docs: public String getDHash(String object) {
  
  		/* OpenCV does not work if you have encoded URLs (e.g., %20 instead of space in the path)
  		 * This fixes the following error:
  		 * CvException [org.opencv.core.CvException: cv::Exception: OpenCV(3.4.3) ...
  		 * error: (-215:Assertion failed) !ssize.empty() in function 'resize'
  		 */
  		try {
  			object = new URI(object).getPath();
  		} catch (URISyntaxException e) {
  			e.printStackTrace();
  		}
  
  		/*
  		 * 1. Convert to grayscale. The first step is to convert the input image to grayscale and
  		 * discard any color information. Discarding color enables us to: (1) Hash the image faster
  		 * since we only have to examine one channel (2) Match images that are identical but have
  		 * slightly altered color spaces (since color information has been removed). If, for
  		 * whatever reason, one is interested in keeping the color information, he can run the
  		 * hashing algorithm on each channel independently and then combine at the end (although
  		 * this will result in a 3x larger hash).
  		 */
  		Mat objectImage = Imgcodecs.imread(object, Imgcodecs.CV_LOAD_IMAGE_GRAYSCALE);
  
  		/*
  		 * 2. Resize image. We squash the image down to 9×8 and ignore aspect ratio to ensure that
  		 * the resulting image hash will match similar photos regardless of their initial spatial
  		 * dimensions. Why 9×8? We are implementing difference hash. The difference hash algorithm
  		 * works by computing the difference (i.e., relative gradients) between adjacent pixels. If
  		 * we take an input image with 9 pixels per row and compute the difference between adjacent
  		 * column pixels, we end up with 8 differences. Eight rows of eight differences (i.e., 8×8)
  		 * is 64 which will become our 64-bit hash.
  		 */
  		Mat resized = new Mat();
  		int size = 8;
  		Imgproc.resize(objectImage, resized, new Size(size + 1, size));
  
  		/*
  		 * 3. Compute the difference image. The difference hash algorithm works by computing the
  		 * difference (i.e., relative gradients) between adjacent pixels. In practice we don't
  		 * actually have to compute the difference — we can apply a “greater than” test (or “less
  		 * than”, it doesn't really matter as long as the same operation is consistently used).
  		 */
  		String hash = "";
  
  		for (int i = 0; i < resized.rows(); i++) {
  
  			for (int j = 0; j < resized.cols() - 1; j++) {
  
  				double[] pixel_left = resized.get(i, j);
  				double[] pixel_right = resized.get(i, j + 1);
  
  				hash += (pixel_left[0] > pixel_right[0] ? "1" : "0");
  
  			}
  		}
  
  		LOG.info("DHash: " + hash);
  		return hash;
  	}