EdgeDetect: findCandidates() and edgeDetect() work (according to DebugCanvas)

js/conf/ExtensionConf.js

@@ -26,7 +26,7 @@ var ExtensionConf = {
     },
     hSamples: 640,
     vSamples: 360,
-    samplingInterval: 10,     // we sample at columns at (width/this) * [ 1 .. this - 1] 
+    // samplingInterval: 10,     // we sample at columns at (width/this) * [ 1 .. this - 1] 
     blackLevel_default: 10,   // everything darker than 10/255 across all RGB components is considered black by
                               // default. GlobalVars.blackLevel can decrease if we detect darker black.
     blackbarTreshold: 16,     // if pixel is darker than blackLevel + blackbarTreshold, we count it as black

js/lib/EdgeDetect.js

@@ -36,6 +36,8 @@ class EdgeDetect{
       // } else {
         edgeCandidates = this.edgeDetect(image, fastCandidates);
         bars = this.edgePostprocess(edgeCandidates, this.conf.canvas.height);
+
+        console.log("\n------------------------------------\nguardLineOut",guardLineOut,"\nsample cols",sampleCols,"\nfast candidates:", fastCandidates, "\nedgeCandidates:",edgeCandidates,"\nbars:",bars,"\n----------------------------\n\n\n")
       // }
     } else {
       bars = this.pillarTest(image) ? {status: 'ar_known'} : {status: 'ar_unknown'};
@@ -48,8 +50,8 @@ class EdgeDetect{
     var upper_top, upper_bottom, lower_top, lower_bottom;
     var blackbarTreshold;
     
-    var cols_a = sampleCols;
+    var cols_a = sampleCols.slice(0);
-    var cols_b = []
+    var cols_b = cols_a.slice(0);
     
     // todo: cloning can be done better. check array.splice or whatever
     for(var i in sampleCols){
@@ -149,12 +151,12 @@ class EdgeDetect{
         sampleStart = 0;
       
       sampleEnd = sampleStart + this.sampleWidthBase;
-      if(sampleEnd > this.conf.canvas.imageDataRowLength)
+      if(sampleEnd > this.conf.canvasImageDataRowLength)
-        sampleEnd = this.conf.canvas.imageDataRowLength;
+        sampleEnd = this.conf.canvasImageDataRowLength;
       
       // calculate row offsets for imageData array
-      sampleRow_black = (sample.top - ExtensionConf.arDetect.edgeDetection.edgeTolerancePx) * this.conf.canvas.imageDataRowLength;
+      sampleRow_black = (sample.top - ExtensionConf.arDetect.edgeDetection.edgeTolerancePx) * this.conf.canvasImageDataRowLength;
-      sampleRow_color = (sample.top + 1 + ExtensionConf.arDetect.edgeDetection.edgeTolerancePx) * this.conf.canvas.imageDataRowLength;
+      sampleRow_color = (sample.top + 1 + ExtensionConf.arDetect.edgeDetection.edgeTolerancePx) * this.conf.canvasImageDataRowLength;
       
       // že ena kršitev črnega roba pomeni, da kandidat ni primeren
       // even a single black edge violation means the candidate is not an edge
@@ -191,12 +193,12 @@ class EdgeDetect{
         sampleStart = 0;
       
       sampleEnd = sampleStart + this.sampleWidthBase;
-      if(sampleEnd > this.conf.canvas.imageDataRowLength)
+      if(sampleEnd > this.conf.canvasImageDataRowLength)
-        sampleEnd = this.conf.canvas.imageDataRowLength;
+        sampleEnd = this.conf.canvasImageDataRowLength;
       
       // calculate row offsets for imageData array
-      sampleRow_black = (sample.bottom + ExtensionConf.arDetect.edgeDetection.edgeTolerancePx) * this.conf.canvas.imageDataRowLength;
+      sampleRow_black = (sample.bottom + ExtensionConf.arDetect.edgeDetection.edgeTolerancePx) * this.conf.canvasImageDataRowLength;
-      sampleRow_color = (sample.bottom - 1 - ExtensionConf.arDetect.edgeDetection.edgeTolerancePx) * this.conf.canvas.imageDataRowLength;
+      sampleRow_color = (sample.bottom - 1 - ExtensionConf.arDetect.edgeDetection.edgeTolerancePx) * this.conf.canvasImageDataRowLength;
       
       // že ena kršitev črnega roba pomeni, da kandidat ni primeren
       // even a single black edge violation means the candidate is not an edge
@@ -506,6 +508,12 @@ class EdgeDetect{
             });
             colsIn.splice(colsIn.indexOf(col), 1);
             this.conf.debugCanvas.trace(tmpI, DebugCanvasClasses.EDGEDETECT_CANDIDATE);      
+            if(tmpI-1 > 0){
+              this.conf.debugCanvas.trace(tmpI - 1, DebugCanvasClasses.EDGEDETECT_CANDIDATE_SECONDARY);
+            }
+            if(tmpI+1 < image.length){
+              this.conf.debugCanvas.trace(tmpI + 1, DebugCanvasClasses.EDGEDETECT_CANDIDATE_SECONDARY);
+            }
           } else {
             this.conf.debugCanvas.trace(tmpI, DebugCanvasClasses.EDGEDETECT_ONBLACK);
           }
@@ -539,7 +547,6 @@ class EdgeDetect{
         this.conf.debugCanvas.trace(i, DebugCanvasClasses.EDGEDETECT_BLACKBAR)
       }
     }
-
     return false; // no violation
   }
 

js/lib/GuardLine.js

@@ -61,7 +61,7 @@ class GuardLine {
 
     return {
       blackbarFail: false,
-      imageFail: imageCheckResult
+      imageFail: ! imageCheckResult.success
     }
   }
 
@@ -78,7 +78,8 @@ class GuardLine {
     // should succeed by default. Also need to check bottom, for cases where only one edge is known
     
     if(! fallbackMode && (! this.blackbar.top || ! this.blackbar.bottom)) {
-        return { success: true };
+      console.log("NO EDGE WAS DETECTED. THIS TEST IS POINTLESS. btw guardline")
+      return { success: true };
     }
 
     var offset = parseInt(this.conf.canvas.width * ExtensionConf.arDetect.guardLine.ignoreEdgeMargin) << 2;
@@ -104,6 +105,7 @@ class GuardLine {
     
     var rowStart, rowEnd;
     
+    console.log("!!!! -asdsa --------------- asdas-                          BLACKBAR CHECK")
     
     // <<<=======| checking upper row |========>>>
     
@@ -183,6 +185,8 @@ class GuardLine {
     
     var res = false;
     
+    console.log("!!!! -asdsa --------------- asdas-                          IMAGE CHECK")
+
     if(Debug.debugCanvas.enabled && Debug.debugCanvas.guardLine){
       res = this._ti_debugCheckRow(image, rowStart, rowEnd, successTreshold);
     } else {
@@ -198,6 +202,7 @@ class GuardLine {
     rowStart = ((edge_lower * this.conf.canvas.width) << 2) + offset;
     // rowEnd = rowStart + ( this.canvas.width << 2 ) - (offset * 2);
     
+
     if(Debug.debugCanvas.enabled && Debug.debugCanvas.guardLine){
       res = this._ti_debugCheckRow(image, rowStart, rowEnd, successTreshold);
     } else {
@@ -243,7 +248,7 @@ class GuardLine {
       // we track sections that go over what's supposed to be a black line, so we can suggest more 
       // columns to sample
       if(image[i] > this.blackbarTreshold || image[i+1] > this.blackbarTreshold || image[i+2] > this.blackbarTreshold){
-        DebugCanvas.trace('guardLine_blackbar_violation', i);      
+        this.conf.this.conf.debugCanvas.trace(i, DebugCanvasClasses.VIOLATION);      
         if(firstOffender < 0){
           firstOffender = (i - rowStart) >> 2;
           offenderCount++;
@@ -254,7 +259,7 @@ class GuardLine {
         }
       }
       else{
-        DebugCanvas.trace('guardLine_blackbar', i);              
+        this.conf.this.conf.debugCanvas.trace(i, DebugCanvasClasses.GUARDLINE_BLACKBAR);              
         // is that a black pixel again? Let's reset the 'first offender' 
         firstOffender = -1;
       }
@@ -279,12 +284,12 @@ class GuardLine {
   _ti_debugCheckRow(image, rowStart, rowEnd, successTreshold) {
     for(var i = rowStart; i < rowEnd; i+=4){
       if(image[i] > this.blackbarTreshold || image[i+1] > this.blackbarTreshold || image[i+2] > this.blackbarTreshold){
-        DebugCanvas.trace('guardLine_imageTest', i);
+        this.conf.debugCanvas.trace(i, DebugCanvasClasses.GUARDLINE_IMAGE);
         if(successTreshold --<= 0){
           return true;
         }
       } else {
-        DebugCanvas.trace('guardLine_imageTest_noimage', i);
+        this.conf.debugCanvas.trace(i, DebugCanvasClasses.WARN);
       }   
     }
   

js/modules/ArDetect.js

@@ -40,20 +40,22 @@ class ArDetector {
 
     
     try{
-      if(Debug.debug)
+      if(Debug.debug){
-        console.log("%c[ArDetect::_ard_setup] Starting automatic aspect ratio detection", _ard_console_start);
+        console.log("%c[ArDetect::_ard_setup] Starting automatic aspect ratio detection.", _ard_console_start);
+        console.log("[ArDetect::_ard_setup] Choice config bits:\ncanvas dimensions:",cwidth, "×", cheight, "\nsamplingInterval (ExtensionConf):", ExtensionConf.arDetect.samplingInterval, "width/interval:", parseInt(cheight / ExtensionConf.arDetect.samplingInterval));
+      }
     
       this._halted = false;
       this.detectionTimeoutEventCount = 0;
       
-      // vstavimo začetne stolpce v this.sampleCols. 
+      // // vstavimo začetne stolpce v this.sampleCols.  - NE!
-      // let's insert initial columns to this.sampleCols
+      // // let's insert initial columns to this.sampleCols - NO!!! do it later dow
-      this.sampleCols = [];
+      // this.sampleCols = [];
 
-      var samplingIntervalPx = parseInt(cheight / ExtensionConf.arDetect.samplingInterval)
+      // var samplingIntervalPx = parseInt(cheight / ExtensionConf.arDetect.samplingInterval)
-      for(var i = 1; i < ExtensionConf.arDetect.samplingInterval; i++){
+      // for(var i = 1; i < ExtensionConf.arDetect.samplingInterval; i++){
-        this.sampleCols.push(i * samplingIntervalPx);
+      //   this.sampleCols.push(i * samplingIntervalPx);
-      }
+      // }
       
       if(this.canvas){
         if(Debug.debug)
@@ -92,8 +94,8 @@ class ArDetector {
         var ncol = ExtensionConf.arDetect.staticSampleCols;
         var nrow = ExtensionConf.arDetect.staticSampleRows;
         
-        var colSpacing = this.cwidth / ncol;
+        var colSpacing = this.canvas.width / ncol;
-        var rowSpacing = (this.cheight << 2) / nrow;
+        var rowSpacing = (this.canvas.height << 2) / nrow;
         
         this.sampleLines = [];
         this.sampleCols = [];
@@ -164,6 +166,31 @@ class ArDetector {
     return ! this._halted;
   }
 
+  scheduleFrameCheck(timeout, force_reset){
+    if(! timeout){
+      this.frameCheck();
+      return;
+    }
+  
+    // run anything that needs to be run after frame check
+    this.postFrameCheck(); 
+
+    // don't allow more than 1 instance
+    if(this.timer){ 
+      clearTimeout(this.timer);
+    }
+    
+    var ths = this;
+
+    this.timer = setTimeout(function(){
+        ths.timer = null;
+        ths.frameCheck();
+        ths = null;
+      },
+      timeout
+    );
+  }
+
 
   postFrameCheck(){
     if(Debug.debugCanvas.enabled){
@@ -203,15 +230,15 @@ class ArDetector {
         console.log("[ArDetect::getTimeout] Exec time exceeded maximum allowed execution time. This has now happened" +  this.detectionTimeoutEventCount + "times in a row.");
       }
   
-      if( this.detectionTimeoutEventCount >= ExtensionConf.arDetect.autoDisable.consecutiveTimeoutCount ){
+      // if( this.detectionTimeoutEventCount >= ExtensionConf.arDetect.autoDisable.consecutiveTimeoutCount ){
-        if (Debug.debug){
+      //   if (Debug.debug){
-          console.log("[ArDetect::getTimeout] Maximum execution time was exceeded too many times. Automatic aspect ratio detection has been disabled.");
+      //     console.log("[ArDetect::getTimeout] Maximum execution time was exceeded too many times. Automatic aspect ratio detection has been disabled.");
-        }
+      //   }
   
-        Comms.sendToBackgroundScript({cmd: 'disable-autoar', reason: 'Automatic aspect ratio detection was taking too much time and has been automatically disabled in order to avoid lag.'});
+      //   Comms.sendToBackgroundScript({cmd: 'disable-autoar', reason: 'Automatic aspect ratio detection was taking too much time and has been automatically disabled in order to avoid lag.'});
-        _ard_stop();
+      //   _ard_stop();
-        return 999999;
+      //   return 999999;
-      }
+      // }
       
     } else {
        this.detectionTimeoutEventCount = 0;
@@ -319,11 +346,7 @@ class ArDetector {
     var imageDetectResult = false;      // true if we detect image along the way. false by default
     
 
-    // todo - can be done faster, probably. Use array.splice (i think)
+    var sampleCols = this.sampleCols.slice(0);
-    var sampleCols = [];
-    for(var i in  this.sampleCols){
-      sampleCols[i] = this.sampleCols[i];
-    }
     
     var how_far_treshold = 8; // how much can the edge pixel vary (*4)
     
@@ -457,6 +480,8 @@ class ArDetector {
       
     }
     
+    console.log("sample cols", sampleCols)
+
     // save black level only if defined
     if(currentMinVal)
       this.blackLevel = this.blackLevel < currentMinVal ? this.blackLevel : currentMinVal;
@@ -564,7 +589,7 @@ class ArDetector {
 
     // pa poglejmo, kje se končajo črne letvice na vrhu in na dnu videa.
     // let's see where black bars end.
-    GlobalVars.sampleCols_current = sampleCols.length;
+    this.sampleCols_current = sampleCols.length;
     
     // blackSamples -> {res_top, res_bottom}
    
@@ -613,33 +638,7 @@ class ArDetector {
     this.blackLevel = ExtensionConf.arDetect.blackLevel_default;    
   }
 
-  scheduleFrameCheck(timeout, force_reset){
-    if(! timeout){
-      this.frameCheck();
-      return;
-    }
-  
-    // run anything that needs to be run after frame check
-    this.postFrameCheck(); 
-
-    // don't allow more than 1 instance
-    if(this.timer){ 
-      clearTimeout(this.timer);
-    }
-    
-    var ths = this;
-
-    this.timer = setTimeout(function(){
-        ths.timer = null;
-        ths.frameCheck();
-        ths = null;
-      },
-      timeout
-    );
-  }
-
 }
-
 if(Debug.debug)
   console.log("Loading: ArDetect");
 

js/modules/DebugCanvas.js

@@ -84,6 +84,7 @@ DebugCanvasClasses = {
   
   EDGEDETECT_ONBLACK: {color: '#444444', colorRgb: [68, 68, 68], text: 'edge detect - perpendicular (to edge)'},
   EDGEDETECT_CANDIDATE: {color: '#FFFFFF', colorRgb: [255, 255, 255], text: 'edge detect - edge candidate'},
+  EDGEDETECT_CANDIDATE_SECONDARY: {color: '#OOOOOO', colorRgb: [0, 0, 0], text: 'edge detect - edge candidate, but for when candidate is really bright'},
   EDGEDETECT_BLACKBAR: {color: '#07ac93', colorRgb: [7, 172, 147], text: 'edge detect - parallel, black test'},
   EDGEDETECT_IMAGE: {color: '#046c5c', colorRgb: [4, 108, 92], text: 'edge detect - parallel, image test'}
 }