tamius-han/ultrawidify
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

switch arDetect with aard

Browse Source
This commit is contained in:
Tamius Han 2020-05-26 01:40:25 +02:00
parent 124dc33828
commit 75a214962c
5 changed files with 118 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
src/ext/lib/ar-detect/AardGl.js
View File

@ -9,7 +9,7 @@ import DebugCanvas from './DebugCanvas';
import VideoAlignment from '../../../common/enums/video-alignment.enum'; import VideoAlignment from '../../../common/enums/video-alignment.enum';
import AspectRatio from '../../../common/enums/aspect-ratio.enum'; import AspectRatio from '../../../common/enums/aspect-ratio.enum';
import { generateHorizontalAdder } from './gllib/shader-generators/HorizontalAdderGenerator'; import { generateHorizontalAdder } from './gllib/shader-generators/HorizontalAdderGenerator';
import { getVertexShader } from './gllib/shaders/vertex-shader'; import { getBasicVertexShader } from './gllib/shaders/vertex-shader';
import { sleep } from '../Util'; import { sleep } from '../Util';
/** /**
@ -30,7 +30,7 @@ class AardGl {
this.canFallback = true; this.canFallback = true;
this.fallbackMode = false; this.fallbackMode = false;
this.blackLevel = this.settings.active.arDetect.blackbar.blackLevel; this.blackLevel = this.settings.activeaard.blackbar.blackLevel;
this.arid = (Math.random()*100).toFixed(); this.arid = (Math.random()*100).toFixed();
@ -61,15 +61,15 @@ class AardGl {
// we slow down if ended or pausing. Detecting is pointless. // we slow down if ended or pausing. Detecting is pointless.
// we don't stop outright in case seeking happens during pause/after video was // we don't stop outright in case seeking happens during pause/after video was
// ended and video gets into 'playing' state again // ended and video gets into 'playing' state again
return Date.now() - lastFrameCheckStartTime > this.settings.active.arDetect.timers.paused; return Date.now() - lastFrameCheckStartTime > this.settings.activeaard.timers.paused;
} }
if (this.video.error){ if (this.video.error){
// če je video pavziran, še vedno skušamo zaznati razmerje stranic - ampak bolj poredko. // če je video pavziran, še vedno skušamo zaznati razmerje stranic - ampak bolj poredko.
// if the video is paused, we still do autodetection. We just do it less often. // if the video is paused, we still do autodetection. We just do it less often.
return Date.now() - lastFrameCheckStartTime > this.settings.active.arDetect.timers.error; return Date.now() - lastFrameCheckStartTime > this.settings.activeaard.timers.error;
} }
return Date.now() - lastFrameCheckStartTime > this.settings.active.arDetect.timers.playing; return Date.now() - lastFrameCheckStartTime > this.settings.activeaard.timers.playing;
} }
isRunning(){ isRunning(){
@ -114,7 +114,7 @@ class AardGl {
} }
resetBlackLevel(){ resetBlackLevel(){
this.blackLevel = this.settings.active.arDetect.blackbar.blackLevel; this.blackLevel = this.settings.activeaard.blackbar.blackLevel;
} }
clearImageData(id) { clearImageData(id) {
@ -223,7 +223,7 @@ class AardGl {
glContext.compileShader(shader); glContext.compileShader(shader);
// check if shader was compiled successfully // check if shader was compiled successfully
if (! glContext.getShaderParameter(shader, gl.COMPILE_STATUS)) { if (! glContext.getShaderParameter(shader, this.gl.COMPILE_STATUS)) {
glContext.deleteShader(shader); glContext.deleteShader(shader);
this.logger.log('error', ['init', 'debug', 'arDetect'], `%c[AardGl::setupShader] <@${this.arid}> Failed to setup shader.`, _ard_console_stop); this.logger.log('error', ['init', 'debug', 'arDetect'], `%c[AardGl::setupShader] <@${this.arid}> Failed to setup shader.`, _ard_console_stop);
return null; return null;
@ -238,8 +238,9 @@ class AardGl {
* @param {*} shaders — shaders (previously compiled with setupShader()) * @param {*} shaders — shaders (previously compiled with setupShader())
*/ */
compileProgram(glContext, shaders) { compileProgram(glContext, shaders) {
console.log(glContext, shaders);
const program = glContext.createProgram(); const program = glContext.createProgram();
for (const shader of shadersr) { for (const shader of shaders) {
glContext.attachShader(program, shader); glContext.attachShader(program, shader);
} }
glContext.linkProgram(program); glContext.linkProgram(program);
@ -306,8 +307,8 @@ class AardGl {
// //
if (!cwidth) { if (!cwidth) {
cwidth = this.settings.active.aardGl.canvasDimensions.sampleCanvas.width; cwidth = this.settings.activeaard.Gl.canvasDimensions.sampleCanvas.width;
cheight = this.settings.active.aardGl.canvasDimensions.sampleCanvas.height; cheight = this.settings.activeaard.Gl.canvasDimensions.sampleCanvas.height;
} }
if (this.canvas) { if (this.canvas) {
@ -322,11 +323,12 @@ class AardGl {
this.canvas.width = cwidth; this.canvas.width = cwidth;
this.canvas.height = cheight; this.canvas.height = cheight;
this.blackframeCanvas = document.createElement("canvas"); this.blackframeCanvas = document.createElement("canvas");
this.blackframeCanvas.width = this.settings.active.arDetect.canvasDimensions.blackframeCanvas.width; this.blackframeCanvas.width = this.settings.activeaard.canvasDimensions.blackframeCanvas.width;
this.blackframeCanvas.height = this.settings.active.arDetect.canvasDimensions.blackframeCanvas.height; this.blackframeCanvas.height = this.settings.activeaard.canvasDimensions.blackframeCanvas.height;
this.context = this.canvas.getContext("2d"); // this.context = this.canvas.getContext("2d");
this.pixelBuffer = new Uint8Array(cwidth * cheight * 4);
// //
// [2] SETUP WEBGL STUFF ————————————————————————————————————————————————————————————————————————————————— // [2] SETUP WEBGL STUFF —————————————————————————————————————————————————————————————————————————————————
@ -345,8 +347,8 @@ class AardGl {
const glProgram = this.compileProgram(this.gl, [vertexShader, horizontalAdderShader]); const glProgram = this.compileProgram(this.gl, [vertexShader, horizontalAdderShader]);
// look up where the vertex data needs to go // look up where the vertex data needs to go
const positionLocation = this.gl.getAttributeLocation(program, 'a_position'); // const positionLocation = this.gl.getAttributeLocation(glProgram, 'a_position');
const textureCoordsLocation = this.gl.getAttributeLocation(program, 'a_textureCoords'); // const textureCoordsLocation = this.gl.getAttributeLocation(glProgram, 'a_textureCoords');
// create buffers and bind them // create buffers and bind them
const positionBuffer = this.gl.createBuffer(); const positionBuffer = this.gl.createBuffer();
@ -355,18 +357,18 @@ class AardGl {
this.gl.bindBuffer(this.gl.ARRAY_BUFFER, textureCoordsBuffer); this.gl.bindBuffer(this.gl.ARRAY_BUFFER, textureCoordsBuffer);
// create a texture // create a texture
const texture = this.gl.createTexture(); this.texture = this.gl.createTexture();
this.gl.bindTexture(this.gl.TEXTURE_2D, texture); this.gl.bindTexture(this.gl.TEXTURE_2D, this.texture);
// set some parameters // set some parameters
// btw we don't need to set gl.TEXTURE_WRAP_[S|T], because it's set to repeat by default — which is what we want // btw we don't need to set gl.TEXTURE_WRAP_[S|T], because it's set to repeat by default — which is what we want
this.gl.texParameteri(this.gl, this.gl.TEXTURE_MAG_FILTER, gl.NEAREST); this.gl.texParameteri(this.gl, this.gl.TEXTURE_MAG_FILTER, this.gl.NEAREST);
this.gl.texParameteri(this.gl, this.gl.TEXTURE_MIN_FILTER, gl.NEAREST); this.gl.texParameteri(this.gl, this.gl.TEXTURE_MIN_FILTER, this.gl.NEAREST);
// we need a rectangle. This is output data, not texture. This means that the size of the rectangle should be // we need a rectangle. This is output data, not texture. This means that the size of the rectangle should be
// [sample count] x height of the sample, as shader can sample frame at a different resolution than what gets // [sample count] x height of the sample, as shader can sample frame at a different resolution than what gets
// rendered here. We don't need all horizontal pixels on our output. We do need all vertical pixels, though) // rendered here. We don't need all horizontal pixels on our output. We do need all vertical pixels, though)
this.glSetRectangle(this.gl, this.settings.active.aard.sampleCols, cheight); this.glSetRectangle(this.gl, this.settings.activeaard..sampleCols, cheight);
// do setup once // do setup once
// tho we could do it for every frame // tho we could do it for every frame
@ -418,6 +420,7 @@ class AardGl {
} }
this.conf.arSetupComplete = true; this.conf.arSetupComplete = true;
console.log("DRAWING BUFFER SIZE:", this.gl.drawingBufferWidth, '×', this.gl.drawingBufferHeight);
} }
drawFrame() { drawFrame() {
@ -455,7 +458,7 @@ class AardGl {
while (!this._exited && exitedRetries --> 0) { while (!this._exited && exitedRetries --> 0) {
this.logger.log('warn', 'debug', `[AardGl::main] <@${this.arid}> We are trying to start another instance of autodetection on current video, but the previous instance hasn't exited yet. Waiting for old instance to exit ...`); this.logger.log('warn', 'debug', `[AardGl::main] <@${this.arid}> We are trying to start another instance of autodetection on current video, but the previous instance hasn't exited yet. Waiting for old instance to exit ...`);
await sleep(this.settings.active.arDetect.timers.tickrate); await sleep(this.settings.activeaard.timers.tickrate);
} }
if (!this._exited) { if (!this._exited) {
this.logger.log('error', 'debug', `[AardGl::main] <@${this.arid}> Previous instance didn't exit in time. Not starting a new one.`); this.logger.log('error', 'debug', `[AardGl::main] <@${this.arid}> Previous instance didn't exit in time. Not starting a new one.`);
@ -469,7 +472,7 @@ class AardGl {
this._exited = false; this._exited = false;
// set initial timestamps so frame check will trigger the first time we run the loop // set initial timestamps so frame check will trigger the first time we run the loop
let lastFrameCheckStartTime = Date.now() - (this.settings.active.aardGl.timers.playing << 1); let lastFrameCheckStartTime = Date.now() - (this.settings.activeaard.Gl.timers.playing << 1);
const frameCheckTimes = new Array(10).fill(-1); const frameCheckTimes = new Array(10).fill(-1);
let frameCheckBufferIndex = 0; let frameCheckBufferIndex = 0;
@ -523,8 +526,12 @@ class AardGl {
// //
// [0] try drawing image to canvas // [0] try drawing image to canvas
// //
let imageData;
try { try {
this.drawFrame(); this.drawFrame();
this.fallbackMode = false; this.fallbackMode = false;
} catch (e) { } catch (e) {
this.logger.log('error', 'arDetect', `%c[AardGl::frameCheck] <@${this.arid}> %c[AardGl::frameCheck] can't draw image on canvas. ${this.canDoFallbackMode ? 'Trying canvas.drawWindow instead' : 'Doing nothing as browser doesn\'t support fallback mode.'}`, "color:#000; backgroud:#f51;", e); this.logger.log('error', 'arDetect', `%c[AardGl::frameCheck] <@${this.arid}> %c[AardGl::frameCheck] can't draw image on canvas. ${this.canDoFallbackMode ? 'Trying canvas.drawWindow instead' : 'Doing nothing as browser doesn\'t support fallback mode.'}`, "color:#000; backgroud:#f51;", e);
@ -593,7 +600,7 @@ class AardGl {
var trueHeight = this.canvas.height * zoomFactor - letterbox; var trueHeight = this.canvas.height * zoomFactor - letterbox;
if(edges.top > 1 && edges.top <= this.settings.active.arDetect.fallbackMode.noTriggerZonePx ){ if(edges.top > 1 && edges.top <= this.settings.activeaard.fallbackMode.noTriggerZonePx ){
this.logger.log('info', 'arDetect', `%c[AardGl::calculateArFromEdges] <@${this.arid}> Edge is in the no-trigger zone. Aspect ratio change is not triggered.`) this.logger.log('info', 'arDetect', `%c[AardGl::calculateArFromEdges] <@${this.arid}> Edge is in the no-trigger zone. Aspect ratio change is not triggered.`)
return; return;
} }
@ -602,7 +609,7 @@ class AardGl {
// x2, ker je safetyBorderPx definiran za eno stran. // x2, ker je safetyBorderPx definiran za eno stran.
// safety border so we can detect aspect ratio narrowing (21:9 -> 16:9). // safety border so we can detect aspect ratio narrowing (21:9 -> 16:9).
// x2 because safetyBorderPx is for one side. // x2 because safetyBorderPx is for one side.
trueHeight += (this.settings.active.arDetect.fallbackMode.safetyBorderPx << 1); trueHeight += (this.settings.activeaard.fallbackMode.safetyBorderPx << 1);
return this.canvas.width * zoomFactor / trueHeight; return this.canvas.width * zoomFactor / trueHeight;
} }
@ -631,7 +638,7 @@ class AardGl {
// is ar variance within acceptable levels? If yes -> we done // is ar variance within acceptable levels? If yes -> we done
this.logger.log('info', 'arDetect', `%c[AardGl::processAr] <@${this.arid}> New aspect ratio varies from the old one by this much:\n`,"color: #aaf","old Ar", lastAr.ar, "current ar", trueAr, "arDiff (absolute):",arDiff,"ar diff (relative to new ar)", arDiff_percent); this.logger.log('info', 'arDetect', `%c[AardGl::processAr] <@${this.arid}> New aspect ratio varies from the old one by this much:\n`,"color: #aaf","old Ar", lastAr.ar, "current ar", trueAr, "arDiff (absolute):",arDiff,"ar diff (relative to new ar)", arDiff_percent);
if (arDiff < trueAr * this.settings.active.arDetect.allowedArVariance){ if (arDiff < trueAr * this.settings.activeaard.allowedArVariance){
this.logger.log('info', 'arDetect', `%c[AardGl::processAr] <@${this.arid}> Aspect ratio change denied — diff %: ${arDiff_percent}`, "background: #740; color: #fa2"); this.logger.log('info', 'arDetect', `%c[AardGl::processAr] <@${this.arid}> Aspect ratio change denied — diff %: ${arDiff_percent}`, "background: #740; color: #fa2");
return; return;
} }

68
src/ext/lib/ar-detect/ArDetector.js
View File

@ -25,7 +25,7 @@ class ArDetector {
this.canFallback = true; this.canFallback = true;
this.fallbackMode = false; this.fallbackMode = false;
this.blackLevel = this.settings.active.arDetect.blackbar.blackLevel; this.blackLevel = this.settings.activeaard.blackbar.blackLevel;
this.arid = (Math.random()*100).toFixed(); this.arid = (Math.random()*100).toFixed();
@ -97,8 +97,8 @@ class ArDetector {
// //
if (!cwidth) { if (!cwidth) {
cwidth = this.settings.active.arDetect.canvasDimensions.sampleCanvas.width; cwidth = this.settings.activeaard.canvasDimensions.sampleCanvas.width;
cheight = this.settings.active.arDetect.canvasDimensions.sampleCanvas.height; cheight = this.settings.activeaard.canvasDimensions.sampleCanvas.height;
} }
if (this.canvas) { if (this.canvas) {
@ -113,8 +113,8 @@ class ArDetector {
this.canvas.width = cwidth; this.canvas.width = cwidth;
this.canvas.height = cheight; this.canvas.height = cheight;
this.blackframeCanvas = document.createElement("canvas"); this.blackframeCanvas = document.createElement("canvas");
this.blackframeCanvas.width = this.settings.active.arDetect.canvasDimensions.blackframeCanvas.width; this.blackframeCanvas.width = this.settings.activeaard.canvasDimensions.blackframeCanvas.width;
this.blackframeCanvas.height = this.settings.active.arDetect.canvasDimensions.blackframeCanvas.height; this.blackframeCanvas.height = this.settings.activeaard.canvasDimensions.blackframeCanvas.height;
this.context = this.canvas.getContext("2d"); this.context = this.canvas.getContext("2d");
this.blackframeContext = this.blackframeCanvas.getContext("2d"); this.blackframeContext = this.blackframeCanvas.getContext("2d");
@ -129,8 +129,8 @@ class ArDetector {
// [2] determine places we'll use to sample our main frame // [2] determine places we'll use to sample our main frame
// //
var ncol = this.settings.active.arDetect.sampling.staticCols; var ncol = this.settings.activeaard.sampling.staticCols;
var nrow = this.settings.active.arDetect.sampling.staticRows; var nrow = this.settings.activeaard.sampling.staticRows;
var colSpacing = this.canvas.width / ncol; var colSpacing = this.canvas.width / ncol;
var rowSpacing = (this.canvas.height << 2) / nrow; var rowSpacing = (this.canvas.height << 2) / nrow;
@ -258,7 +258,7 @@ class ArDetector {
while (!this._exited && exitedRetries --> 0) { while (!this._exited && exitedRetries --> 0) {
this.logger.log('warn', 'debug', `[ArDetect::main] <@${this.arid}> We are trying to start another instance of autodetection on current video, but the previous instance hasn't exited yet. Waiting for old instance to exit ...`); this.logger.log('warn', 'debug', `[ArDetect::main] <@${this.arid}> We are trying to start another instance of autodetection on current video, but the previous instance hasn't exited yet. Waiting for old instance to exit ...`);
await sleep(this.settings.active.arDetect.timers.tickrate); await sleep(this.settings.activeaard.timers.tickrate);
} }
if (!this._exited) { if (!this._exited) {
this.logger.log('error', 'debug', `[ArDetect::main] <@${this.arid}> Previous instance didn't exit in time. Not starting a new one.`); this.logger.log('error', 'debug', `[ArDetect::main] <@${this.arid}> Previous instance didn't exit in time. Not starting a new one.`);
@ -272,7 +272,7 @@ class ArDetector {
this._exited = false; this._exited = false;
// set initial timestamps so frame check will trigger the first time we run the loop // set initial timestamps so frame check will trigger the first time we run the loop
let lastFrameCheckStartTime = Date.now() - (this.settings.active.arDetect.timers.playing << 1); let lastFrameCheckStartTime = Date.now() - (this.settings.activeaard.timers.playing << 1);
const frameCheckTimes = new Array(10).fill(-1); const frameCheckTimes = new Array(10).fill(-1);
let frameCheckBufferIndex = 0; let frameCheckBufferIndex = 0;
@ -303,7 +303,7 @@ class ArDetector {
} }
} }
await sleep(this.settings.active.arDetect.timers.tickrate); await sleep(this.settings.activeaard.timers.tickrate);
} }
this.logger.log('info', 'debug', `%c[ArDetect::main] <@${this.arid}> Main autodetection loop exited. Halted? ${this._halted}`, _ard_console_stop); this.logger.log('info', 'debug', `%c[ArDetect::main] <@${this.arid}> Main autodetection loop exited. Halted? ${this._halted}`, _ard_console_stop);
@ -319,15 +319,15 @@ class ArDetector {
// we slow down if ended or pausing. Detecting is pointless. // we slow down if ended or pausing. Detecting is pointless.
// we don't stop outright in case seeking happens during pause/after video was // we don't stop outright in case seeking happens during pause/after video was
// ended and video gets into 'playing' state again // ended and video gets into 'playing' state again
return Date.now() - lastFrameCheckStartTime > this.settings.active.arDetect.timers.paused; return Date.now() - lastFrameCheckStartTime > this.settings.activeaard.timers.paused;
} }
if (this.video.error){ if (this.video.error){
// če je video pavziran, še vedno skušamo zaznati razmerje stranic - ampak bolj poredko. // če je video pavziran, še vedno skušamo zaznati razmerje stranic - ampak bolj poredko.
// if the video is paused, we still do autodetection. We just do it less often. // if the video is paused, we still do autodetection. We just do it less often.
return Date.now() - lastFrameCheckStartTime > this.settings.active.arDetect.timers.error; return Date.now() - lastFrameCheckStartTime > this.settings.activeaard.timers.error;
} }
return Date.now() - lastFrameCheckStartTime > this.settings.active.arDetect.timers.playing; return Date.now() - lastFrameCheckStartTime > this.settings.activeaard.timers.playing;
} }
isRunning(){ isRunning(){
@ -445,7 +445,7 @@ class ArDetector {
var trueHeight = this.canvas.height * zoomFactor - letterbox; var trueHeight = this.canvas.height * zoomFactor - letterbox;
if(edges.top > 1 && edges.top <= this.settings.active.arDetect.fallbackMode.noTriggerZonePx ){ if(edges.top > 1 && edges.top <= this.settings.activeaard.fallbackMode.noTriggerZonePx ){
this.logger.log('info', 'arDetect', `%c[ArDetect::calculateArFromEdges] <@${this.arid}> Edge is in the no-trigger zone. Aspect ratio change is not triggered.`) this.logger.log('info', 'arDetect', `%c[ArDetect::calculateArFromEdges] <@${this.arid}> Edge is in the no-trigger zone. Aspect ratio change is not triggered.`)
return; return;
} }
@ -454,7 +454,7 @@ class ArDetector {
// x2, ker je safetyBorderPx definiran za eno stran. // x2, ker je safetyBorderPx definiran za eno stran.
// safety border so we can detect aspect ratio narrowing (21:9 -> 16:9). // safety border so we can detect aspect ratio narrowing (21:9 -> 16:9).
// x2 because safetyBorderPx is for one side. // x2 because safetyBorderPx is for one side.
trueHeight += (this.settings.active.arDetect.fallbackMode.safetyBorderPx << 1); trueHeight += (this.settings.activeaard.fallbackMode.safetyBorderPx << 1);
return this.canvas.width * zoomFactor / trueHeight; return this.canvas.width * zoomFactor / trueHeight;
} }
@ -483,7 +483,7 @@ class ArDetector {
// is ar variance within acceptable levels? If yes -> we done // is ar variance within acceptable levels? If yes -> we done
this.logger.log('info', 'arDetect', `%c[ArDetect::processAr] <@${this.arid}> New aspect ratio varies from the old one by this much:\n`,"color: #aaf","old Ar", lastAr.ar, "current ar", trueAr, "arDiff (absolute):",arDiff,"ar diff (relative to new ar)", arDiff_percent); this.logger.log('info', 'arDetect', `%c[ArDetect::processAr] <@${this.arid}> New aspect ratio varies from the old one by this much:\n`,"color: #aaf","old Ar", lastAr.ar, "current ar", trueAr, "arDiff (absolute):",arDiff,"ar diff (relative to new ar)", arDiff_percent);
if (arDiff < trueAr * this.settings.active.arDetect.allowedArVariance){ if (arDiff < trueAr * this.settings.activeaard.allowedArVariance){
this.logger.log('info', 'arDetect', `%c[ArDetect::processAr] <@${this.arid}> Aspect ratio change denied — diff %: ${arDiff_percent}`, "background: #740; color: #fa2"); this.logger.log('info', 'arDetect', `%c[ArDetect::processAr] <@${this.arid}> Aspect ratio change denied — diff %: ${arDiff_percent}`, "background: #740; color: #fa2");
return; return;
} }
@ -698,11 +698,11 @@ class ArDetector {
} else { } else {
if (this.conf.player.dimensions){ if (this.conf.player.dimensions){
this.guardLine.setBlackbarManual({ this.guardLine.setBlackbarManual({
top: this.settings.active.arDetect.fallbackMode.noTriggerZonePx, top: this.settings.activeaard.fallbackMode.noTriggerZonePx,
bottom: this.conf.player.dimensions.height - this.settings.active.arDetect.fallbackMode.noTriggerZonePx - 1 bottom: this.conf.player.dimensions.height - this.settings.activeaard.fallbackMode.noTriggerZonePx - 1
},{ },{
top: edgePost.guardLineTop + this.settings.active.arDetect.guardLine.edgeTolerancePx, top: edgePost.guardLineTop + this.settings.activeaard.guardLine.edgeTolerancePx,
bottom: edgePost.guardLineBottom - this.settings.active.arDetect.guardLine.edgeTolerancePx bottom: edgePost.guardLineBottom - this.settings.activeaard.guardLine.edgeTolerancePx
}) })
} }
} }
@ -724,7 +724,7 @@ class ArDetector {
} }
resetBlackLevel(){ resetBlackLevel(){
this.blackLevel = this.settings.active.arDetect.blackbar.blackLevel; this.blackLevel = this.settings.activeaard.blackbar.blackLevel;
} }
blackLevelTest_full() { blackLevelTest_full() {
@ -749,7 +749,7 @@ class ArDetector {
let cumulativeValue = 0; let cumulativeValue = 0;
let blackPixelCount = 0; let blackPixelCount = 0;
const bfImageData = this.blackframeContext.getImageData(0, 0, cols, rows).data; const bfImageData = this.blackframeContext.getImageData(0, 0, cols, rows).data;
const blackTreshold = this.blackLevel + this.settings.active.arDetect.blackbar.frameTreshold; const blackTreshold = this.blackLevel + this.settings.activeaard.blackbar.frameTreshold;
// we do some recon for letterbox and pillarbox. While this can't determine whether letterbox/pillarbox exists // we do some recon for letterbox and pillarbox. While this can't determine whether letterbox/pillarbox exists
@ -810,17 +810,17 @@ class ArDetector {
} }
} }
const hasSufficientVariance = Math.abs(var_r - var_g) / Math.max(var_r, var_g, 1) > this.settings.active.arDetect.blackframe.sufficientColorVariance const hasSufficientVariance = Math.abs(var_r - var_g) / Math.max(var_r, var_g, 1) > this.settings.activeaard.blackframe.sufficientColorVariance
|| Math.abs(var_r - var_b) / Math.max(var_r, var_b, 1) > this.settings.active.arDetect.blackframe.sufficientColorVariance || Math.abs(var_r - var_b) / Math.max(var_r, var_b, 1) > this.settings.activeaard.blackframe.sufficientColorVariance
|| Math.abs(var_b - var_g) / Math.max(var_b, var_g, 1) > this.settings.active.arDetect.blackframe.sufficientColorVariance || Math.abs(var_b - var_g) / Math.max(var_b, var_g, 1) > this.settings.activeaard.blackframe.sufficientColorVariance
let isBlack = (blackPixelCount/(cols * rows) > this.settings.active.arDetect.blackframe.blackPixelsCondition); let isBlack = (blackPixelCount/(cols * rows) > this.settings.activeaard.blackframe.blackPixelsCondition);
if (! isBlack) { if (! isBlack) {
if (hasSufficientVariance) { if (hasSufficientVariance) {
isBlack = cumulativeValue < this.settings.active.arDetect.blackframe.cumulativeThresholdLax; isBlack = cumulativeValue < this.settings.activeaard.blackframe.cumulativeThresholdLax;
} else { } else {
isBlack = cumulativeValue < this.settings.active.arDetect.blackframe.cumulativeThresholdStrict; isBlack = cumulativeValue < this.settings.activeaard.blackframe.cumulativeThresholdStrict;
} }
} }
@ -842,13 +842,13 @@ class ArDetector {
gb: Math.abs(var_b - var_g) / Math.max(var_b, var_g, 1), gb: Math.abs(var_b - var_g) / Math.max(var_b, var_g, 1),
}, },
relativePercent: { relativePercent: {
rg: Math.abs(var_r - var_g) / Math.max(var_r, var_g, 1) / this.settings.active.arDetect.blackframe.sufficientColorVariance, rg: Math.abs(var_r - var_g) / Math.max(var_r, var_g, 1) / this.settings.activeaard.blackframe.sufficientColorVariance,
rb: Math.abs(var_r - var_b) / Math.max(var_r, var_b, 1) / this.settings.active.arDetect.blackframe.sufficientColorVariance, rb: Math.abs(var_r - var_b) / Math.max(var_r, var_b, 1) / this.settings.activeaard.blackframe.sufficientColorVariance,
gb: Math.abs(var_b - var_g) / Math.max(var_b, var_g, 1) / this.settings.active.arDetect.blackframe.sufficientColorVariance, gb: Math.abs(var_b - var_g) / Math.max(var_b, var_g, 1) / this.settings.activeaard.blackframe.sufficientColorVariance,
}, },
varianceLimit: this.settings.active.arDetect.blackframe.sufficientColorVariance, varianceLimit: this.settings.activeaard.blackframe.sufficientColorVariance,
}, },
cumulativeValuePercent: cumulativeValue / (hasSufficientVariance ? this.settings.active.arDetect.blackframe.cumulativeThresholdLax : this.settings.active.arDetect.blackframe.cumulativeThresholdStrict), cumulativeValuePercent: cumulativeValue / (hasSufficientVariance ? this.settings.activeaard.blackframe.cumulativeThresholdLax : this.settings.activeaard.blackframe.cumulativeThresholdStrict),
rowMax: rowMax, rowMax: rowMax,
colMax: colMax, colMax: colMax,
}; };
@ -867,7 +867,7 @@ class ArDetector {
// If we detect anything darker than blackLevel, we modify blackLevel to the new lowest value // If we detect anything darker than blackLevel, we modify blackLevel to the new lowest value
const rowOffset = this.canvas.width * (this.canvas.height - 1); const rowOffset = this.canvas.width * (this.canvas.height - 1);
let currentMin = 255, currentMax = 0, colOffset_r, colOffset_g, colOffset_b, colOffset_rb, colOffset_gb, colOffset_bb, blthreshold = this.settings.active.arDetect.blackbar.threshold; let currentMin = 255, currentMax = 0, colOffset_r, colOffset_g, colOffset_b, colOffset_rb, colOffset_gb, colOffset_bb, blthreshold = this.settings.activeaard.blackbar.threshold;
// detect black level. if currentMax comes above blackbar + blackbar threshold, we know we aren't letterboxed // detect black level. if currentMax comes above blackbar + blackbar threshold, we know we aren't letterboxed

22
src/ext/lib/ar-detect/GuardLine.js
View File

@ -28,8 +28,8 @@ class GuardLine {
} }
setBlackbar(bbconf){ setBlackbar(bbconf){
var bbTop = bbconf.top - this.settings.active.arDetect.guardLine.edgeTolerancePx; var bbTop = bbconf.top - this.settings.activeaard.guardLine.edgeTolerancePx;
var bbBottom = bbconf.bottom + this.settings.active.arDetect.guardLine.edgeTolerancePx; var bbBottom = bbconf.bottom + this.settings.activeaard.guardLine.edgeTolerancePx;
// to odstrani vse neveljavne nastavitve in vse možnosti, ki niso smiselne // to odstrani vse neveljavne nastavitve in vse možnosti, ki niso smiselne
// this removes any configs with invalid values or values that dont make sense // this removes any configs with invalid values or values that dont make sense
@ -43,16 +43,16 @@ class GuardLine {
} }
this.imageBar = { this.imageBar = {
top: bbconf.top + 1 + this.settings.active.arDetect.guardLine.edgeTolerancePx, top: bbconf.top + 1 + this.settings.activeaard.guardLine.edgeTolerancePx,
bottom: bbconf.bottom - 1 - this.settings.active.arDetect.guardLine.edgeTolerancePx bottom: bbconf.bottom - 1 - this.settings.activeaard.guardLine.edgeTolerancePx
} }
} }
check(image, fallbackMode){ check(image, fallbackMode){
// izračunaj enkrat in shrani na objekt // izračunaj enkrat in shrani na objekt
// calculate once and save object-instance-wide // calculate once and save object-instance-wide
this.blackbarThreshold = this.conf.blackLevel + this.settings.active.arDetect.blackbar.threshold; this.blackbarThreshold = this.conf.blackLevel + this.settings.activeaard.blackbar.threshold;
this.imageThreshold = this.blackbarThreshold + this.settings.active.arDetect.blackbar.imageThreshold; this.imageThreshold = this.blackbarThreshold + this.settings.activeaard.blackbar.imageThreshold;
// dejansko testiranje // dejansko testiranje
// actual checks // actual checks
@ -95,7 +95,7 @@ class GuardLine {
return { success: true }; return { success: true };
} }
var offset = parseInt(this.conf.canvas.width * this.settings.active.arDetect.guardLine.ignoreEdgeMargin) << 2; var offset = parseInt(this.conf.canvas.width * this.settings.activeaard.guardLine.ignoreEdgeMargin) << 2;
var offenders = []; var offenders = [];
var offenderCount = -1; // doing it this way means first offender has offenderCount==0. Ez index. var offenderCount = -1; // doing it this way means first offender has offenderCount==0. Ez index.
@ -160,7 +160,7 @@ class GuardLine {
if(!this.imageBar.top || !this.imageBar.bottom) if(!this.imageBar.top || !this.imageBar.bottom)
return { success: false }; return { success: false };
var offset = (this.conf.canvas.width * this.settings.active.arDetect.guardLine.ignoreEdgeMargin) << 2; var offset = (this.conf.canvas.width * this.settings.activeaard.guardLine.ignoreEdgeMargin) << 2;
// TODO: implement logo check. // TODO: implement logo check.
@ -169,8 +169,8 @@ class GuardLine {
// check both rows - by the rules and definitions, we shouldn't go out of bounds here. no need to check, then // check both rows - by the rules and definitions, we shouldn't go out of bounds here. no need to check, then
// if(fallbackMode){ // if(fallbackMode){
// var edge_upper = this.settings.active.arDetect.fallbackMode.noTriggerZonePx; // var edge_upper = this.settings.activeaard.fallbackMode.noTriggerZonePx;
// var edge_lower = this.conf.canvas.height - this.settings.active.arDetect.fallbackMode.noTriggerZonePx - 1; // var edge_lower = this.conf.canvas.height - this.settings.activeaard.fallbackMode.noTriggerZonePx - 1;
// } // }
// else{ // else{
var edge_upper = this.imageBar.top; var edge_upper = this.imageBar.top;
@ -181,7 +181,7 @@ class GuardLine {
// robu (eden izmed robov je lahko v celoti črn) // robu (eden izmed robov je lahko v celoti črn)
// how many non-black pixels we need to consider this check a success. We only need to detect enough pixels // how many non-black pixels we need to consider this check a success. We only need to detect enough pixels
// on one edge (one of the edges can be black as long as both aren't) // on one edge (one of the edges can be black as long as both aren't)
var successThreshold = (this.conf.canvas.width * this.settings.active.arDetect.guardLine.imageTestThreshold); var successThreshold = (this.conf.canvas.width * this.settings.activeaard.guardLine.imageTestThreshold);
var rowStart, rowEnd; var rowStart, rowEnd;

76
src/ext/lib/ar-detect/edge-detect/EdgeDetect.js
View File

@ -15,10 +15,10 @@ class EdgeDetect{
this.logger = ardConf.logger; this.logger = ardConf.logger;
this.settings = ardConf.settings; this.settings = ardConf.settings;
this.sampleWidthBase = this.settings.active.arDetect.edgeDetection.sampleWidth << 2; // corrected so we can work on imageData this.sampleWidthBase = this.settings.active.aard.edgeDetection.sampleWidth << 2; // corrected so we can work on imageData
this.halfSample = this.sampleWidthBase >> 1; this.halfSample = this.sampleWidthBase >> 1;
this.detectionThreshold = this.settings.active.arDetect.edgeDetection.detectionThreshold; this.detectionThreshold = this.settings.active.aard.edgeDetection.detectionThreshold;
this.init(); // initiate things that can change this.init(); // initiate things that can change
} }
@ -73,12 +73,12 @@ class EdgeDetect{
const cols_b = cols_a.slice(0); const cols_b = cols_a.slice(0);
const res_bottom = []; const res_bottom = [];
this.colsThreshold = sampleCols.length * this.settings.active.arDetect.edgeDetection.minColsForSearch; this.colsThreshold = sampleCols.length * this.settings.active.aard.edgeDetection.minColsForSearch;
if (this.colsThreshold == 0) if (this.colsThreshold == 0)
this.colsThreshold = 1; this.colsThreshold = 1;
this.blackbarThreshold = this.conf.blackLevel + this.settings.active.arDetect.blackbar.threshold; this.blackbarThreshold = this.conf.blackLevel + this.settings.active.aard.blackbar.threshold;
this.imageThreshold = this.blackbarThreshold + this.settings.active.arDetect.blackbar.imageThreshold; this.imageThreshold = this.blackbarThreshold + this.settings.active.aard.blackbar.imageThreshold;
// if guardline didn't fail and imageDetect did, we don't have to check the upper few pixels // if guardline didn't fail and imageDetect did, we don't have to check the upper few pixels
// but only if upper and lower edge are defined. If they're not, we need to check full height // but only if upper and lower edge are defined. If they're not, we need to check full height
@ -100,14 +100,14 @@ class EdgeDetect{
lower_bottom = this.conf.canvas.height - 1; lower_bottom = this.conf.canvas.height - 1;
} else { } else {
upper_top = 0; upper_top = 0;
upper_bottom = (this.conf.canvas.height >> 1) /*- parseInt(this.conf.canvas.height * this.settings.active.arDetect.edgeDetection.middleIgnoredArea);*/ upper_bottom = (this.conf.canvas.height >> 1) /*- parseInt(this.conf.canvas.height * this.settings.active.aard.edgeDetection.middleIgnoredArea);*/
lower_top = (this.conf.canvas.height >> 1) /*+ parseInt(this.conf.canvas.height * this.settings.active.arDetect.edgeDetection.middleIgnoredArea);*/ lower_top = (this.conf.canvas.height >> 1) /*+ parseInt(this.conf.canvas.height * this.settings.active.aard.edgeDetection.middleIgnoredArea);*/
lower_bottom = this.conf.canvas.height - 1; lower_bottom = this.conf.canvas.height - 1;
} }
} else{ } else{
upper_top = 0; upper_top = 0;
upper_bottom = (this.conf.canvas.height >> 1) /*- parseInt(this.conf.canvas.height * this.settings.active.arDetect.edgeDetection.middleIgnoredArea);*/ upper_bottom = (this.conf.canvas.height >> 1) /*- parseInt(this.conf.canvas.height * this.settings.active.aard.edgeDetection.middleIgnoredArea);*/
lower_top = (this.conf.canvas.height >> 1) /*+ parseInt(this.conf.canvas.height * this.settings.active.arDetect.edgeDetection.middleIgnoredArea);*/ lower_top = (this.conf.canvas.height >> 1) /*+ parseInt(this.conf.canvas.height * this.settings.active.aard.edgeDetection.middleIgnoredArea);*/
lower_bottom = this.conf.canvas.height - 1; lower_bottom = this.conf.canvas.height - 1;
} }
@ -251,8 +251,8 @@ class EdgeDetect{
sampleEnd = this.conf.canvasImageDataRowLength; sampleEnd = this.conf.canvasImageDataRowLength;
// calculate row offsets for imageData array // calculate row offsets for imageData array
sampleRow_black = (sample.black - this.settings.active.arDetect.edgeDetection.edgeTolerancePx - 1) * this.conf.canvasImageDataRowLength; sampleRow_black = (sample.black - this.settings.active.aard.edgeDetection.edgeTolerancePx - 1) * this.conf.canvasImageDataRowLength;
sampleRow_color = (sample.black + this.settings.active.arDetect.edgeDetection.edgeTolerancePx) * this.conf.canvasImageDataRowLength; sampleRow_color = (sample.black + this.settings.active.aard.edgeDetection.edgeTolerancePx) * this.conf.canvasImageDataRowLength;
// že ena kršitev črnega roba pomeni, da kandidat ni primeren // že ena kršitev črnega roba pomeni, da kandidat ni primeren
// even a single black edge violation means the candidate is not an edge // even a single black edge violation means the candidate is not an edge
@ -294,8 +294,8 @@ class EdgeDetect{
sampleEnd = this.conf.canvasImageDataRowLength; sampleEnd = this.conf.canvasImageDataRowLength;
// calculate row offsets for imageData array // calculate row offsets for imageData array
sampleRow_black = (sample.black + this.settings.active.arDetect.edgeDetection.edgeTolerancePx + 1) * this.conf.canvasImageDataRowLength; sampleRow_black = (sample.black + this.settings.active.aard.edgeDetection.edgeTolerancePx + 1) * this.conf.canvasImageDataRowLength;
sampleRow_color = (sample.black - this.settings.active.arDetect.edgeDetection.edgeTolerancePx) * this.conf.canvasImageDataRowLength; sampleRow_color = (sample.black - this.settings.active.aard.edgeDetection.edgeTolerancePx) * this.conf.canvasImageDataRowLength;
// že ena kršitev črnega roba pomeni, da kandidat ni primeren // že ena kršitev črnega roba pomeni, da kandidat ni primeren
// even a single black edge violation means the candidate is not an edge // even a single black edge violation means the candidate is not an edge
@ -337,7 +337,7 @@ class EdgeDetect{
edgePostprocess(edges){ edgePostprocess(edges){
var edgesTop = []; var edgesTop = [];
var edgesBottom = []; var edgesBottom = [];
var alignMargin = this.conf.canvas.height * this.settings.active.arDetect.allowedMisaligned; var alignMargin = this.conf.canvas.height * this.settings.active.aard.allowedMisaligned;
var missingEdge = edges.edgeCandidatesTopCount == 0 || edges.edgeCandidatesBottomCount == 0; var missingEdge = edges.edgeCandidatesTopCount == 0 || edges.edgeCandidatesBottomCount == 0;
@ -391,8 +391,8 @@ class EdgeDetect{
var blackbarWidth = edgesTop[0].distance > edgesBottom[0].distance ? var blackbarWidth = edgesTop[0].distance > edgesBottom[0].distance ?
edgesTop[0].distance : edgesBottom[0].distance; edgesTop[0].distance : edgesBottom[0].distance;
if (edgesTop[0].count + edgesBottom[0].count > this.settings.active.arDetect.edgeDetection.singleSideConfirmationThreshold if (edgesTop[0].count + edgesBottom[0].count > this.settings.active.aard.edgeDetection.singleSideConfirmationThreshold
|| ( edgesTop[0].count > this.settings.active.arDetect.edgeDetection.confirmationThreshold && edgesBottom[0].count > this.settings.active.arDetect.edgeDetection.confirmationThreshold) ){ || ( edgesTop[0].count > this.settings.active.aard.edgeDetection.confirmationThreshold && edgesBottom[0].count > this.settings.active.aard.edgeDetection.confirmationThreshold) ){
return { return {
status: EdgeStatus.AR_KNOWN, status: EdgeStatus.AR_KNOWN,
blackbarWidth: blackbarWidth, blackbarWidth: blackbarWidth,
@ -409,7 +409,7 @@ class EdgeDetect{
// it could be watermark. It could be a dark frame. Let's check for watermark first. // it could be watermark. It could be a dark frame. Let's check for watermark first.
if (edgesTop[0].distance < edgesBottom[0].distance && if (edgesTop[0].distance < edgesBottom[0].distance &&
edgesTop[0].count < edgesBottom[0].count && edgesTop[0].count < edgesBottom[0].count &&
edgesTop[0].count < this.conf.sampleCols.length * this.settings.active.arDetect.edgeDetection.logoThreshold){ edgesTop[0].count < this.conf.sampleCols.length * this.settings.active.aard.edgeDetection.logoThreshold){
// možno, da je watermark zgoraj. Preverimo, če se kateri od drugih potencialnih robov na zgornjem robu // možno, da je watermark zgoraj. Preverimo, če se kateri od drugih potencialnih robov na zgornjem robu
// ujema s prvim spodnjim (+/- variance). Če je temu tako, potem bo verjetno watermark. Logo mora imeti // ujema s prvim spodnjim (+/- variance). Če je temu tako, potem bo verjetno watermark. Logo mora imeti
// manj vzorcev kot navaden rob. // manj vzorcev kot navaden rob.
@ -425,8 +425,8 @@ class EdgeDetect{
var blackbarWidth = edgesTop[i].distance > edgesBottom[0].distance ? var blackbarWidth = edgesTop[i].distance > edgesBottom[0].distance ?
edgesTop[i].distance : edgesBottom[0].distance; edgesTop[i].distance : edgesBottom[0].distance;
if (edgesTop[i].count + edgesBottom[0].count > this.settings.active.arDetect.edgeDetection.singleSideConfirmationThreshold if (edgesTop[i].count + edgesBottom[0].count > this.settings.active.aard.edgeDetection.singleSideConfirmationThreshold
|| (edgesTop[i].count > this.settings.active.arDetect.edgeDetection.singleSideConfirmationThreshold && edgesBottom[0].count > this.settings.active.arDetect.edgeDetection.confirmationThreshold) ) { || (edgesTop[i].count > this.settings.active.aard.edgeDetection.singleSideConfirmationThreshold && edgesBottom[0].count > this.settings.active.aard.edgeDetection.confirmationThreshold) ) {
return { return {
status: EdgeStatus.AR_KNOWN, status: EdgeStatus.AR_KNOWN,
blackbarWidth: blackbarWidth, blackbarWidth: blackbarWidth,
@ -443,7 +443,7 @@ class EdgeDetect{
} }
if (edgesBottom[0].distance < edgesTop[0].distance && if (edgesBottom[0].distance < edgesTop[0].distance &&
edgesBottom[0].count < edgesTop[0].count && edgesBottom[0].count < edgesTop[0].count &&
edgesBottom[0].count < this.conf.sampleCols.length * this.settings.active.arDetect.edgeDetection.logoThreshold){ edgesBottom[0].count < this.conf.sampleCols.length * this.settings.active.aard.edgeDetection.logoThreshold){
if(edgesBottom[0].length > 1){ if(edgesBottom[0].length > 1){
var lowMargin = edgesTop[0].distance - alignMargin; var lowMargin = edgesTop[0].distance - alignMargin;
@ -456,8 +456,8 @@ class EdgeDetect{
var blackbarWidth = edgesBottom[i].distance > edgesTop[0].distance ? var blackbarWidth = edgesBottom[i].distance > edgesTop[0].distance ?
edgesBottom[i].distance : edgesTop[0].distance; edgesBottom[i].distance : edgesTop[0].distance;
if (edgesTop[0].count + edgesBottom[i].count > this.settings.active.arDetect.edgeDetection.singleSideConfirmationThreshold if (edgesTop[0].count + edgesBottom[i].count > this.settings.active.aard.edgeDetection.singleSideConfirmationThreshold
|| (edgesTop[0].count > this.settings.active.arDetect.edgeDetection.singleSideConfirmationThreshold && edgesBottom[i].count > this.settings.active.arDetect.edgeDetection.confirmationThreshold)) { || (edgesTop[0].count > this.settings.active.aard.edgeDetection.singleSideConfirmationThreshold && edgesBottom[i].count > this.settings.active.aard.edgeDetection.confirmationThreshold)) {
return { return {
status: EdgeStatus.AR_KNOWN, status: EdgeStatus.AR_KNOWN,
blackbarWidth: blackbarWidth, blackbarWidth: blackbarWidth,
@ -479,7 +479,7 @@ class EdgeDetect{
// either the top or the bottom edge remains undetected, but we have one more trick that we // either the top or the bottom edge remains undetected, but we have one more trick that we
// can try. It also tries to work around logos. // can try. It also tries to work around logos.
const edgeDetectionThreshold = this.settings.active.arDetect.edgeDetection.singleSideConfirmationThreshold; const edgeDetectionThreshold = this.settings.active.aard.edgeDetection.singleSideConfirmationThreshold;
if (edges.edgeCandidatesTopCount == 0 && edges.edgeCandidatesBottomCount != 0){ if (edges.edgeCandidatesTopCount == 0 && edges.edgeCandidatesBottomCount != 0){
for(var edge of edgesBottom){ for(var edge of edgesBottom){
@ -524,7 +524,7 @@ class EdgeDetect{
// we also return true if we detect too much black // we also return true if we detect too much black
var blackbarThreshold, upper, lower; var blackbarThreshold, upper, lower;
blackbarThreshold = this.conf.blackLevel + this.settings.active.arDetect.blackbar.threshold; blackbarThreshold = this.conf.blackLevel + this.settings.active.aard.blackbar.threshold;
var middleRowStart = (this.conf.canvas.height >> 1) * this.conf.canvas.width; var middleRowStart = (this.conf.canvas.height >> 1) * this.conf.canvas.width;
@ -562,11 +562,11 @@ class EdgeDetect{
// če sta oba robova v mejah merske napake, potem vrnemo 'false' // če sta oba robova v mejah merske napake, potem vrnemo 'false'
// if both edges resemble rounding error, we retunr 'false' // if both edges resemble rounding error, we retunr 'false'
if(edge_left < this.settings.active.arDetect.pillarTest.ignoreThinPillarsPx && edge_right < this.settings.active.arDetect.pillarTest.ignoreThinPillarsPx){ if(edge_left < this.settings.active.aard.pillarTest.ignoreThinPillarsPx && edge_right < this.settings.active.aard.pillarTest.ignoreThinPillarsPx){
return false; return false;
} }
var edgeError = this.settings.active.arDetect.pillarTest.allowMisaligned; var edgeError = this.settings.active.aard.pillarTest.allowMisaligned;
var error_low = 1 - edgeError; var error_low = 1 - edgeError;
var error_hi = 1 + edgeError; var error_hi = 1 + edgeError;
@ -646,7 +646,7 @@ class EdgeDetect{
imageRow: -1, imageRow: -1,
lastValue: -1, lastValue: -1,
diffIndex: 0, diffIndex: 0,
diffs: new Array(this.settings.active.arDetect.blackbar.gradientSampleSize).fill(0) diffs: new Array(this.settings.active.aard.blackbar.gradientSampleSize).fill(0)
} }
} }
@ -724,7 +724,7 @@ class EdgeDetect{
} }
colsTmp[c].diffIndex++; colsTmp[c].diffIndex++;
if (colsTmp[c].diffIndex > this.settings.active.arDetect.blackbar.gradientSampleSize) { if (colsTmp[c].diffIndex > this.settings.active.aard.blackbar.gradientSampleSize) {
colsTmp[c].imageFound = true; colsTmp[c].imageFound = true;
continue; continue;
} }
@ -737,11 +737,11 @@ class EdgeDetect{
// let's process our results // let's process our results
for (const c of colsTmp) { for (const c of colsTmp) {
if (c.blackFound) { if (c.blackFound) {
if (this.settings.active.arDetect.blackbar.antiGradientMode === AntiGradientMode.Disabled) { if (this.settings.active.aard.blackbar.antiGradientMode === AntiGradientMode.Disabled) {
// if gradient detection is disabled, we treat such columns as detections/not gradient // if gradient detection is disabled, we treat such columns as detections/not gradient
} }
if (c.imageFound) { if (c.imageFound) {
if (c.imageRow - c.blackRow <= this.settings.active.arDetect.blackbar.gradientThreshold) { if (c.imageRow - c.blackRow <= this.settings.active.aard.blackbar.gradientThreshold) {
// this is within our margin of error. Colums like this are auto-accepted // this is within our margin of error. Colums like this are auto-accepted
colsOut.push({ colsOut.push({
col: c.col, col: c.col,
@ -757,7 +757,7 @@ class EdgeDetect{
tmpVal += c.diffs[i]; tmpVal += c.diffs[i];
// if difference is negative, we aren't looking at a gradient // if difference is negative, we aren't looking at a gradient
if (c.diffs[i] < this.settings.active.arDetect.blackbar.gradientNegativeTreshold) { if (c.diffs[i] < this.settings.active.aard.blackbar.gradientNegativeTreshold) {
colsOut.push({ colsOut.push({
col: c.col, col: c.col,
black: c.blackRow black: c.blackRow
@ -766,7 +766,7 @@ class EdgeDetect{
} }
// if difference is too big, we assume we aren't looking at a gradient // if difference is too big, we assume we aren't looking at a gradient
if (c.diffs[i] > this.settings.active.arDetect.blackbar.maxGradient) { if (c.diffs[i] > this.settings.active.aard.blackbar.maxGradient) {
colsOut.push({ colsOut.push({
col: c.col, col: c.col,
black: c.blackRow black: c.blackRow
@ -789,7 +789,7 @@ class EdgeDetect{
stdev = Math.sqrt((squareSum / (c.diffIndex - 1))); stdev = Math.sqrt((squareSum / (c.diffIndex - 1)));
// if standard deviation is too big, we're not on a gradient (prolly) // if standard deviation is too big, we're not on a gradient (prolly)
if (stdev > this.settings.active.arDetect.blackbar.gradientMaxSD) { if (stdev > this.settings.active.aard.blackbar.gradientMaxSD) {
colsOut.push({ colsOut.push({
col: c.col, col: c.col,
black: c.blackRow black: c.blackRow
@ -821,7 +821,7 @@ class EdgeDetect{
// we have blackbar but we haven't found a point that goes over imageTreshold. // we have blackbar but we haven't found a point that goes over imageTreshold.
// how these cases are handled is determiend by what antiGradientMode we're using. // how these cases are handled is determiend by what antiGradientMode we're using.
// strict mode — treat as gradient. Lax mode — treat as not gradient // strict mode — treat as gradient. Lax mode — treat as not gradient
if (this.settings.active.arDetect.blackbar.antiGradientMode === AntiGradientMode.Lax) { if (this.settings.active.aard.blackbar.antiGradientMode === AntiGradientMode.Lax) {
colsOut.push({ colsOut.push({
col: c.col, col: c.col,
black: c.blackRow black: c.blackRow
@ -852,7 +852,7 @@ class EdgeDetect{
c.diffs = []; c.diffs = [];
} }
if (reverseSearchDirection) { if (reverseSearchDirection) {
if (this.settings.active.arDetect.blackbar.antiGradientMode === AntiGradientMode.Disabled) { if (this.settings.active.aard.blackbar.antiGradientMode === AntiGradientMode.Disabled) {
// todo: remove gradient detection code from this branch // todo: remove gradient detection code from this branch
for(var i = bottom - this.conf.canvasImageDataRowLength; i >= top; i-= this.conf.canvasImageDataRowLength){ for(var i = bottom - this.conf.canvasImageDataRowLength; i >= top; i-= this.conf.canvasImageDataRowLength){
for(let c = 0; c < colsIn.length; c++){ for(let c = 0; c < colsIn.length; c++){
@ -883,7 +883,7 @@ class EdgeDetect{
continue; continue;
} }
} else { } else {
if (colsIn[c].blackFound++ > this.settings.active.arDetect.blackbar.gradientSampleSize) { if (colsIn[c].blackFound++ > this.settings.active.aard.blackbar.gradientSampleSize) {
colsIn[c].imageFound = true; colsIn[c].imageFound = true;
continue; continue;
} }
@ -961,7 +961,7 @@ class EdgeDetect{
} else { } else {
// če smo dobili piksel, ki presega blackbar, preverimo do gradientSampleSize dodatnih pikslov. // če smo dobili piksel, ki presega blackbar, preverimo do gradientSampleSize dodatnih pikslov.
// ko dobimo piksel čez imageTreshold oz. gradientSampleSize, izračunamo ali gre za gradient. // ko dobimo piksel čez imageTreshold oz. gradientSampleSize, izračunamo ali gre za gradient.
if (colsIn[c].blackFound++ > this.settings.active.arDetect.blackbar.gradientSampleSize) { if (colsIn[c].blackFound++ > this.settings.active.aard.blackbar.gradientSampleSize) {
colsIn[c].imageFound = true; colsIn[c].imageFound = true;
continue; continue;
} }
@ -1024,7 +1024,7 @@ class EdgeDetect{
continue; continue;
} }
} else { } else {
if (colsIn[c].blackFound++ > this.settings.active.arDetect.blackbar.gradientSampleSize) { if (colsIn[c].blackFound++ > this.settings.active.aard.blackbar.gradientSampleSize) {
colsIn[c].imageFound = true; colsIn[c].imageFound = true;
continue; continue;
} }

6
src/ext/lib/comms/CommsServer.js
View File

@ -97,9 +97,9 @@ class CommsServer {
(message) => { (message) => {
this.settings.active.sites['@global'].autoar = "disabled"; this.settings.active.sites['@global'].autoar = "disabled";
if (message.reason){ if (message.reason){
this.settings.active.arDetect.disabledReason = message.reason; this.settings.active.aard.disabledReason = message.reason;
} else { } else {
this.settings.active.arDetect.disabledReason = 'User disabled'; this.settings.active.aard.disabledReason = 'User disabled';
} }
this.settings.save(); this.settings.save();
this.logger.log('info', 'comms', "[uw-bg] autoar set to disabled. evidenz:", this.settings.active); this.logger.log('info', 'comms', "[uw-bg] autoar set to disabled. evidenz:", this.settings.active);
@ -111,7 +111,7 @@ class CommsServer {
// set fairly liberal limit // set fairly liberal limit
var timeout = message.timeout < 4 ? 4 : message.timeout; var timeout = message.timeout < 4 ? 4 : message.timeout;
this.settings.active.arDetect.timer_playing = timeout; this.settings.active.aard.timer_playing = timeout;
this.settings.save(); this.settings.save();
} }
], ],