Sudoku Release 1.8: simplified algorithm implementation

pom.xml

@@ -36,7 +36,7 @@
             <dependency>
                 <groupId>junit</groupId>
                 <artifactId>junit</artifactId>
-                <version>4.11</version>
+                <version>4.12</version>
                 <scope>test</scope>
             </dependency>
             <dependency>
@@ -60,7 +60,7 @@
                 <plugin>
                     <groupId>com.simpligility.maven.plugins</groupId>
                     <artifactId>android-maven-plugin</artifactId>
-                    <version>4.3.0</version>
+                    <version>4.4.1</version>
                     <extensions>true</extensions>
                     <dependencies>
                         <dependency>

sudoku-android/src/main/scala/net/ladstatt/apps/sudoku/android/SudokuCapturer.scala

@@ -65,6 +65,7 @@ class SudokuCapturer extends Activity with CvCameraViewListener2 with CanLog {
   var currState: SudokuState = AndroidOpenCV.DefaultAndroidState
 
   def initAssets(): Unit = {
+    AndroidOpenCV.init()
     TemplateLibrary.getResourceAsStream = getAssets().open
     TemplateLibrary.templateResource = "templates.csv"
   }
@@ -142,9 +143,16 @@ class SudokuCapturer extends Activity with CvCameraViewListener2 with CanLog {
     val frame = inputFrame.rgba()
     frameNr = frameNr + 1
 
-    val (sudokuResult, nextState) = Await.result(SCandidate(frameNr, frame, currState, SParams()).calc, Duration.Inf)
-    currState = nextState
-    sudokuResult
+    val pipeline: FramePipeline = FramePipeline(frame, SParams())
+
+    pipeline.detectRectangle match  {
+      case None => SFailure("No rectangle detected",SCandidate(frameNr,pipeline, SRectangle(frame, pipeline.corners,pipeline.corners),currState))
+      case Some(r) =>
+        val rectangle: SRectangle = SRectangle(pipeline)
+        val (sudokuResult, nextState) = Await.result(SCandidate(frameNr, pipeline, rectangle, currState).calc, Duration.Inf)
+        currState = nextState
+        sudokuResult
+    }
   }
 
   def execOnUIThread(f: => Unit): Unit = {

sudoku-core/src/main/scala/net/ladstatt/opencv/OpenCV.scala

@@ -229,9 +229,8 @@ object OpenCV extends CanLog {
     * @param pattern
     * @return
     */
-  def copySrcToDestWithMask(source: Mat, destination: Mat, pattern: Mat): Future[Mat] =
-    Future {
-      source.copyTo(destination, pattern)
+  def copySrcToDestWithMask(source: Mat, destination: Mat, pattern: Mat): Mat = {
+    source.copyTo(destination, pattern)
       destination
     }
 

sudoku-core/src/main/scala/net/ladstatt/sudoku/FramePipeline.scala

@@ -14,18 +14,17 @@ object FramePipeline {
 
   import net.ladstatt.opencv.OpenCV._
 
-  def apply(frame: Mat, params: SParams): FramePipeline = {
+  def apply(frame: Mat, params: SParams = SParams()): FramePipeline = {
     val start = System.nanoTime()
     Await.result(for {
-      working <- copySrcToDestWithMask(frame, new Mat, frame)
+      working <- Future(copySrcToDestWithMask(frame, new Mat, frame))
       grayed <- toGray(working)
       blurred <- gaussianblur(grayed)
       thresholdApplied <- adaptiveThreshold(blurred)
       inverted <- bitwiseNot(thresholdApplied)
       dilated <- dilate(inverted, OpenCV.Kernel)
       eroded <- erode(inverted)
-      corners: MatOfPoint2f = OpenCV.mkCorners(frame.size)
-    } yield FramePipeline(start, frame, working, grayed, blurred, thresholdApplied, inverted, dilated, eroded, corners, params), Duration.Inf)
+    } yield FramePipeline(start, frame, working, grayed, blurred, thresholdApplied, inverted, dilated, eroded, params), Duration.Inf)
   }
 
 }
@@ -42,9 +41,9 @@ case class FramePipeline(start: Long,
                          thresholded: Mat,
                          inverted: Mat,
                          dilated: Mat, eroded: Mat,
-                         corners: MatOfPoint2f,
                          params: SParams) extends SResult {
 
+  val corners =  OpenCV.mkCorners(frame.size)
   /**
     * a sequence of point lists which give the recognized contour lines
     */

sudoku-core/src/main/scala/net/ladstatt/sudoku/Parameters.scala

@@ -3,6 +3,8 @@ package net.ladstatt.sudoku
 import net.ladstatt.opencv.OpenCV._
 import org.opencv.core.Mat
 
+import scala.concurrent.Future
+
 
 object SudokuState {
 
@@ -49,6 +51,9 @@ case class SudokuState(hitCounts: HitCounters,
 
   val detections: Int = hitCounts.values.flatMap(filterHits(_, cap)).size
 
+  def merge(sRectangle: SRectangle) : SudokuState = {
+    merge(sRectangle.normalized, sRectangle.cells, sRectangle.cellValues)
+  }
   def merge(normalized: Mat,
             detectedCells: Seq[SCell],
             detectedCellValues: Seq[Int]): SudokuState = {
@@ -82,16 +87,20 @@ object Parameters {
 
   // least number of matches necessary to identify one number
   // if you have a good camera, take 1 to get fast response
-  val cap = 30
+  val cap = 3
+  //val cap = 30
 
   // number of different values a cell can have before the cell is label 'ambiguous'
   val ambiguitiesCount = 5
+  //val ambiguitiesCount = 5
 
   // how many cells are allowed to have ambiguous information before number detection process is restarted
   val ambiCount = 5
+  //val ambiCount = 5
 
   // numbers won't get any larger in the status matrix than this number
-  val topCap = 50
+  val topCap =5
+  //val topCap = 50
 
 
   assert(topCap - cap > 0)

sudoku-core/src/main/scala/net/ladstatt/sudoku/SCandidate.scala

@@ -1,6 +1,5 @@
 package net.ladstatt.sudoku
 
-import net.ladstatt.core.CanLog
 import net.ladstatt.opencv.{Debug, OpenCV}
 import org.opencv.core._
 
@@ -43,18 +42,15 @@ case class SCandidate(nr: Int,
     * This function uses an input image and a detection method to calculate the sudoku.
     */
   lazy val calc: Future[(SudokuResult, SudokuState)] = {
+    val currentState = oldState.merge(sRectangle)
     for {
-      detectedCells <- Future(sRectangle.cells)
-      detectedCellValues = sRectangle.cells.map(_.value)
-      currentState = oldState.merge(sRectangle.normalized, detectedCells, detectedCellValues)
       solvedState <- Future(currentState.solve())
-      withSolution <- sRectangle.paintSolution(detectedCellValues, solvedState.someCells, currentState.library)
-      annotatedSolution <- SudokuUtils.paintCorners(withSolution, sRectangle.cellRois, solvedState.someCells, currentState.hitCounts, oldState.cap)
+      withSolution <- Future(sRectangle.paintSolution(solvedState.someCells, currentState.library))
+      annotatedSolution <- Future(SudokuUtils.paintCorners(withSolution, sRectangle.cellRois, solvedState.someCells, currentState.hitCounts, oldState.cap))
       warped = OpenCV.warp(annotatedSolution, pipeline.corners, sRectangle.detectedCorners)
-      solutionMat <- OpenCV.copySrcToDestWithMask(warped, pipeline.frame, warped) // copy solution mat to input mat
-      sudokuFrame = SudokuFrame(sRectangle.normalized, detectedCells.toArray, sRectangle.detectedCorners.toList.toList)
+      solutionMat <- Future(OpenCV.copySrcToDestWithMask(warped, pipeline.frame, warped)) // copy solution mat to input mat
     } yield {
-      (SSuccess(this, sudokuFrame, solvedState.someResult.map(s => SolutionFrame(s, solutionMat))), currentState)
+      (SSuccess(this, sRectangle, solvedState.someResult.map(s => SolutionFrame(s, solutionMat))), currentState)
     }
   }
 

sudoku-core/src/main/scala/net/ladstatt/sudoku/SCell.scala

@@ -16,6 +16,7 @@ import scala.concurrent.{Await, Future}
   * @param roi
   */
 case class SCell(cellMat: Mat, roi: Rect) {
+
   val contour: Option[Mat] = Await.result(extractContour(cellMat), Duration.Inf)
 
   val (value, quality) = Await.result(contour.map(TemplateLibrary.detectNumber).getOrElse(Future.successful((0, 0.0))),Duration.Inf)

sudoku-core/src/main/scala/net/ladstatt/sudoku/SParams.scala

@@ -8,6 +8,7 @@ object SParams {
   def apply(): SParams = {
     SParams(Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE, 30)
   }
+
 }
 
 

sudoku-core/src/main/scala/net/ladstatt/sudoku/SRectangle.scala

@@ -4,25 +4,38 @@ import net.ladstatt.opencv.OpenCV
 import net.ladstatt.opencv.OpenCV._
 import org.opencv.core._
 
-import scala.concurrent.ExecutionContext.Implicits.global
-import scala.concurrent.Future
+import scala.collection.JavaConversions ._
 
+object SRectangle {
+
+  def apply(pipeline: FramePipeline) : SRectangle = {
+    SRectangle(pipeline.frame, pipeline.detectRectangle.get,pipeline.corners)
+  }
+}
 /**
   * Created by lad on 01.05.16.
   */
 case class SRectangle(frame: Mat, detectedCorners: MatOfPoint2f, destCorners: MatOfPoint2f) {
-
-  //val analysisCorners = OpenCV.mkCorners(TemplateLibrary.templateCanvasSize)
+  /**
+    * This mat contains an 'unstretched' version of the detected sudoku outer rectangle.
+    *
+    * In this representation it is easier to paint upon. After painting this Mat will be retransformed
+    * to the original appearance again.
+    */
   val normalized: Mat = OpenCV.warp(frame, detectedCorners, destCorners)
+
   /**
     * the cellRois denote the region of interests for every sudoku cell (there are 81 of them for every sudoku)
     */
   val cellRois: Seq[Rect] = Parameters.cellRange.map(OpenCV.mkRect(_, OpenCV.mkCellSize(normalized.size)))
 
   val cells: Seq[SCell] = cellRois.map(r => SCell(normalized.submat(r), r))
 
-  // lazy val detectedCells: Future[Seq[SCell]] = Future.fold(warpedCells)(Seq[SCell]())((cells, c) => cells ++ Seq(c))
+  val cellValues: Seq[Int] = cells.map(_.value)
+
+  lazy val detectedCells: Seq[SCell] = cells.filter(_.value != 0)
 
+  lazy val corners = detectedCorners.toList.toList
   /**
     * paints the solution to the canvas.
     *
@@ -33,23 +46,15 @@ case class SRectangle(frame: Mat, detectedCorners: MatOfPoint2f, destCorners: Ma
     *
     * uses digitData as lookup table to paint onto the canvas, thus modifying the canvas.
     */
-  def paintSolution(detectedCells: Seq[Int],
-                    someSolution: Option[Cells],
-                    digitLibrary: DigitLibrary): Future[Mat] = {
-
-    Future {
-      for (solution <- someSolution) {
-        val values: Array[Int] = solution.map(_.value)
-        for ((s, r) <- values zip cellRois) {
-          if (values.sum == 405) {
-            copyTo(digitLibrary(s)._2.getOrElse(SudokuUtils.mkFallback(s, digitLibrary).get), normalized, r)
-          } else {
-            logTrace("values.sum was not 405 in paintsolution")
-          }
-        }
+  def paintSolution(someSolution: Option[Cells],
+                    digitLibrary: DigitLibrary): Mat = {
+    for (solution <- someSolution) {
+      val values: Array[Int] = solution.map(_.value)
+      for ((s, r) <- values zip cellRois if s != 0) {
+        copyTo(digitLibrary(s)._2.getOrElse(SudokuUtils.mkFallback(s, digitLibrary).get), normalized, r)
       }
-      normalized
     }
+    normalized
   }
 
 

sudoku-core/src/main/scala/net/ladstatt/sudoku/SudokuResult.scala

@@ -2,11 +2,11 @@ package net.ladstatt.sudoku
 
 import org.opencv.core.{Mat, Point}
 
+import scala.collection.JavaConversions._
+
 case class InputFrame(nr: Int, framePipeline: FramePipeline)
 
-case class SudokuFrame(in: Mat, cells: Cells, corners: List[Point]) {
-  lazy val detectedCells = cells.filter(_.value != 0)
-}
+
 
 case class SolutionFrame(solution: SudokuDigitSolution, solutionMat: Mat) {
   def solutionAsString: String = solution.sliding(9, 9).map(new String(_)).mkString("\n")
@@ -24,7 +24,7 @@ sealed trait SudokuResult {
   * @param someSolution
   */
 case class SSuccess(inputFrame: SCandidate,
-                    sudokuFrame: SudokuFrame,
+                    sudokuFrame: SRectangle,
                     someSolution: Option[SolutionFrame]) extends SudokuResult
 
 case class SFailure(msg: String, inputFrame: SCandidate) extends SudokuResult

sudoku-core/src/main/scala/net/ladstatt/sudoku/SudokuUtils.scala

@@ -78,7 +78,7 @@ object SudokuUtils {
                    rects: Seq[Rect],
                    someSolution: Option[Cells],
                    hitCounts: HitCounters,
-                   cap: Int): Future[Mat] = {
+                   cap: Int): Mat = {
 
 
     // TODO update colors
@@ -96,7 +96,7 @@ object SudokuUtils {
       new Scalar(0, (n % cap) * 255 / cap, r, 255.0)
     }
 
-    Future {
+
       for (solution <- someSolution) {
         CollectionUtils.traverseWithIndex(rects)((cell, i) => {
           paintRect(canvas, rects(i), color(hitCounts(i), cap), 1)
@@ -105,7 +105,6 @@ object SudokuUtils {
       }
 
       canvas
-    }
   }
 
 

sudoku-core/src/main/scala/net/ladstatt/sudoku/TemplateLibrary.scala

@@ -37,7 +37,6 @@ object TemplateLibrary extends CanLog {
     * @return
     */
   def detectNumber(candidate: Mat): Future[(Int, Double)] = {
-    //println(candidate.size.width + "/" + candidate.size.height)
     val resizedCandidate = OpenCV.resize(candidate, TemplateLibrary.templateSize) // since templates are 25 x 50
     val matchHaystack: (Int, Mat) => Future[(Int, Double)] = OpenCV.matchTemplate(resizedCandidate, _: Int, _: Mat)
 

sudoku-core/src/main/scala/net/ladstatt/sudoku/package.scala

@@ -24,6 +24,7 @@ package object sudoku {
     * records for each number from 0 to 9 the best hit (quality) along with its digital data
     */
   type DigitLibrary = Map[Int, (Double, Option[Mat])]
+
   // TODO solution should be an array of Int or a string with 81 entries
   // the graphical representation should be a single mat with the matrixes edited inline
   // (meaning the matrix represents the whole canvas and the app is working with submatrixes

sudoku-core/src/test/scala/net/ladstatt/sudoku/SudokuStateTest.scala

@@ -18,7 +18,7 @@ final class SudokuStateTest extends FunSuite with GeneratorDrivenPropertyChecks
     for {nr <- Gen.choose(0, 10000)
          frame <- Gen.const(SudokuTestContext.frameSudoku_1)
          cap <- Gen.choose(8, 15)
-         minHits <- Gen.choose(20, 30)} yield SCandidate(nr, frame,FramePipeline(frame,SParams()),SudokuState())
+         minHits <- Gen.choose(20, 30)} yield SCandidate(nr, frame, FramePipeline(frame), SudokuState())
   // SudokuState(cap = cap, minHits = minHits)
 
   def printState(s: SCandidate): Unit = logInfo(s"${s}")

sudoku-core/src/test/scala/net/ladstatt/sudoku/SudokuTestContext.scala

@@ -40,7 +40,7 @@ object SudokuTestContext {
   lazy val (emptySudoku, (emptySudokuResult, _)) = calculate(emptyFrame)
 
   def calculate(frame: Mat): (SCandidate, (SudokuResult, SudokuState)) = {
-    val c = SCandidate(0, frame,FramePipeline(frame,SParams()), SudokuState.DefaultState)
+    val c = SCandidate(0, frame, FramePipeline(frame), SudokuState.DefaultState)
     val state: SudokuState = SudokuState.DefaultState.copy(cap = 1, minHits = 17, maxSolvingDuration = 5000L)
     (c, Await.result(c.calc, Duration.Inf))
   }

sudoku-javafx/pom.xml

@@ -47,12 +47,12 @@
         <dependency>
             <groupId>io.reactivex</groupId>
             <artifactId>rxjava</artifactId>
-            <version>1.0.1</version>
+            <version>1.1.5</version>
         </dependency>
         <dependency>
             <groupId>io.reactivex</groupId>
             <artifactId>rxscala_2.11</artifactId>
-            <version>0.23.1</version>
+            <version>0.26.1</version>
         </dependency>
     </dependencies>
     <build>

sudoku-javafx/src/main/scala/net/ladstatt/sudoku/SudokuFX.scala

@@ -480,7 +480,7 @@ class SudokuFXController extends Initializable with OpenCVJfxUtils with CanLog w
     displayHitCounts(getCurrentSudokuState().hitCounts, as[FlowPane](statsFlowPane.getChildren))
 
     sudokuResult match {
-      case SSuccess(SCandidate(nr, framePipeline, sr, ss), SudokuFrame(sudokuCanvas, detectedCells, corners), someSolution) =>
+      case SSuccess(SCandidate(nr, framePipeline, sr, ss), SRectangle(sudokuCanvas, detectedCells, corners), someSolution) =>
         if (someSolution.isDefined) {
           val sol = someSolution.get
           updateVideo(stage, framePipeline, sol.solutionMat)