Refactor: Cleanup and performance enhancements

* Full imageHash calculation improved between 10-20% with greater performance enhancements for larger images.
* Cleaned up code
* Reduced code duplication
* Adapted engine to hash lib 0.2.0
* Adjusted library versions where appropriate

engine/src/main/scala/com/sothr/imagetools/engine/ConcurrentEngine.scala

@@ -7,10 +7,9 @@ import akka.actor.{Actor, ActorLogging, ActorRef, PoisonPill, Props}
 import akka.pattern.ask
 import akka.routing.{Broadcast, RoundRobinPool, SmallestMailboxPool}
 import akka.util.Timeout
-import com.sothr.imagetools.hash.HashService
+import com.sothr.imagetools.hash.{HashService, ImageHash}
 import com.sothr.imagetools.engine.image.{Image, ImageService, SimilarImages}
 import com.sothr.imagetools.engine.util.{PropertiesService, PropertyEnum}
-import com.sothr.imagetools.hash.dto.ImageHashDTO
 
 import scala.collection.mutable
 import scala.concurrent.Await

engine/src/main/scala/com/sothr/imagetools/engine/image/ImageService.scala

@@ -8,8 +8,7 @@ import com.sothr.imagetools.engine.AppConfig
 import com.sothr.imagetools.engine.dao.ImageDAO
 import com.sothr.imagetools.engine.util.{PropertiesService, PropertyEnum}
 import com.sothr.imagetools.engine.vo.ImageHashVO
-import com.sothr.imagetools.hash.HashService
-import com.sothr.imagetools.hash.dto.ImageHashDTO
+import com.sothr.imagetools.hash.{HashService, ImageHash}
 import com.sothr.imagetools.hash.util.ImageUtil
 import grizzled.slf4j.Logging
 import net.sf.ehcache.Element
@@ -36,8 +35,8 @@ object ImageService extends Logging {
           bufferedImage,
           file.getAbsolutePath)
 
-        var thumbnailPath = lookupThumbnailPath(hashes.getFileHash)
-        if (thumbnailPath == null) thumbnailPath = getThumbnail(bufferedImage, hashes.getFileHash)
+        var thumbnailPath = lookupThumbnailPath(hashes.fileHash)
+        if (thumbnailPath == null) thumbnailPath = getThumbnail(bufferedImage, hashes.fileHash)
         val imageSize = {
           (bufferedImage.getWidth, bufferedImage.getHeight)
         }
@@ -52,11 +51,11 @@ object ImageService extends Logging {
     null
   }
 
-  def convertToImageHashDTO(imageHashVO: ImageHashVO): ImageHashDTO = {
-    new ImageHashDTO(imageHashVO.ahash, imageHashVO.dhash, imageHashVO.phash, imageHashVO.fileHash)
+  def convertToImageHashDTO(imageHashVO: ImageHashVO): ImageHash = {
+    new ImageHash(imageHashVO.ahash, imageHashVO.dhash, imageHashVO.phash, imageHashVO.fileHash)
   }
 
-  def convertToImageHashVO(imageHashDTO: ImageHashDTO): ImageHashVO = {
+  def convertToImageHashVO(imageHashDTO: ImageHash): ImageHashVO = {
     new ImageHashVO(imageHashDTO.ahash, imageHashDTO.dhash, imageHashDTO.phash, imageHashDTO.fileHash)
   }
 

engine/src/main/scala/com/sothr/imagetools/engine/util/PropertiesService.scala

@@ -3,7 +3,7 @@ package com.sothr.imagetools.engine.util
 import java.io.{File, FileOutputStream, PrintStream}
 import java.util.Properties
 
-import com.sothr.imagetools.hash.dto.HashSettingDTO
+import com.sothr.imagetools.hash.HashSetting
 import com.typesafe.config.{Config, ConfigFactory, ConfigRenderOptions}
 import grizzled.slf4j.Logging
 
@@ -13,19 +13,19 @@ import grizzled.slf4j.Logging
 object PropertiesService extends Logging {
 
   //OS information
-  val OS = System.getProperty("os.name", "UNKNOWN")
-  val OS_VERSION = System.getProperty("os.version", "UNKNOWN")
-  val OS_ARCH = System.getProperty("os.arch", "UNKNOWN")
+  val OS: String = System.getProperty("os.name", "UNKNOWN")
+  val OS_VERSION: String = System.getProperty("os.version", "UNKNOWN")
+  val OS_ARCH: String = System.getProperty("os.arch", "UNKNOWN")
   private val newUserConf: Properties = new Properties()
   private val configRenderOptions = ConfigRenderOptions.concise().setFormatted(true)
   //specific highly used properties
   var TimingEnabled: Boolean = false
-  var aHashSettings = new HashSettingDTO(false, 0, 0, 0.0f)
-  var dHashSettings = new HashSettingDTO(false, 0, 0, 0.0f)
-  var pHashSettings = new HashSettingDTO(false, 0, 0, 0.0f)
-  private var defaultConf: Config = null
-  private var userConf: Config = null
-  private var version: Version = null
+  var aHashSettings = new HashSetting("AHash", false, 0, 0, 0.0f)
+  var dHashSettings = new HashSetting("DHash", false, 0, 0, 0.0f)
+  var pHashSettings = new HashSetting("PHash", false, 0, 0, 0.0f)
+  private var defaultConf: Config = _
+  private var userConf: Config = _
+  private var version: Version = _
 
   def getVersion: Version = this.version
 
@@ -47,21 +47,24 @@ object PropertiesService extends Logging {
     //load special properties
     TimingEnabled = get(PropertyEnum.Timed.toString).toBoolean
 
-    aHashSettings = new HashSettingDTO(
+    aHashSettings = new HashSetting(
+      "AHash",
       get(PropertyEnum.UseAhash.toString).toBoolean,
       get(PropertyEnum.AhashPrecision.toString).toInt,
       get(PropertyEnum.AhashTolerance.toString).toInt,
       get(PropertyEnum.AhashWeight.toString).toFloat
     )
 
-    dHashSettings = new HashSettingDTO(
+    dHashSettings = new HashSetting(
+      "DHash",
       get(PropertyEnum.UseDhash.toString).toBoolean,
       get(PropertyEnum.DhashPrecision.toString).toInt,
       get(PropertyEnum.DhashTolerance.toString).toInt,
       get(PropertyEnum.DhashWeight.toString).toFloat
     )
 
-    pHashSettings = new HashSettingDTO(
+    pHashSettings = new HashSetting(
+      "PHash",
       get(PropertyEnum.UsePhash.toString).toBoolean,
       get(PropertyEnum.PhashPrecision.toString).toInt,
       get(PropertyEnum.PhashTolerance.toString).toInt,

hash/pom.xml

@@ -12,7 +12,7 @@
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>hash</artifactId>
-    <version>0.1.1</version>
+    <version>0.2.0</version>
     <packaging>jar</packaging>
 
     <name>ImageTools-Hash</name>
@@ -57,6 +57,11 @@
             <artifactId>scalatest_${scala.binary.version}</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>

hash/src/main/scala/com/sothr/imagetools/hash/HashService.scala

@@ -5,7 +5,6 @@ import java.io.{File, FileInputStream}
 import javax.imageio.ImageIO
 
 import com.sothr.imagetools.hash.`type`.{AHash, DHash, PHash}
-import com.sothr.imagetools.hash.dto.{HashSettingDTO, ImageHashDTO}
 import com.sothr.imagetools.hash.util.{HammingUtil, ImageUtil}
 import grizzled.slf4j.Logging
 import org.apache.commons.codec.digest.DigestUtils
@@ -18,88 +17,159 @@ import resource.managed
   */
 object HashService extends Logging {
 
-  def getImageHashes(ahashSettings: HashSettingDTO,
-                     dhashSettings: HashSettingDTO,
-                     phashSettings: HashSettingDTO,
-                     imagePath: String): ImageHashDTO = {
-    getImageHashes(ahashSettings, dhashSettings, phashSettings, ImageIO.read(new File(imagePath)), imagePath)
+	/**
+	  * Given hash settings and an image path, calculate the perceptual hashes
+	  *
+	  * @param ahashSettings { @see com.sothr.imagetools.hash.HashSetting}
+	  * @param dhashSettings { @see com.sothr.imagetools.hash.HashSetting}
+	  * @param phashSettings { @see com.sothr.imagetools.hash.HashSetting}
+	  * @param imagePath     Absolute path to the image file
+	  * @return { @see com.sothr.imagetools.hash.ImageHash}
+	  */
+	def getImageHashes(ahashSettings: HashSetting,
+	                   dhashSettings: HashSetting,
+	                   phashSettings: HashSetting,
+	                   imagePath: String): ImageHash = {
+		getImageHashes(ahashSettings,
+			dhashSettings,
+			phashSettings,
+			ImageIO.read(new File(imagePath)),
+			imagePath)
+	}
+
+	def getPrecisionMap(precisionSet: Set[Int], grayImage: BufferedImage): Map[Int, Array[Array[Int]]] = {
+		precisionSet.map(p => p -> getImageData(p, grayImage, alreadyGray = true))(collection.breakOut)
 	}
 
-  def getImageHashes(ahashSettings: HashSettingDTO,
-                     dhashSettings: HashSettingDTO,
-                     phashSettings: HashSettingDTO,
+	/**
+	  * Given hash settings, a buffered image and an image path, calculate the perceptual hashes
+	  *
+	  * @param ahashSettings { @see com.sothr.imagetools.hash.HashSetting}
+	  * @param dhashSettings { @see com.sothr.imagetools.hash.HashSetting}
+	  * @param phashSettings { @see com.sothr.imagetools.hash.HashSetting}
+	  * @param image         { @see java.awt.image.BufferedImage}
+	  * @param imagePath     Absolute path to the image file
+	  * @return { @see com.sothr.imagetools.hash.ImageHash}
+	  *
+	  */
+	def getImageHashes(ahashSettings: HashSetting,
+	                   dhashSettings: HashSetting,
+	                   phashSettings: HashSetting,
 	                   image: BufferedImage,
-                     imagePath: String): ImageHashDTO = {
+	                   imagePath: String): ImageHash = {
 
 		debug(s"Creating hashes for $imagePath")
 
-    var ahash: Long = 0L
-    var dhash: Long = 0L
-    var phash: Long = 0L
-    val sha1: String = getSHA1(imagePath)
-
 		//Get Image Data
 		val grayImage = ImageUtil.convertToGray(image)
 
-    if (ahashSettings.use) {
-      ahash = getAhash(ahashSettings, grayImage, alreadyGray = true)
-    }
-    if (dhashSettings.use) {
-      dhash = getDhash(dhashSettings, grayImage, alreadyGray = true)
-    }
-    if (phashSettings.use) {
-      phash = getPhash(phashSettings, grayImage, alreadyGray = true)
-    }
+		val precisionSet: Set[Int] = getPrecisionSet(ahashSettings, dhashSettings, phashSettings)
+		val precisionMap: Map[Int, Array[Array[Int]]] = getPrecisionMap(precisionSet, grayImage)
+
+		val ahash: Long = if (ahashSettings.use && precisionMap.contains(ahashSettings.precision))
+			getHash(ahashSettings, precisionMap(ahashSettings.precision), AHash.getHash)
+		else 0l
+
+		val dhash: Long = if (dhashSettings.use && precisionMap.contains(dhashSettings.precision))
+			getHash(dhashSettings, precisionMap(dhashSettings.precision), DHash.getHash)
+		else 0l
+
+		val phash: Long = if (phashSettings.use && precisionMap.contains(phashSettings.precision))
+			getHash(phashSettings, precisionMap(phashSettings.precision), PHash.getHash)
+		else 0l
+
+		val sha1: String = getSHA1(imagePath)
 
-    val hashes = new ImageHashDTO(ahash, dhash, phash, sha1)
+		val hashes = new ImageHash(ahash, dhash, phash, sha1)
 		debug(s"Generated hashes: $hashes")
 
 		hashes
 	}
 
-  def getAhash(hashSettings: HashSettingDTO, image: BufferedImage, alreadyGray: Boolean = false): Long = {
-    //debug("Started generating an AHash")
+	def getSHA1(filePath: String): String = {
+		managed(new FileInputStream(filePath)) acquireAndGet {
+			input => DigestUtils.sha1Hex(input)
+		}
+	}
+
+	def getPrecisionSet(ahashSettings: HashSetting, dhashSettings: HashSetting, phashSettings: HashSetting): Set[Int] = {
+		Set(
+			if (ahashSettings.use) Option(ahashSettings.precision) else None,
+			if (dhashSettings.use) Option(dhashSettings.precision) else None,
+			if (phashSettings.use) Option(phashSettings.precision) else None
+		).flatten
+	}
+
+	def getImageData(precision: Int, image: BufferedImage, alreadyGray: Boolean): Array[Array[Int]] = {
 		var grayImage: BufferedImage = null
+
 		if (alreadyGray) {
 			grayImage = image
 		} else {
 			grayImage = ImageUtil.convertToGray(image)
 		}
-    val resizedImage = ImageUtil.resize(grayImage, hashSettings.precision, forced = true)
-    val imageData = ImageUtil.getImageData(resizedImage)
-    AHash.getHash(imageData)
+
+		val resizedImage = ImageUtil.resize(grayImage, precision, forced = true)
+		ImageUtil.getImageData(resizedImage)
 	}
 
-  def getDhash(hashSettings: HashSettingDTO, image: BufferedImage, alreadyGray: Boolean = false): Long = {
-    //debug("Started generating an DHash")
-    var grayImage: BufferedImage = null
-    if (alreadyGray) {
-      grayImage = image
+	/**
+	  * Simpler function that only works with the imageData and the hashFunction
+	  *
+	  * @param hashSettings
+	  * @param imageData
+	  * @param hashFunction
+	  * @return
+	  */
+	def getHash(hashSettings: HashSetting, imageData: Array[Array[Int]], hashFunction: Array[Array[Int]] => Long): Long = {
+		if (hashSettings.use) {
+			val hashResult = hashFunction(imageData)
+			trace(s"${hashSettings.name} result: $hashResult")
+			hashResult
 		} else {
-      grayImage = ImageUtil.convertToGray(image)
+			0l
 		}
-    val resizedImage = ImageUtil.resize(grayImage, hashSettings.precision, forced = true)
-    val imageData = ImageUtil.getImageData(resizedImage)
-    DHash.getHash(imageData)
 	}
 
-  def getPhash(hashSettings: HashSettingDTO, image: BufferedImage, alreadyGray: Boolean = false): Long = {
-    //debug("Started generating an PHash")
+	def getAhash(hashSettings: HashSetting, image: BufferedImage, alreadyGray: Boolean = false): Long = {
+		getHash(hashSettings, image, alreadyGray, AHash.getHash)
+	}
+
+	/**
+	  * Internal function to retrieve the hash from a processed image, for a given hash function
+	  *
+	  * @param hashSettings A HashSettings that is used for the processing parameters of the Image
+	  * @param image        BufferedImage representing the image data to calculate the hash for
+	  * @param alreadyGray  Indicator that the grayscale processing has already been applied to the incoming image
+	  * @param hashFunction The function accepting an two dimensional array of Int and returning the hash of the data
+	  * @return
+	  */
+	def getHash(hashSettings: HashSetting, image: BufferedImage, alreadyGray: Boolean = false, hashFunction: Array[Array[Int]] => Long): Long = {
+		if (hashSettings.use) {
 			var grayImage: BufferedImage = null
+
 			if (alreadyGray) {
 				grayImage = image
 			} else {
 				grayImage = ImageUtil.convertToGray(image)
 			}
+
 			val resizedImage = ImageUtil.resize(grayImage, hashSettings.precision, forced = true)
-    val imageData = ImageUtil.getImageData(resizedImage)
-    PHash.getHash(imageData)
+			val hashResult = hashFunction(ImageUtil.getImageData(resizedImage))
+			trace(s"${hashSettings.name} result: $hashResult")
+			hashResult
+		} else {
+			trace(s"${hashSettings.name} result: DISABLED")
+			0l
+		}
 	}
 
-  def getSHA1(filePath: String): String = {
-    managed(new FileInputStream(filePath)) acquireAndGet {
-      input => DigestUtils.sha1Hex(input)
+	def getDhash(hashSettings: HashSetting, image: BufferedImage, alreadyGray: Boolean = false): Long = {
+		getHash(hashSettings, image, alreadyGray, DHash.getHash)
 	}
+
+	def getPhash(hashSettings: HashSetting, image: BufferedImage, alreadyGray: Boolean = false): Long = {
+		getHash(hashSettings, image, alreadyGray, PHash.getHash)
 	}
 
 	def getMD5(filePath: String): String = {
@@ -108,79 +178,79 @@ object HashService extends Logging {
 		}
 	}
 
-  def areHashSimilar(hashSettings: HashSettingDTO, hash1: Long, hash2: Long): Boolean = {
-    val tolerence = hashSettings.tolerance
+	def areHashSimilar(hashSettings: HashSetting, hash1: Long, hash2: Long): Boolean = {
+		val tolerance = hashSettings.tolerance
 		val distance = HammingUtil.getDistance(hash1, hash2)
-    if (distance <= tolerence) true else false
+		if (distance <= tolerance) true else false
 	}
 
-  def areImageHashesSimilar(ahashSettings: HashSettingDTO,
-                            dhashSettings: HashSettingDTO,
-                            phashSettings: HashSettingDTO,
-                            imageHash1: ImageHashDTO,
-                            imageHash2: ImageHashDTO): Boolean = {
+	def areImageHashesSimilar(ahashSettings: HashSetting,
+	                          dhashSettings: HashSetting,
+	                          phashSettings: HashSetting,
+	                          imageHash1: ImageHash,
+	                          imageHash2: ImageHash): Boolean = {
 		val weightedHammingMean = getWeightedHashSimilarity(ahashSettings, dhashSettings, phashSettings, imageHash1, imageHash2)
-    val weightedToleranceMean = getWeightedHashTolerence(ahashSettings, dhashSettings, phashSettings)
+		val weightedToleranceMean = getWeightedHashTolerance(ahashSettings, dhashSettings, phashSettings)
 		if (weightedHammingMean <= weightedToleranceMean) true else false
 	}
 
-  def getWeightedHashSimilarity(ahashSettings: HashSettingDTO,
-                                dhashSettings: HashSettingDTO,
-                                phashSettings: HashSettingDTO,
-                                imageHash1: ImageHashDTO,
-                                imageHash2: ImageHashDTO): Float = {
-    //calculate weighted values
-    var weightedHammingTotal: Float = 0
-    var methodsTotal = 0
-
-    if (ahashSettings.use) {
-      val hamming = HammingUtil.getDistance(imageHash1.ahash, imageHash2.ahash)
-      weightedHammingTotal += hamming * ahashSettings.weight
-      trace(s"hash1: ${imageHash1.ahash} hash2: ${imageHash1.ahash} tolerance: ${ahashSettings.tolerance} hamming distance: $hamming weight: ${ahashSettings.weight}")
-      methodsTotal += 1
-    }
-    if (dhashSettings.use) {
-      val hamming = HammingUtil.getDistance(imageHash1.dhash, imageHash2.dhash)
-      weightedHammingTotal += hamming * dhashSettings.weight
-      trace(s"hash1: ${imageHash1.dhash} hash2: ${imageHash1.dhash} tolerance: ${dhashSettings.tolerance} hamming distance: $hamming weight: ${dhashSettings.weight}")
-      methodsTotal += 1
-    }
-    if (phashSettings.use) {
-      val hamming = HammingUtil.getDistance(imageHash1.phash, imageHash2.phash)
-      weightedHammingTotal += hamming * phashSettings.weight
-      trace(s"hash1: ${imageHash1.phash} hash2: ${imageHash1.phash} tolerance: ${phashSettings.tolerance} hamming distance: $hamming weight: ${phashSettings.weight}")
-      methodsTotal += 1
-    }
-    val weightedHammingMean = weightedHammingTotal / methodsTotal
+	def getWeightedHashSimilarity(ahashSettings: HashSetting,
+	                              dhashSettings: HashSetting,
+	                              phashSettings: HashSetting,
+	                              imageHash1: ImageHash,
+	                              imageHash2: ImageHash): Float = {
+
+		val (weightedHammingTotal1, methodsTotal1) = sumWeightedHammingAndMethodCount(ahashSettings, imageHash1.ahash, imageHash2.ahash, 0f, 0)
+		val (weightedHammingTotal2, methodsTotal2) = sumWeightedHammingAndMethodCount(dhashSettings, imageHash1.dhash, imageHash2.dhash, weightedHammingTotal1, methodsTotal1)
+		val (weightedHammingTotalFinal, methodsTotalFinal) = sumWeightedHammingAndMethodCount(phashSettings, imageHash1.phash, imageHash2.phash, weightedHammingTotal2, methodsTotal2)
+
+		val weightedHammingMean = weightedHammingTotalFinal / methodsTotalFinal
 		debug(s"Calculated Weighted HammingUtil Mean: $weightedHammingMean")
 		weightedHammingMean
 	}
 
-  def getWeightedHashTolerence(ahashSettings: HashSettingDTO,
-                               dhashSettings: HashSettingDTO,
-                               phashSettings: HashSettingDTO): Float = {
-    //calculate weighted values
-    var weightedToleranceTotal: Float = 0
-    var methodsTotal = 0
-
-    if (ahashSettings.use) {
-      weightedToleranceTotal += ahashSettings.tolerance * ahashSettings.weight
-      trace(s"Ahash Tolerance: ${ahashSettings.tolerance} Current Weighted Tolerance: $weightedToleranceTotal")
-      methodsTotal += 1
+	def sumWeightedHammingAndMethodCount(hashSettings: HashSetting, hash1: Long, hash2: Long, weightedHamming: Float, methodCount: Int): (Float, Int) = {
+		val (newWeightedHamming, newMethodCount) = getWeightedHamming(hashSettings, hash1, hash2)
+		(weightedHamming + newWeightedHamming, methodCount + newMethodCount)
 	}
-    if (dhashSettings.use) {
-      weightedToleranceTotal += dhashSettings.tolerance * dhashSettings.weight
-      trace(s"Dhash Tolerance: ${dhashSettings.tolerance} Current Weighted Tolerance: $weightedToleranceTotal")
-      methodsTotal += 1
+
+	def getWeightedHamming(hashSettings: HashSetting, hash1: Long, hash2: Long): (Float, Int) = {
+		if (hashSettings.use) {
+			val hamming = HammingUtil.getDistance(hash1, hash2)
+			trace(s"${hashSettings.name} Hamming: hash1: $hash1 hash2: $hash2 tolerance: ${hashSettings.tolerance} hamming distance: $hamming weight: ${hashSettings.weight}")
+			(hamming * hashSettings.weight, 1)
+		} else {
+			trace(s"${hashSettings.name} Hamming: DISABLED")
+			(0f, 0)
 		}
-    if (phashSettings.use) {
-      weightedToleranceTotal += phashSettings.tolerance * phashSettings.weight
-      trace(s"Phash Tolerance: ${phashSettings.tolerance} Current Weighted Tolerance: $weightedToleranceTotal")
-      methodsTotal += 1
 	}
-    val weightedTolerance = weightedToleranceTotal / methodsTotal
+
+	def getWeightedHashTolerance(ahashSettings: HashSetting,
+	                             dhashSettings: HashSetting,
+	                             phashSettings: HashSetting): Float = {
+
+		val (weightedToleranceTotal1, methodsTotal1) = sumWeightedToleranceAndMethodCount(ahashSettings, 0f, 0)
+		val (weightedToleranceTotal2, methodsTotal2) = sumWeightedToleranceAndMethodCount(dhashSettings, weightedToleranceTotal1, methodsTotal1)
+		val (weightedToleranceTotalFinal, methodsTotalFinal) = sumWeightedToleranceAndMethodCount(phashSettings, weightedToleranceTotal2, methodsTotal2)
+
+		val weightedTolerance = weightedToleranceTotalFinal / methodsTotalFinal
 		debug(s"Calculated Weighted Tolerance: $weightedTolerance")
 		weightedTolerance
 	}
 
+	def sumWeightedToleranceAndMethodCount(hashSettings: HashSetting, weightedTolerance: Float, methodCount: Int): (Float, Int) = {
+		val (newWeightedTolerance, newMethodCount) = getWeightedTolerance(hashSettings)
+		(weightedTolerance + newWeightedTolerance, methodCount + newMethodCount)
+	}
+
+	def getWeightedTolerance(hashSettings: HashSetting): (Float, Int) = {
+		if (hashSettings.use) {
+			val weightedTolerance = hashSettings.tolerance * hashSettings.weight
+			trace(s"${hashSettings.name} Tolerance: ${hashSettings.tolerance} Current Weighted Tolerance: $weightedTolerance")
+			(weightedTolerance, 1)
+		} else {
+			trace(s"${hashSettings.name} Tolerance: DISABLED")
+			(0f, 0)
+		}
+	}
 }

hash/src/main/scala/com/sothr/imagetools/hash/HashSetting.scala

@@ -0,0 +1,8 @@
+package com.sothr.imagetools.hash
+
+class HashSetting(val name: String,
+                  val use: Boolean,
+                  val precision: Int,
+                  val tolerance: Int,
+                  val weight: Float) {
+}

hash/src/main/scala/com/sothr/imagetools/hash/ImageHash.scala

@@ -0,0 +1,25 @@
+package com.sothr.imagetools.hash
+
+import grizzled.slf4j.Logging
+
+class ImageHash(val ahash: Long,
+                val dhash: Long,
+                val phash: Long,
+                val fileHash: String) extends Serializable with Logging {
+
+	def cloneHashes: ImageHash = {
+		new ImageHash(ahash, dhash, phash, fileHash)
+	}
+
+	override def hashCode(): Int = {
+		var result = 365
+		result = 41 * result + (this.ahash ^ (this.ahash >>> 32)).toInt
+		result = 37 * result + (this.dhash ^ (this.dhash >>> 32)).toInt
+		result = 2 * result + (this.phash ^ (this.phash >>> 32)).toInt
+		result
+	}
+
+	override def toString: String = {
+		s"fileHash: $fileHash ahash: $ahash dhash: $dhash phash: $phash"
+	}
+}

hash/src/main/scala/com/sothr/imagetools/hash/dto/HashSettingDTO.scala

@@ -1,8 +0,0 @@
-package com.sothr.imagetools.hash.dto
-
-class HashSettingDTO(
-                      val use: Boolean,
-                      val precision: Int,
-                      val tolerance: Int,
-                      val weight: Float) {
-}

hash/src/main/scala/com/sothr/imagetools/hash/dto/ImageHashDTO.scala

@@ -1,46 +0,0 @@
-package com.sothr.imagetools.hash.dto
-
-import grizzled.slf4j.Logging
-
-class ImageHashDTO(var ahash: Long, var dhash: Long, var phash: Long, var fileHash: String) extends Serializable with Logging {
-
-  def getAhash: Long = ahash
-
-  def setAhash(hash: Long) = {
-    ahash = hash
-  }
-
-  def getDhash: Long = dhash
-
-  def setDhash(hash: Long) = {
-    dhash = hash
-  }
-
-  def getPhash: Long = phash
-
-  def setPhash(hash: Long) = {
-    phash = hash
-  }
-
-  def getFileHash: String = fileHash
-
-  def setFileHash(hash: String) = {
-    fileHash = hash
-  }
-
-  def cloneHashes: ImageHashDTO = {
-    new ImageHashDTO(ahash, dhash, phash, fileHash)
-  }
-
-  override def hashCode(): Int = {
-    var result = 365
-    result = 41 * result + (this.ahash ^ (this.ahash >>> 32)).toInt
-    result = 37 * result + (this.dhash ^ (this.dhash >>> 32)).toInt
-    result = 2 * result + (this.phash ^ (this.phash >>> 32)).toInt
-    result
-  }
-
-  override def toString: String = {
-    s"fileHash: $fileHash ahash: $ahash dhash: $dhash phash: $phash"
-  }
-}

hash/src/main/scala/com/sothr/imagetools/hash/type/AHash.scala

@@ -4,7 +4,7 @@ import grizzled.slf4j.Logging
 
 /**
   * Speedy AHash Perceptual Hashing
- * Uses the average value of the pixels as a baseline
+  * Uses the average value of the pixels as a baseline to determine the structure of the image
   *
   * Created by dev on 1/22/14.
   */
@@ -15,7 +15,9 @@ object AHash extends PerceptualHasher with Logging {
 		val height = imageData(0).length
 		trace(s"Image data size: ${width}x$height")
 
-    //calculate average pixel
+		/*
+		Average Pixel Calculation
+		 */
 		var total = 0
 		for (row <- 0 until height) {
 			for (col <- 0 until width) {
@@ -24,20 +26,19 @@ object AHash extends PerceptualHasher with Logging {
 		}
 		val mean = total / (height * width)
 
-    //calculate ahash
+		/*
+		For each pixel, if it is at or above the average, store it as a one, else store it as a zero
+		 */
 		var hash = 0L
 		for (row <- 0 until height by 2) {
-      //process each column
 			for (col <- 0 until width by 1) {
 				hash <<= 1
 				val pixel = imageData(row)(col)
-        //If the current pixel is at or above the mean, store it as a one, else store it as a zero
 				if (pixel >= mean) hash |= 1 else hash |= 0
 			}
 
 			if ((row + 1) < width) {
 				val nextRow = row + 1
-        //process each column
 				for (col <- (width - 1) to 0 by -1) {
 					hash <<= 1
 					val pixel = imageData(nextRow)(col)

hash/src/main/scala/com/sothr/imagetools/hash/type/DHash.scala

@@ -3,7 +3,9 @@ package com.sothr.imagetools.hash.`type`
 import grizzled.slf4j.Logging
 
 /**
- * DHash algorithm class
+  * DHash algorithm object
+  *
+  * Tracks the differences between pixels in a pattern as the basis of similarity
   *
   * Created by Drew on 1/22/14.
   */

hash/src/main/scala/com/sothr/imagetools/hash/type/PHash.scala

@@ -5,7 +5,7 @@ import grizzled.slf4j.Logging
 
 /**
   * Complex perceptual hash
- * Uses FFT to get
+  * Uses FFT to get structural data out of the image, which can represent the perception of similarity
   *
   * Created by dev on 1/22/14.
   */
@@ -22,14 +22,10 @@ object PHash extends PerceptualHasher with Logging {
 				imageDataFloat(row)(col) = imageData(row)(col).toFloat
 			}
 		}
-    //debug("Copied image data to float array for transform")
-    //debug(s"\n${imageDataFloat.deep.mkString("\n")}")
 
 		//perform transform on the data
 		val dct: FloatDCT_2D = new FloatDCT_2D(height, width)
 		dct.forward(imageDataFloat, true)
-    //debug("Converted image data into DCT")
-    //debug(s"\n${imageDataFloat.deep.mkString("\n")}")
 
 		//extract the DCT data
 		val dctDataWidth: Int = width / 4
@@ -45,14 +41,15 @@ object PHash extends PerceptualHasher with Logging {
 		val mean = total / (dctDataHeight * dctDataWidth)
 		//debug(s"Calculated mean as $mean from ${total}/${dctDataHeight * dctDataWidth}")
 
-    //calculate the hash
+		/*
+		For each pixel, if it is at or above the mean, store it as a one, else store it as a zero
+		 */
 		var hash = 0L
 		for (row <- 0 until dctDataHeight by 2) {
-      //process each column
 			for (col <- 0 until dctDataWidth by 1) {
 				hash <<= 1
 				val pixel = imageDataFloat(row)(col)
-        //If the current pixel is at or above the mean, store it as a one, else store it as a zero
+				//
 				if (pixel >= mean) hash |= 1 else hash |= 0
 			}
 

hash/src/main/scala/com/sothr/imagetools/hash/util/HammingUtil.scala

@@ -14,5 +14,4 @@ object HammingUtil {
 		//then the number of '1's is counted. This is the hamming distance
 		(hash1 ^ hash2).toBinaryString.count(_ == '1')
 	}
-
 }

hash/src/main/scala/com/sothr/imagetools/hash/util/ImageUtil.scala

@@ -113,5 +113,4 @@ object ImageUtil extends Logging {
 		}
 		result
 	}
-
 }

hash/src/main/scala/com/sothr/imagetools/hash/util/TimingUtil.scala

@@ -31,5 +31,4 @@ trait TimingUtil extends Logging {
 		}
 		ag / times.length
 	}
-
 }

hash/src/test/scala/com/sothr/imagetools/hash/BaseTest.scala

@@ -1,9 +0,0 @@
-package com.sothr.imagetools.hash
-
-import com.sothr.imagetools.hash.util.TimingUtil
-import grizzled.slf4j.Logging
-import org.scalatest.{BeforeAndAfter, FunSuite, Inside, Inspectors, Matchers, OptionValues}
-
-abstract class BaseTest extends FunSuite with Matchers with OptionValues with Inside with Inspectors with BeforeAndAfter with Logging with TimingUtil {
-
-}

hash/src/test/scala/com/sothr/imagetools/hash/HashServiceAHashTest.scala

@@ -0,0 +1,93 @@
+package com.sothr.imagetools.hash
+
+import java.io.File
+import javax.imageio.ImageIO
+
+import scala.collection.mutable
+
+class HashServiceAHashTest extends HashServiceBaseTest {
+
+	def ahashTestCase(filePath: String): Long = {
+		val sample = new File(filePath)
+		val image = ImageIO.read(sample)
+		HashService.getAhash(ahashSetting, image)
+	}
+
+	test("Calculate AHash Large Sample Image 1") {
+		debug("Starting 'Calculate AHash Large Sample Image 1' test")
+		val sample = new File(LargeSampleImage1)
+		debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
+		val image = ImageIO.read(sample)
+		debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
+		val hash = HashService.getAhash(ahashSetting, image)
+		debug(s"Testing that $hash = 36070299219713907L")
+		assert(hash == 36070299219713907L)
+	}
+
+	test("Calculate AHash Medium Sample Image 1") {
+		debug("Starting 'Calculate AHash Medium Sample Image 1' test")
+		val sample = new File(MediumSampleImage1)
+		debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
+		val image = ImageIO.read(sample)
+		debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
+		val hash = HashService.getAhash(ahashSetting, image)
+		debug(s"Testing that $hash = 36070299219713907L")
+		assert(hash == 36070299219713907L)
+	}
+
+	test("Calculate AHash Small Sample Image 1") {
+		debug("Starting 'Calculate AHash Small Sample Image 1' test")
+		val sample = new File(SmallSampleImage1)
+		debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
+		val image = ImageIO.read(sample)
+		debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
+		val hash = HashService.getAhash(ahashSetting, image)
+		debug(s"Testing that $hash = 36070299219713907L")
+		assert(hash == 36070299219713907L)
+	}
+
+	test("AHash Of Large, Medium, And Small Sample 1 Must Be Similar") {
+		val largeHash = ahashTestCase(LargeSampleImage1)
+		val mediumHash = ahashTestCase(MediumSampleImage1)
+		val smallHash = ahashTestCase(SmallSampleImage1)
+		assert(HashService.areHashSimilar(ahashSetting, largeHash, mediumHash))
+		assert(HashService.areHashSimilar(ahashSetting, largeHash, smallHash))
+		assert(HashService.areHashSimilar(ahashSetting, mediumHash, smallHash))
+	}
+
+	test("Benchmark AHash") {
+		info("Benchmarking AHash")
+		info("AHash Large Image 3684x2736")
+		val time = new mutable.MutableList[Long]()
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				ahashTestCase(LargeSampleImage1)
+			}
+		}
+
+		val largeMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for large was: $largeMean ms")
+		time.clear()
+		info("AHash Medium Image 1824x1368")
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				ahashTestCase(MediumSampleImage1)
+			}
+		}
+
+		val mediumMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for medium was: $mediumMean ms")
+		time.clear()
+		info("AHash Small Image 912x684")
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				ahashTestCase(SmallSampleImage1)
+			}
+		}
+
+		val smallMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for small was: $smallMean ms")
+		time.clear()
+		assert(true)
+	}
+}

hash/src/test/scala/com/sothr/imagetools/hash/HashServiceBaseTest.scala

@@ -0,0 +1,21 @@
+package com.sothr.imagetools.hash
+
+import com.sothr.imagetools.hash.util.TimingUtil
+import grizzled.slf4j.Logging
+import org.scalatest.{BeforeAndAfter, FunSuite, Inside, Inspectors, Matchers, OptionValues}
+
+abstract class HashServiceBaseTest extends FunSuite with Matchers with OptionValues with Inside with Inspectors with BeforeAndAfter with Logging with TimingUtil {
+
+	// Define the number of runs the benchmarking tests should use
+	val benchmarkRuns = 10
+
+	// The Standard Parameters Used To Benchmark Perceptual hashes
+	val ahashSetting = new HashSetting("AHash", true, 8, 8, 0.75f)
+	val dhashSetting = new HashSetting("DHash", true, 8, 8, 0.85f)
+	val phashSetting = new HashSetting("PHash", true, 32, 8, 1.0f)
+
+	// Base Test Images
+	val LargeSampleImage1 = "sample/sample_01_large.jpg"
+	val MediumSampleImage1 = "sample/sample_01_medium.jpg"
+	val SmallSampleImage1 = "sample/sample_01_small.jpg"
+}

hash/src/test/scala/com/sothr/imagetools/hash/HashServiceDHashTest.scala

@@ -0,0 +1,110 @@
+package com.sothr.imagetools.hash
+
+import java.io.File
+import javax.imageio.ImageIO
+
+import com.sothr.imagetools.hash.`type`.DHash
+
+import scala.collection.mutable
+
+class HashServiceDHashTest extends HashServiceBaseTest {
+
+	def dhashTestCase(filePath: String): Long = {
+		val sample = new File(filePath)
+		val image = ImageIO.read(sample)
+		HashService.getDhash(dhashSetting, image)
+	}
+
+	test("Confirm Largest DHash Output ") {
+		val testData: Array[Array[Int]] = Array(
+			Array(1, 2, 3, 4, 5, 6, 7, 8),
+			Array(16, 15, 14, 13, 12, 11, 10, 9),
+			Array(17, 18, 19, 20, 21, 22, 23, 24),
+			Array(32, 31, 30, 29, 28, 27, 26, 25),
+			Array(33, 34, 35, 36, 37, 38, 39, 40),
+			Array(48, 47, 46, 45, 44, 43, 42, 41),
+			Array(49, 50, 51, 52, 53, 54, 55, 56),
+			Array(64, 63, 62, 61, 60, 59, 58, 57))
+		val hash = DHash.getHash(testData)
+		debug(s"Hash of test array: $hash")
+		assert(hash == Long.MaxValue)
+	}
+
+	test("Calculate DHash Large Sample Image 1") {
+		debug("Starting 'Calculate DHash Large Sample Image 1' test")
+		val sample = new File(LargeSampleImage1)
+		debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
+		val image = ImageIO.read(sample)
+		debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
+		val hash = HashService.getDhash(dhashSetting, image)
+		debug(s"Testing that $hash = 4004374827879799635L")
+		assert(hash == 4004374827879799635L)
+	}
+
+	test("Calculate DHash Medium Sample Image 1") {
+		debug("Starting 'Calculate DHash Medium Sample Image 1' test")
+		val sample = new File(MediumSampleImage1)
+		debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
+		val image = ImageIO.read(sample)
+		debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
+		val hash = HashService.getDhash(dhashSetting, image)
+		debug(s"Testing that $hash = 4004374827879799635L")
+		assert(hash == 4004374827879799635L)
+	}
+
+	test("Calculate DHash Small Sample Image 1") {
+		debug("Starting 'Calculate DHash Small Sample Image 1' test")
+		val sample = new File(SmallSampleImage1)
+		debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
+		val image = ImageIO.read(sample)
+		debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
+		val hash = HashService.getDhash(dhashSetting, image)
+		debug(s"Testing that $hash = 4004383623972821843L")
+		assert(hash == 4004383623972821843L)
+	}
+
+	test("DHash Of Large, Medium, And Small Sample 1 Must Be Similar") {
+		val largeHash = dhashTestCase(LargeSampleImage1)
+		val mediumHash = dhashTestCase(MediumSampleImage1)
+		val smallHash = dhashTestCase(SmallSampleImage1)
+		assert(HashService.areHashSimilar(dhashSetting, largeHash, mediumHash))
+		assert(HashService.areHashSimilar(dhashSetting, largeHash, smallHash))
+		assert(HashService.areHashSimilar(dhashSetting, mediumHash, smallHash))
+	}
+
+	test("Benchmark DHash") {
+		info("Benchmarking DHash")
+		info("DHash Large Image 3684x2736")
+		val time = new mutable.MutableList[Long]()
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				dhashTestCase(LargeSampleImage1)
+			}
+		}
+
+		val largeMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for large was: $largeMean ms")
+		time.clear()
+		info("DHash Medium Image 1824x1368")
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				dhashTestCase(MediumSampleImage1)
+			}
+		}
+
+		val mediumMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for medium was: $mediumMean ms")
+		time.clear()
+		info("DHash Small Image 912x684")
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				dhashTestCase(SmallSampleImage1)
+			}
+		}
+
+		val smallMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for small was: $smallMean ms")
+		time.clear()
+		assert(true)
+	}
+}

hash/src/test/scala/com/sothr/imagetools/hash/HashServiceMD5Test.scala

@@ -0,0 +1,67 @@
+package com.sothr.imagetools.hash
+
+import scala.collection.mutable
+
+class HashServiceMD5Test extends HashServiceBaseTest {
+
+	def md5TestCase(filePath: String): String = {
+		HashService.getMD5(filePath)
+	}
+
+	test("Calculate MD5 Large Sample Image 1") {
+		debug("Starting 'Calculate MD5 Large Sample Image 1' test")
+		val hash = HashService.getMD5(LargeSampleImage1)
+		debug(s"Testing that $hash = 3fbccfd5faf3f991435b827ee5961862")
+		assert(hash == "3fbccfd5faf3f991435b827ee5961862")
+	}
+
+	test("Calculate MD5 Medium Sample Image 1") {
+		debug("Starting 'Calculate MD5 Medium Sample Image 1' test")
+		val hash = HashService.getMD5(MediumSampleImage1)
+		debug(s"Testing that $hash = a95e2cc4610307eb957e9c812429c53e")
+		assert(hash == "a95e2cc4610307eb957e9c812429c53e")
+	}
+
+	test("Calculate MD5 Small Sample Image 1") {
+		debug("Starting 'Calculate MD5 Small Sample Image 1' test")
+		val hash = HashService.getMD5(SmallSampleImage1)
+		debug(s"Testing that $hash = b137131bd55896c747286e4d247b845e")
+		assert(hash == "b137131bd55896c747286e4d247b845e")
+	}
+
+	test("Benchmark MD5") {
+		info("Benchmarking MD5")
+		info("MD5 Large Image 3684x2736")
+		val time = new mutable.MutableList[Long]()
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				md5TestCase(LargeSampleImage1)
+			}
+		}
+
+		val largeMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for large was: $largeMean ms")
+		time.clear()
+		info("MD5 Medium Image 1824x1368")
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				md5TestCase(MediumSampleImage1)
+			}
+		}
+
+		val mediumMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for medium was: $mediumMean ms")
+		time.clear()
+		info("MD5 Small Image 912x684")
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				md5TestCase(SmallSampleImage1)
+			}
+		}
+
+		val smallMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for small was: $smallMean ms")
+		time.clear()
+		assert(true)
+	}
+}

hash/src/test/scala/com/sothr/imagetools/hash/HashServicePHashTest.scala

@@ -0,0 +1,93 @@
+package com.sothr.imagetools.hash
+
+import java.io.File
+import javax.imageio.ImageIO
+
+import scala.collection.mutable
+
+class HashServicePHashTest extends HashServiceBaseTest {
+
+	def phashTestCase(filePath: String): Long = {
+		val sample = new File(filePath)
+		val image = ImageIO.read(sample)
+		HashService.getPhash(phashSetting, image)
+	}
+
+	test("Calculate PHash Large Sample Image 1") {
+		debug("Starting 'Calculate PHash Large Sample Image 1' test")
+		val sample = new File(LargeSampleImage1)
+		debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
+		val image = ImageIO.read(sample)
+		debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
+		val hash = HashService.getPhash(phashSetting, image)
+		debug(s"Testing that $hash = -9154554603604154117L")
+		assert(hash == -9154554603604154117L)
+	}
+
+	test("Calculate PHash Medium Sample Image 1") {
+		debug("Starting 'Calculate PHash Medium Sample Image 1' test")
+		val sample = new File(MediumSampleImage1)
+		debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
+		val image = ImageIO.read(sample)
+		debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
+		val hash = HashService.getPhash(phashSetting, image)
+		debug(s"Testing that $hash = -9154589787976242949L")
+		assert(hash == -9154589787976242949L)
+	}
+
+	test("Calculate PHash Small Sample Image 1") {
+		debug("Starting 'Calculate PHash Small Sample Image 1' test")
+		val sample = new File(SmallSampleImage1)
+		debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
+		val image = ImageIO.read(sample)
+		debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
+		val hash = HashService.getPhash(phashSetting, image)
+		debug(s"Testing that $hash = -9154589787976242949L")
+		assert(hash == -9154589787976242949L)
+	}
+
+	test("PHash Of Large, Medium, And Small Sample 1 Must Be Similar") {
+		val largeHash = phashTestCase(LargeSampleImage1)
+		val mediumHash = phashTestCase(MediumSampleImage1)
+		val smallHash = phashTestCase(SmallSampleImage1)
+		assert(HashService.areHashSimilar(phashSetting, largeHash, mediumHash))
+		assert(HashService.areHashSimilar(phashSetting, largeHash, smallHash))
+		assert(HashService.areHashSimilar(phashSetting, mediumHash, smallHash))
+	}
+
+	test("Benchmark PHash") {
+		info("Benchmarking PHash")
+		info("PHash Large Image 3684x2736")
+		val time = new mutable.MutableList[Long]()
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				phashTestCase(LargeSampleImage1)
+			}
+		}
+
+		val largeMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for large was: $largeMean ms")
+		time.clear()
+		info("PHash Medium Image 1824x1368")
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				phashTestCase(MediumSampleImage1)
+			}
+		}
+
+		val mediumMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for medium was: $mediumMean ms")
+		time.clear()
+		info("PHash Small Image 912x684")
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				phashTestCase(SmallSampleImage1)
+			}
+		}
+
+		val smallMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for small was: $smallMean ms")
+		time.clear()
+		assert(true)
+	}
+}

hash/src/test/scala/com/sothr/imagetools/hash/HashServiceSHA1Test.scala

@@ -0,0 +1,67 @@
+package com.sothr.imagetools.hash
+
+import scala.collection.mutable
+
+class HashServiceSHA1Test extends HashServiceBaseTest {
+
+	def sha1TestCase(filePath: String): String = {
+		HashService.getSHA1(filePath)
+	}
+
+	test("Calculate SHA1 Large Sample Image 1") {
+		debug("Starting 'Calculate SHA1 Large Sample Image 1' test")
+		val hash = HashService.getSHA1(LargeSampleImage1)
+		debug(s"Testing that $hash = 4beb6f2d852b75a313863916a1803ebad13a3196")
+		assert(hash == "4beb6f2d852b75a313863916a1803ebad13a3196")
+	}
+
+	test("Calculate SHA1 Medium Sample Image 1") {
+		debug("Starting 'Calculate SHA1 Medium Sample Image 1' test")
+		val hash = HashService.getSHA1(MediumSampleImage1)
+		debug(s"Testing that $hash = edc718ce8e3556a39592ffdc214d0f636529be9f")
+		assert(hash == "edc718ce8e3556a39592ffdc214d0f636529be9f")
+	}
+
+	test("Calculate SHA1 Small Sample Image 1") {
+		debug("Starting 'Calculate SHA1 Small Sample Image 1' test")
+		val hash = HashService.getSHA1(SmallSampleImage1)
+		debug(s"Testing that $hash = 1a91d2b5327f0aad258419f76b87d4c0bc343443")
+		assert(hash == "1a91d2b5327f0aad258419f76b87d4c0bc343443")
+	}
+
+	test("Benchmark SHA1") {
+		info("Benchmarking SHA1")
+		info("SHA1 Large Image 3684x2736")
+		val time = new mutable.MutableList[Long]()
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				sha1TestCase(LargeSampleImage1)
+			}
+		}
+
+		val largeMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for large was: $largeMean ms")
+		time.clear()
+		info("SHA1 Medium Image 1824x1368")
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				sha1TestCase(MediumSampleImage1)
+			}
+		}
+
+		val mediumMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for medium was: $mediumMean ms")
+		time.clear()
+		info("SHA1 Small Image 912x684")
+		for (_ <- 0 until benchmarkRuns) {
+			time += getTime {
+				sha1TestCase(SmallSampleImage1)
+			}
+		}
+
+		val smallMean = getMean(time.toArray[Long])
+		info(s"The mean time of ${time.size} tests for small was: $smallMean ms")
+		time.clear()
+		assert(true)
+	}
+}

hash/src/test/scala/com/sothr/imagetools/hash/HashServiceTest.scala

@@ -1,10 +1,12 @@
 package com.sothr.imagetools.hash
 
 import java.io.File
+import java.util.NoSuchElementException
 import javax.imageio.ImageIO
 
-import com.sothr.imagetools.hash.`type`.DHash
-import com.sothr.imagetools.hash.dto.{HashSettingDTO, ImageHashDTO}
+import com.sothr.imagetools.hash.HashService.getHash
+import com.sothr.imagetools.hash.`type`.{AHash, DHash, PHash}
+import com.sothr.imagetools.hash.util.ImageUtil
 
 import scala.collection.mutable
 
@@ -13,390 +15,40 @@ import scala.collection.mutable
   *
   * Created by dev on 1/23/14.
   */
-class HashServiceTest extends BaseTest {
+class HashServiceTest extends HashServiceBaseTest {
 
-  // Define the number of runs the benchmarking tests should use
-  val benchmarkRuns = 10
-  val ahashSetting = new HashSettingDTO(true, 8, 8, 0.75f)
-  val dhashSetting = new HashSettingDTO(true, 8, 8, 0.85f)
-  val phashSetting = new HashSettingDTO(true, 32, 8, 1.0f)
-
-  def dhashTestCase(filePath: String): Long = {
-    val sample = new File(filePath)
-    val image = ImageIO.read(sample)
-    HashService.getDhash(dhashSetting, image)
-  }
-
-  test("Benchmark DHash") {
-    info("Benchmarking DHash")
-    info("DHash Large Image 3684x2736")
-    val time = new mutable.MutableList[Long]()
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        dhashTestCase(TestParams.LargeSampleImage1)
-      }
-    }
-    val largeMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for large was: $largeMean ms")
-    time.clear()
-    info("DHash Medium Image 1824x1368")
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        dhashTestCase(TestParams.MediumSampleImage1)
-      }
-    }
-    val mediumMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for medium was: $mediumMean ms")
-    time.clear()
-    info("DHash Small Image 912x684")
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        dhashTestCase(TestParams.SmallSampleImage1)
-      }
-    }
-    val smallMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for small was: $smallMean ms")
-    time.clear()
-    assert(true)
-  }
-
-  test("Confirm Largest DHash Output ") {
-    val testData: Array[Array[Int]] = Array(
-      Array(1, 2, 3, 4, 5, 6, 7, 8),
-      Array(16, 15, 14, 13, 12, 11, 10, 9),
-      Array(17, 18, 19, 20, 21, 22, 23, 24),
-      Array(32, 31, 30, 29, 28, 27, 26, 25),
-      Array(33, 34, 35, 36, 37, 38, 39, 40),
-      Array(48, 47, 46, 45, 44, 43, 42, 41),
-      Array(49, 50, 51, 52, 53, 54, 55, 56),
-      Array(64, 63, 62, 61, 60, 59, 58, 57))
-    val hash = DHash.getHash(testData)
-    debug(s"Hash of test array: $hash")
-    assert(hash == Long.MaxValue)
-  }
-
-  test("Calculate DHash Large Sample Image 1") {
-    debug("Starting 'Calculate DHash Large Sample Image 1' test")
-    val sample = new File(TestParams.LargeSampleImage1)
-    debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
-    val image = ImageIO.read(sample)
-    debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
-    val hash = HashService.getDhash(dhashSetting, image)
-    debug(s"Testing that $hash = 4004374827879799635L")
-    assert(hash == 4004374827879799635L)
-  }
-
-  test("Calculate DHash Medium Sample Image 1") {
-    debug("Starting 'Calculate DHash Medium Sample Image 1' test")
-    val sample = new File(TestParams.MediumSampleImage1)
-    debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
-    val image = ImageIO.read(sample)
-    debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
-    val hash = HashService.getDhash(dhashSetting, image)
-    debug(s"Testing that $hash = 4004374827879799635L")
-    assert(hash == 4004374827879799635L)
-  }
-
-  test("Calculate DHash Small Sample Image 1") {
-    debug("Starting 'Calculate DHash Small Sample Image 1' test")
-    val sample = new File(TestParams.SmallSampleImage1)
-    debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
-    val image = ImageIO.read(sample)
-    debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
-    val hash = HashService.getDhash(dhashSetting, image)
-    debug(s"Testing that $hash = 4004383623972821843L")
-    assert(hash == 4004383623972821843L)
-  }
-
-  test("DHash Of Large, Medium, And Small Sample 1 Must Be Similar") {
-    val largeHash = dhashTestCase(TestParams.LargeSampleImage1)
-    val mediumHash = dhashTestCase(TestParams.MediumSampleImage1)
-    val smallHash = dhashTestCase(TestParams.SmallSampleImage1)
-    assert(HashService.areHashSimilar(dhashSetting, largeHash, mediumHash))
-    assert(HashService.areHashSimilar(dhashSetting, largeHash, smallHash))
-    assert(HashService.areHashSimilar(dhashSetting, mediumHash, smallHash))
-  }
-
-  def ahashTestCase(filePath: String): Long = {
-    val sample = new File(filePath)
-    val image = ImageIO.read(sample)
-    HashService.getAhash(ahashSetting, image)
-  }
-
-  test("Benchmark AHash") {
-    info("Benchmarking AHash")
-    info("AHash Large Image 3684x2736")
-    val time = new mutable.MutableList[Long]()
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        ahashTestCase(TestParams.LargeSampleImage1)
-      }
-    }
-    val largeMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for large was: $largeMean ms")
-    time.clear()
-    info("AHash Medium Image 1824x1368")
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        ahashTestCase(TestParams.MediumSampleImage1)
-      }
-    }
-    val mediumMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for medium was: $mediumMean ms")
-    time.clear()
-    info("AHash Small Image 912x684")
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        ahashTestCase(TestParams.SmallSampleImage1)
-      }
-    }
-    val smallMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for small was: $smallMean ms")
-    time.clear()
-    assert(true)
-  }
-
-  test("Calculate AHash Large Sample Image 1") {
-    debug("Starting 'Calculate AHash Large Sample Image 1' test")
-    val sample = new File(TestParams.LargeSampleImage1)
-    debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
-    val image = ImageIO.read(sample)
-    debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
-    val hash = HashService.getAhash(ahashSetting, image)
-    debug(s"Testing that $hash = 36070299219713907L")
-    assert(hash == 36070299219713907L)
-  }
-
-  test("Calculate AHash Medium Sample Image 1") {
-    debug("Starting 'Calculate AHash Medium Sample Image 1' test")
-    val sample = new File(TestParams.MediumSampleImage1)
-    debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
-    val image = ImageIO.read(sample)
-    debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
-    val hash = HashService.getAhash(ahashSetting, image)
-    debug(s"Testing that $hash = 36070299219713907L")
-    assert(hash == 36070299219713907L)
-  }
-
-  test("Calculate AHash Small Sample Image 1") {
-    debug("Starting 'Calculate AHash Small Sample Image 1' test")
-    val sample = new File(TestParams.SmallSampleImage1)
-    debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
-    val image = ImageIO.read(sample)
-    debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
-    val hash = HashService.getAhash(ahashSetting, image)
-    debug(s"Testing that $hash = 36070299219713907L")
-    assert(hash == 36070299219713907L)
-  }
-
-  test("AHash Of Large, Medium, And Small Sample 1 Must Be Similar") {
-    val largeHash = ahashTestCase(TestParams.LargeSampleImage1)
-    val mediumHash = ahashTestCase(TestParams.MediumSampleImage1)
-    val smallHash = ahashTestCase(TestParams.SmallSampleImage1)
-    assert(HashService.areHashSimilar(ahashSetting, largeHash, mediumHash))
-    assert(HashService.areHashSimilar(ahashSetting, largeHash, smallHash))
-    assert(HashService.areHashSimilar(ahashSetting, mediumHash, smallHash))
-  }
-
-  def phashTestCase(filePath: String): Long = {
-    val sample = new File(filePath)
-    val image = ImageIO.read(sample)
-    HashService.getPhash(phashSetting, image)
-  }
-
-  test("Benchmark PHash") {
-    info("Benchmarking PHash")
-    info("PHash Large Image 3684x2736")
-    val time = new mutable.MutableList[Long]()
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        phashTestCase(TestParams.LargeSampleImage1)
-      }
-    }
-    val largeMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for large was: $largeMean ms")
-    time.clear()
-    info("PHash Medium Image 1824x1368")
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        phashTestCase(TestParams.MediumSampleImage1)
-      }
-    }
-    val mediumMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for medium was: $mediumMean ms")
-    time.clear()
-    info("PHash Small Image 912x684")
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        phashTestCase(TestParams.SmallSampleImage1)
-      }
-    }
-    val smallMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for small was: $smallMean ms")
-    time.clear()
-    assert(true)
-  }
-
-  test("Calculate PHash Large Sample Image 1") {
-    debug("Starting 'Calculate PHash Large Sample Image 1' test")
-    val sample = new File(TestParams.LargeSampleImage1)
-    debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
-    val image = ImageIO.read(sample)
-    debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
-    val hash = HashService.getPhash(phashSetting, image)
-    debug(s"Testing that $hash = -9154554603604154117L")
-    assert(hash == -9154554603604154117L)
-  }
-
-  test("Calculate PHash Medium Sample Image 1") {
-    debug("Starting 'Calculate PHash Medium Sample Image 1' test")
-    val sample = new File(TestParams.MediumSampleImage1)
-    debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
-    val image = ImageIO.read(sample)
-    debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
-    val hash = HashService.getPhash(phashSetting, image)
-    debug(s"Testing that $hash = -9154589787976242949L")
-    assert(hash == -9154589787976242949L)
-  }
-
-  test("Calculate PHash Small Sample Image 1") {
-    debug("Starting 'Calculate PHash Small Sample Image 1' test")
-    val sample = new File(TestParams.SmallSampleImage1)
-    debug(s"Testing File: ${sample.getAbsolutePath} exists: ${sample.exists}")
-    val image = ImageIO.read(sample)
-    debug(s"Image: width: ${image.getWidth} height: ${image.getHeight}")
-    val hash = HashService.getPhash(phashSetting, image)
-    debug(s"Testing that $hash = -9154589787976242949L")
-    assert(hash == -9154589787976242949L)
-  }
-
-  test("PHash Of Large, Medium, And Small Sample 1 Must Be Similar") {
-    val largeHash = phashTestCase(TestParams.LargeSampleImage1)
-    val mediumHash = phashTestCase(TestParams.MediumSampleImage1)
-    val smallHash = phashTestCase(TestParams.SmallSampleImage1)
-    assert(HashService.areHashSimilar(phashSetting, largeHash, mediumHash))
-    assert(HashService.areHashSimilar(phashSetting, largeHash, smallHash))
-    assert(HashService.areHashSimilar(phashSetting, mediumHash, smallHash))
-  }
-
-  def md5TestCase(filePath: String): String = {
-    HashService.getMD5(filePath)
-  }
-
-  test("Benchmark MD5") {
-    info("Benchmarking MD5")
-    info("MD5 Large Image 3684x2736")
-    val time = new mutable.MutableList[Long]()
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        md5TestCase(TestParams.LargeSampleImage1)
-      }
-    }
-    val largeMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for large was: $largeMean ms")
-    time.clear()
-    info("MD5 Medium Image 1824x1368")
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        md5TestCase(TestParams.MediumSampleImage1)
-      }
-    }
-    val mediumMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for medium was: $mediumMean ms")
-    time.clear()
-    info("MD5 Small Image 912x684")
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        md5TestCase(TestParams.SmallSampleImage1)
-      }
-    }
-    val smallMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for small was: $smallMean ms")
-    time.clear()
-    assert(true)
-  }
-
-  test("Calculate MD5 Large Sample Image 1") {
-    debug("Starting 'Calculate MD5 Large Sample Image 1' test")
-    val hash = HashService.getMD5(TestParams.LargeSampleImage1)
-    debug(s"Testing that $hash = 3fbccfd5faf3f991435b827ee5961862")
-    assert(hash == "3fbccfd5faf3f991435b827ee5961862")
-  }
-
-  test("Calculate MD5 Medium Sample Image 1") {
-    debug("Starting 'Calculate MD5 Medium Sample Image 1' test")
-    val hash = HashService.getMD5(TestParams.MediumSampleImage1)
-    debug(s"Testing that $hash = a95e2cc4610307eb957e9c812429c53e")
-    assert(hash == "a95e2cc4610307eb957e9c812429c53e")
-  }
-
-  test("Calculate MD5 Small Sample Image 1") {
-    debug("Starting 'Calculate MD5 Small Sample Image 1' test")
-    val hash = HashService.getMD5(TestParams.SmallSampleImage1)
-    debug(s"Testing that $hash = b137131bd55896c747286e4d247b845e")
-    assert(hash == "b137131bd55896c747286e4d247b845e")
-  }
-
-  def sha1TestCase(filePath: String): String = {
-    HashService.getSHA1(filePath)
-  }
-
-  test("Benchmark SHA1") {
-    info("Benchmarking SHA1")
-    info("SHA1 Large Image 3684x2736")
-    val time = new mutable.MutableList[Long]()
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        sha1TestCase(TestParams.LargeSampleImage1)
-      }
-    }
-    val largeMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for large was: $largeMean ms")
-    time.clear()
-    info("SHA1 Medium Image 1824x1368")
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        sha1TestCase(TestParams.MediumSampleImage1)
-      }
-    }
-    val mediumMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for medium was: $mediumMean ms")
-    time.clear()
-    info("SHA1 Small Image 912x684")
-    for (_ <- 0 until benchmarkRuns) {
-      time += getTime {
-        sha1TestCase(TestParams.SmallSampleImage1)
-      }
-    }
-    val smallMean = getMean(time.toArray[Long])
-    info(s"The mean time of ${time.size} tests for small was: $smallMean ms")
-    time.clear()
-    assert(true)
+	def imageHashTestCase(filePath: String): ImageHash = {
+		HashService.getImageHashes(ahashSetting, dhashSetting, phashSetting, filePath)
 	}
 
-  test("Calculate SHA1 Large Sample Image 1") {
-    debug("Starting 'Calculate SHA1 Large Sample Image 1' test")
-    val hash = HashService.getSHA1(TestParams.LargeSampleImage1)
-    debug(s"Testing that $hash = 4beb6f2d852b75a313863916a1803ebad13a3196")
-    assert(hash == "4beb6f2d852b75a313863916a1803ebad13a3196")
+	test("ImageHash Of Large, Medium, And Small Sample 1 Must Be Similar") {
+		val largeHash = imageHashTestCase(LargeSampleImage1)
+		val mediumHash = imageHashTestCase(MediumSampleImage1)
+		val smallHash = imageHashTestCase(SmallSampleImage1)
+		assert(HashService.areImageHashesSimilar(ahashSetting, dhashSetting, phashSetting, largeHash, mediumHash))
+		assert(HashService.areImageHashesSimilar(ahashSetting, dhashSetting, phashSetting, largeHash, smallHash))
+		assert(HashService.areImageHashesSimilar(ahashSetting, dhashSetting, phashSetting, mediumHash, smallHash))
 	}
 
-  test("Calculate SHA1 Medium Sample Image 1") {
-    debug("Starting 'Calculate SHA1 Medium Sample Image 1' test")
-    val hash = HashService.getSHA1(TestParams.MediumSampleImage1)
-    debug(s"Testing that $hash = edc718ce8e3556a39592ffdc214d0f636529be9f")
-    assert(hash == "edc718ce8e3556a39592ffdc214d0f636529be9f")
+	test("Calculate ImageHash Large Sample Image 1") {
+		debug("Starting 'Calculate ImageHash Large Sample Image 1' test")
+		val hash = HashService.getImageHashes(ahashSetting, dhashSetting, phashSetting, LargeSampleImage1)
+		debug(s"Testing that ${hash.hashCode()} = -812844858")
+		assert(hash.hashCode == -812844858)
 	}
 
-  test("Calculate SHA1 Small Sample Image 1") {
-    debug("Starting 'Calculate SHA1 Small Sample Image 1' test")
-    val hash = HashService.getSHA1(TestParams.SmallSampleImage1)
-    debug(s"Testing that $hash = 1a91d2b5327f0aad258419f76b87d4c0bc343443")
-    assert(hash == "1a91d2b5327f0aad258419f76b87d4c0bc343443")
+	test("Calculate ImageHash Medium Sample Image 1") {
+		debug("Starting 'Calculate ImageHash Medium Sample Image 1' test")
+		val hash = HashService.getImageHashes(ahashSetting, dhashSetting, phashSetting, MediumSampleImage1)
+		debug(s"Testing that ${hash.hashCode()} = -812836666")
+		assert(hash.hashCode == -812836666)
 	}
 
-  def imageHashTestCase(filePath: String): ImageHashDTO = {
-    HashService.getImageHashes(ahashSetting, dhashSetting, phashSetting, filePath)
+	test("Calculate ImageHash Small Sample Image 1") {
+		debug("Starting 'Calculate ImageHash Small Sample Image 1' test")
+		val hash = HashService.getImageHashes(ahashSetting, dhashSetting, phashSetting, SmallSampleImage1)
+		debug(s"Testing that ${hash.hashCode()} = -812840762")
+		assert(hash.hashCode == -812840762)
 	}
 
 	test("Benchmark getImageHashes") {
@@ -405,61 +57,85 @@ class HashServiceTest extends BaseTest {
 		val time = new mutable.MutableList[Long]()
 		for (runNum <- 0 until benchmarkRuns) {
 			time += getTime {
-        imageHashTestCase(TestParams.LargeSampleImage1)
+				imageHashTestCase(LargeSampleImage1)
 			}
 		}
+
 		val largeMean = getMean(time.toArray[Long])
 		info(s"The mean time of ${time.size} tests for large was: $largeMean ms")
 		time.clear()
 		info("getImageHashes Medium Image 1824x1368")
 		for (runNum <- 0 until benchmarkRuns) {
 			time += getTime {
-        imageHashTestCase(TestParams.MediumSampleImage1)
+				imageHashTestCase(MediumSampleImage1)
 			}
 		}
+
 		val mediumMean = getMean(time.toArray[Long])
 		info(s"The mean time of ${time.size} tests for medium was: $mediumMean ms")
 		time.clear()
 		info("getImageHashes Small Image 912x684")
 		for (runNum <- 0 until benchmarkRuns) {
 			time += getTime {
-        imageHashTestCase(TestParams.SmallSampleImage1)
+				imageHashTestCase(SmallSampleImage1)
 			}
 		}
+
 		val smallMean = getMean(time.toArray[Long])
 		info(s"The mean time of ${time.size} tests for small was: $smallMean ms")
 		time.clear()
 		assert(true)
 	}
 
-  test("ImageHash Of Large, Medium, And Small Sample 1 Must Be Similar") {
-    val largeHash = imageHashTestCase(TestParams.LargeSampleImage1)
-    val mediumHash = imageHashTestCase(TestParams.MediumSampleImage1)
-    val smallHash = imageHashTestCase(TestParams.SmallSampleImage1)
-    assert(HashService.areImageHashesSimilar(ahashSetting, dhashSetting, phashSetting, largeHash, mediumHash))
-    assert(HashService.areImageHashesSimilar(ahashSetting, dhashSetting, phashSetting, largeHash, smallHash))
-    assert(HashService.areImageHashesSimilar(ahashSetting, dhashSetting, phashSetting, mediumHash, smallHash))
-  }
-
-  test("Calculate ImageHash Large Sample Image 1") {
-    debug("Starting 'Calculate ImageHash Large Sample Image 1' test")
-    val hash = HashService.getImageHashes(ahashSetting, dhashSetting, phashSetting, TestParams.LargeSampleImage1)
-    debug(s"Testing that ${hash.hashCode()} = -812844858")
-    assert(hash.hashCode == -812844858)
-  }
-
-  test("Calculate ImageHash Medium Sample Image 1") {
-    debug("Starting 'Calculate ImageHash Medium Sample Image 1' test")
-    val hash = HashService.getImageHashes(ahashSetting, dhashSetting, phashSetting, TestParams.MediumSampleImage1)
-    debug(s"Testing that ${hash.hashCode()} = -812836666")
-    assert(hash.hashCode == -812836666)
+	test("GetPrecisionSet - Empty Precision Set") {
+		val emptyPrecisionSet = HashService.getPrecisionSet(
+			new HashSetting("Test1", false, 8, 0, 0),
+			new HashSetting("Test2", false, 16, 0, 0),
+			new HashSetting("Test3", false, 32, 0, 0))
+		assert(emptyPrecisionSet.isEmpty)
+	}
+
+	test("GetPrecisionSet - Overlapping Precision Set") {
+		val precisionSet = HashService.getPrecisionSet(
+			new HashSetting("Test1", true, 8, 0, 0),
+			new HashSetting("Test2", true, 8, 0, 0),
+			new HashSetting("Test3", true, 16, 0, 0))
+		assert(precisionSet.nonEmpty)
+		assert(2 == precisionSet.size)
+	}
+
+	test("GetPrecisionMap - Empty Precision Set") {
+		val emptyPrecisionSet = HashService.getPrecisionSet(
+			new HashSetting("Test1", false, 8, 0, 0),
+			new HashSetting("Test2", false, 16, 0, 0),
+			new HashSetting("Test3", false, 32, 0, 0))
+		val grayImage = ImageUtil.convertToGray(ImageIO.read(new File(SmallSampleImage1)))
+		val emptyPrecisionMap = HashService.getPrecisionMap(emptyPrecisionSet, grayImage)
+		assert(emptyPrecisionMap.isEmpty)
+	}
+
+	test("GetPrecisionMap - Overlapping Precision Set") {
+		val precisionSet = HashService.getPrecisionSet(
+			new HashSetting("Test1", true, 8, 0, 0),
+			new HashSetting("Test2", true, 8, 0, 0),
+			new HashSetting("Test3", true, 16, 0, 0))
+		val grayImage = ImageUtil.convertToGray(ImageIO.read(new File(SmallSampleImage1)))
+		val precisionMap = HashService.getPrecisionMap(precisionSet, grayImage)
+		assert(precisionMap.nonEmpty)
+		assert(precisionMap.size == 2)
+	}
+
+	test("getHash - Empty Precision Set") {
+		val emptyPrecisionSet = HashService.getPrecisionSet(
+			new HashSetting("Test1", false, 8, 0, 0),
+			new HashSetting("Test2", false, 16, 0, 0),
+			new HashSetting("Test3", false, 32, 0, 0))
+		val grayImage = ImageUtil.convertToGray(ImageIO.read(new File(SmallSampleImage1)))
+		val emptyPrecisionMap = HashService.getPrecisionMap(emptyPrecisionSet, grayImage)
+		assertThrows[NoSuchElementException] {
+			val ahash: Long = getHash(ahashSetting, emptyPrecisionMap(ahashSetting.precision), AHash.getHash)
+			val dhash: Long = getHash(dhashSetting, emptyPrecisionMap(dhashSetting.precision), DHash.getHash)
+			val phash: Long = getHash(phashSetting, emptyPrecisionMap(phashSetting.precision), PHash.getHash)
 		}
-
-  test("Calculate ImageHash Small Sample Image 1") {
-    debug("Starting 'Calculate ImageHash Small Sample Image 1' test")
-    val hash = HashService.getImageHashes(ahashSetting, dhashSetting, phashSetting, TestParams.SmallSampleImage1)
-    debug(s"Testing that ${hash.hashCode()} = -812840762")
-    assert(hash.hashCode == -812840762)
 	}
-
 }

hash/src/test/scala/com/sothr/imagetools/hash/TestParams.scala

@@ -1,7 +0,0 @@
-package com.sothr.imagetools.hash
-
-object TestParams {
-  val LargeSampleImage1 = "sample/sample_01_large.jpg"
-  val MediumSampleImage1 = "sample/sample_01_medium.jpg"
-  val SmallSampleImage1 = "sample/sample_01_small.jpg"
-}

parent/pom.xml

@@ -70,8 +70,10 @@
   </pluginRepositories>
 
   <properties>
-    <imagetools.hash.version>0.1.1</imagetools.hash.version>
+    <!-- Image Tools Library Versions -->
+    <imagetools.hash.version>0.2.0</imagetools.hash.version>
     <imagetools.engine.version>0.1.3</imagetools.engine.version>
+    <!-- Other Dependency Versions -->
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <jdk.version>1.8</jdk.version>
     <scala.binary.version>2.12</scala.binary.version>