Package dev.brachtendorf.jimagehash.hashAlgorithms

Class AverageKernelHash

  • All Implemented Interfaces:
    Serializable
    public class AverageKernelHash
extends AverageHash
    Calculate a hash value based on the average luminosity in an image. The kernel hash variant applies additional kernels to the already rescaled version of the image.

    Be aware that to guarantee hash consistency the supplied kernels supplied are implicitly assumed to be immutable. Do NOT change the settings of kernels after adding them to the hashing algorithm or else hash collections as well as trouble with the database image matchers may arise.

    Author:
    Kilian
    See Also:
    Serialized Form

    • Constructor Detail

      • AverageKernelHash

        public AverageKernelHash​(int bitResolution)
        Parameters:
        bitResolution - The bit resolution specifies the final length of the generated hash. A higher resolution will increase computation time and space requirement while being able to track finer detail in the image. Be aware that a high key is not always desired.

        The average kernel hash will produce a hash with at least the number of bits defined by this argument. In turn this also means that different bit resolutions may be mapped to the same final key length. 

          64 = 8x8 = 65 bit key
  128 = 11.3 -> 12 -> 144 bit key
  256 = 16 x 16 = 256 bit key

      • AverageKernelHash

        public AverageKernelHash​(int bitResolution,
                         Kernel... kernels)
        Parameters:
        bitResolution - The bit resolution specifies the final length of the generated hash. A higher resolution will increase computation time and space requirement while being able to track finer detail in the image. Be aware that a high key is not always desired.

        The average hash requires to re scale the base image according to the required bit resolution. If the square root of the bit resolution is not a natural number the resolution will be rounded to the next whole number.

        The average hash will produce a hash with at least the number of bits defined by this argument. In turn this also means that different bit resolutions may be mapped to the same final key length. 
          64 = 8x8 = 65 bit key
  128 = 11.3 -> 12 -> 144 bit key
  256 = 16 x 16 = 256 bit key
        kernels - applied before the rescaled image is compared to the filter Since raw luminosity values are compared to the computed kernel value the kernel should be in the same range

    • Method Detail

      • hash

        protected BigInteger hash​(BufferedImage image,
                          HashBuilder hash)
        Description copied from class: HashingAlgorithm
        Calculate a hash for the given image. Invoking the hash function on the same image has to return the same hash value. A comparison of the hashes relates to the similarity of the images. The lower the value the more similar the images are. Equal images will produce a similarity of 0.

        This method is intended to be overwritten by implementations and takes a baseHash argument to allow concatenating multiple hashes as well to be able to compute the effective hash length in HashingAlgorithm.getKeyResolution(). Preceding 0's are omitted in big integer objects, while the usual hamming distance can be calculated due to xoring without issue the normalized distance requires the potential length of the key to be known.

        Overrides:
        hash in class AverageHash
        Parameters:
        image - Image whose hash will be calculated
        hash - a hash builder used to construct the hash
        Returns:
        the hash encoded as a big integer

      • precomputeAlgoId

        protected int precomputeAlgoId()
        Description copied from class: HashingAlgorithm
        A unique id identifying the settings and algorithms used to generate the output result. This method shall contain a hash code for the object which
        • Stays consistent throughout restart of the jvm
        • Value does not change after the constructor finished
        • Must return the same value if two instances compute the same hashes for identical input

        Even if different bitResolutions are used in the constructor HashingAlgorithm(int) the algorithId MUST return the same id for two instances if the returned hashes for the same input will always be equal. Therefore instead of checking against the bitResolution the actual resolution as returned by HashingAlgorithm.getKeyResolution() should be used. This method algorithm id's as information available to the child class and will be extended by the hashcode of the kernels.

        Overrides:
        precomputeAlgoId in class AverageHash
        Returns:
        the preliminary algorithm id identifying this hashing algorithm