clarify and clean up spew

Author: martyvona

RockCollect/Stages/ImageThreshold.cs

@@ -137,6 +137,9 @@ public override bool SaveOutput()
                 // shadow blob
                 string shadowBlobPath = Path.Combine(GetDirectory(Dir.Output), "shadowBlobs.ppm");
                 int numShadows = 0;
+
+                Console.WriteLine("running rock detector on tile to make shadow blob image");
+
                 if(0 == RockDetector.shadows_from_files(shadowPath, shadowBlobPath, ref numShadows)) //BUGBUG: pre-splitting ids...wont match
                 {
                     throw new Exception("Failed to generate shadow blob image");
@@ -190,6 +193,10 @@ public Dictionary<float, int> SweepShadowBlobsForGamma(float stepSize, string sh
                 GammaThresholdOverride = RockDetector.DISABLE_GAMMA_THRESH_OVERRIDE
             };
 
+            Console.WriteLine(string.Format("running rock detector on tile {0} times with gamma {1} to {2} " +
+                                            "to compute shadow blob pixels by gamma",
+                                            steps, MIN_GAMMA, MAX_GAMMA));
+
             for (int idxStep = 0; idxStep < steps; idxStep++)
             {
                 settings.Gamma = MIN_GAMMA + idxStep * stepSize;
@@ -223,10 +230,15 @@ public Dictionary<float, int> SweepShadowPixelsForGamma(float stepSize, string s
 
             float range = MAX_GAMMA - MIN_GAMMA;
             int steps = (int)Math.Ceiling(range / stepSize);
+
+            Console.WriteLine(string.Format("running rock detector on tile {0} times with gamma {1} to {2} " +
+                                            "to compute shadow pixels by gamma",
+                                            steps, MIN_GAMMA, MAX_GAMMA));
+
             for (int idxStep = 1; idxStep < steps; idxStep++) //gamma 0 is too many pixels
             {
                 float gamma = MIN_GAMMA + idxStep * stepSize;
-                var tmpImage = CreateShadowImage(TilePath, shadowPath, gamma, 0, out int thresholdInGamma);
+                var tmpImage = CreateShadowImage(TilePath, shadowPath, gamma, 0, out int thresholdInGamma, true);
                 int shadowPixels = 0;
                 for (int idxPixel = 0; idxPixel < tmpImage.Width * tmpImage.Height; idxPixel++)
                 {
@@ -321,6 +333,8 @@ private Image CreateGammaImage(string tilePath, string gammaPath)
                 File.Delete(gammaPath);
             }
 
+            Console.WriteLine("running rock detector on tile to make gamma image");
+
             if( 0 == RockDetector.gamma_from_files(tilePath, Gamma, gammaPath))
             {
                 throw new Exception("failed to make gamma image");
@@ -341,7 +355,7 @@ private Image CreateGammaImage(string tilePath, string gammaPath)
             return gammaImage;
         }
 
-        private Image CreateShadowImage(string tilePath, string shadowPath, float gamma, int thresholdOverride, out int thresholdInGamma)
+        private Image CreateShadowImage(string tilePath, string shadowPath, float gamma, int thresholdOverride, out int thresholdInGamma, bool quiet = false)
         {
             if (!File.Exists(tilePath))
             {
@@ -353,6 +367,11 @@ private Image CreateShadowImage(string tilePath, string shadowPath, float gamma,
                 File.Delete(shadowPath);
             }
 
+            if (!quiet)
+            {
+                Console.WriteLine("running rock detector on tile to make shadow image");
+            }
+
             thresholdInGamma = 0;
             if (0 == RockDetector.threshold_from_files(tilePath, gamma, thresholdOverride, shadowPath, ref thresholdInGamma))
             {

RockCollect/Stages/RefineShadows.cs

@@ -133,7 +133,9 @@ bool UpdateDetections(out RockDetector.DetectionResults results)
                 return false;
 
             results = new RockDetector.DetectionResults("Shadows", TileImage.Width, TileImage.Height);
-                                  
+
+            Console.WriteLine("running rock detector on tile to refine shadows");
+
             int numOutRocks = 0;
             RockDetector.INSETTINGS inSettings = RockDetector.CreateInSettings(settings);
             byte[] detectImage = new byte[TileImage.Width * TileImage.Height];

RockCollect/Stages/ReviewRocks.cs

@@ -364,6 +364,7 @@ private bool UpdateDetections(out RockDetector.DetectionResults results, out Bit
 
             results = new RockDetector.DetectionResults("Yours", TileImage.Width, TileImage.Height);
 
+            Console.WriteLine("running rock detector on tile to review rock detections");
 
             int numOutRocks = 0;
             RockDetector.INSETTINGS inSettings = RockDetector.CreateInSettings(settings);
@@ -500,6 +501,9 @@ public override bool SaveOutput()
                 InputToOutput("TILES_VERTICAL");
                 InputToOutput("COMPARISON_ROCKLIST");
 
+                Console.WriteLine(string.Format("saving detection settings for tile to \"{0}\" and \"{1}\"",
+                                                outJSONPath, outParamsPath));
+
                 if (!WriteOutputJSON())
                     return false;
 
@@ -509,6 +513,9 @@ public override bool SaveOutput()
                     return false;
                 }
 
+                Console.WriteLine(string.Format("running rock detector on tile, saving rock list to \"{0}\"",
+                                                outRocksListPath));
+
                 if(0 == RockDetector.detect_from_files(TilePath, outParamsPath, outRocksListPath))
                 {
                     return false;

RockCollect/Stages/TileSelect.cs

@@ -220,14 +220,18 @@ public int CountTunedTiles()
 
         internal void SaveRocklist(string fileName)
         {
+            Console.WriteLine(string.Format("running rock detector on all runnable tiles, " +
+                                            "saving resulting rocklist to \"{0}\"", fileName));
+
             int numTiles = TilesVertical * TilesHorizontal;
             var inSettings = new RockDetector.INSETTINGS[numTiles];
             var loaded = new bool[numTiles];
 
             var tsd = TileShapeData;
             var writeJSONOpts = new JsonSerializerOptions { WriteIndented = true };
 
-            Console.WriteLine("loading settings for already-tuned tiles from " + GetDirectory(Dir.FinalOutput));
+            Console.WriteLine(string.Format("loading settings for already-tuned tiles from \"{0}\"",
+                                            GetDirectory(Dir.FinalOutput)));
             int numLoaded = 0;
             for (int y = 0; y < TilesVertical; y++)
             {
@@ -294,6 +298,7 @@ internal void SaveRocklist(string fileName)
                 }
             }
 
+            int nc = 0, nf = 0;
             for (int y = 0; y < TilesVertical; y++)
             {
                 for (int x = 0; x < TilesHorizontal; x++)
@@ -313,8 +318,8 @@ internal void SaveRocklist(string fileName)
                         int maxRadius = Math.Max(x, y);
                         maxRadius = Math.Max(maxRadius, TilesHorizontal - x - 1);
                         maxRadius = Math.Max(maxRadius, TilesVertical - y - 1);
-                        Console.WriteLine(string.Format("searching for tuned neighbor of tile at col {0}, row {1}, " +
-                                                        "max radius {2}{3}", x, y, maxRadius, grpMsg));
+//                        Console.WriteLine(string.Format("searching for tuned neighbor of tile at col {0}, row {1}, " +
+//                                                        "max radius {2}{3}", x, y, maxRadius, grpMsg));
                         int ni = -1;
                         for (int radius = 1; radius <= maxRadius && ni < 0; radius++)
                         {
@@ -346,8 +351,8 @@ internal void SaveRocklist(string fileName)
                         if (ni >= 0)
                         {
                             GetTileAddress(ni, out int nx, out int ny);
-                            Console.WriteLine(string.Format("copying settings for tuned tile at col {0}, row {1} " +
-                                                            "for tile at col {2}, row {3}{4}", nx, ny, x, y, grpMsg));
+//                            Console.WriteLine(string.Format("copying settings for tuned tile at col {0}, row {1} " +
+//                                                            "for tile at col {2}, row {3}{4}", nx, ny, x, y, grpMsg));
                             inSettings[idx] = inSettings[ni];
                             string srcName = ReviewRocks.GetTileOutputName(ni, TilesHorizontal) + ".json";
                             string srcJSON = Path.Combine(GetDirectory(Dir.FinalOutput), srcName);
@@ -362,29 +367,39 @@ internal void SaveRocklist(string fileName)
                             string dstName = ReviewRocks.GetTileOutputName(idx, TilesHorizontal) + ".json";
                             string dstJSON = Path.Combine(dir, dstName);
                             File.WriteAllText(dstJSON, JsonSerializer.Serialize(data, data.GetType(), writeJSONOpts));
+                            nc++;
                         }
                         else
                         {
                             //MaxShadowArea = 0 will cause RockDetector.detect_per_tile_settings() to ignore the tile
                             Console.WriteLine(string.Format("failed to find tuned tile from which to copy settings " +
                                                             "for tile at col {0}, row {1}{2}", x, y, grpMsg));
+                            nf++;
                         }
                     }
                 }
             }
 
-            //MaxShadowArea = 0 will cause RockDetector.detect_per_tile_settings() to ignore the tile
-            if (tsd != null) {
-                for (int y = 0; y < TilesVertical; y++)
+            Console.WriteLine(string.Format("copied settings for {0} un-tuned tiles from nearest tuned neighbor{1}",
+                                            nc, tsd != null ? " in same shape file group" : ""));
+            Console.WriteLine(string.Format("failed to copy settings for {0} un-tuned tiles from any tuned neighbor{1}",
+                                            nf, tsd != null ? " in same shape file group" : ""));
+
+            int nr = 0;
+            for (int y = 0; y < TilesVertical; y++)
+            {
+                for (int x = 0; x < TilesHorizontal; x++)
                 {
-                    for (int x = 0; x < TilesHorizontal; x++)
-                    {
-                        int idx = GetTileIndex(x, y);
-                        if (tsd[idx] == null || !tsd[idx].run) inSettings[idx].MaxShadowArea = 0;
-                    }
+                    int idx = GetTileIndex(x, y);
+                    //MaxShadowArea = 0 will cause RockDetector.detect_per_tile_settings() to ignore the tile
+                    if (tsd != null && (tsd[idx] == null || !tsd[idx].run)) inSettings[idx].MaxShadowArea = 0;
+                    else if (inSettings[idx].MaxShadowArea > 0) nr++;
                 }
             }
 
+            Console.WriteLine(string.Format("running rock detector on {0} runnable of {1} total tiles, " +
+                                            "saving resulting rocklist to \"{2}\"", nr, numTiles, fileName));
+
             RockDetector.detect_per_tile_settings(ImagePath, fileName, numTiles, inSettings);
             //TODO: warn
         }

RockCollect/Workflow.cs

@@ -72,6 +72,7 @@ public void NextStage()
                 {
                     Directory.CreateDirectory(CurImageDirectory);
                 }
+                Console.WriteLine("saving per-tile settings and results at \"{0}\"", CurImageDirectory);
             }
 
             Stage nextStage = null;