Ubuntu
230 lines
9.8 KiB
JavaScript
230 lines
9.8 KiB
JavaScript
// verify_all.js - verify all images and show distRatio/areaRatio details
|
|
const { createCanvas, loadImage } = require('canvas');
|
|
const { Img, PST_NAMES } = require('./paper-recognizer.js');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
|
|
const GP = {
|
|
MIN_CONTOUR_AREA: 100,
|
|
MIN_RECTANGULARITY: 0.5,
|
|
BIG_LOCATOR_RATIO_SHORT: 2.0,
|
|
BIG_LOCATOR_RATIO_LONG: 3.0,
|
|
SMALL_LOCATOR_RATIO: 1.667,
|
|
MIN_BIG_LOCATOR_AREA: 200,
|
|
MAX_BIG_LOCATOR_AREA: 8000,
|
|
MIN_SMALL_LOCATOR_AREA: 50,
|
|
MAX_SMALL_LOCATOR_AREA: 2000,
|
|
AREA_RATIO_SHORT: 3.33,
|
|
AREA_RATIO_LONG: 5.0,
|
|
};
|
|
|
|
function matchConfig(distRatio, areaRatio, bigType) {
|
|
const Min_AR_S = 2.6, Max_AR_S = 4.0, Min_AR_L = 4.0, Max_AR_L = 6.0;
|
|
if (areaRatio < Min_AR_S || areaRatio > Max_AR_L) return -1;
|
|
const isSmall = areaRatio <= Max_AR_S;
|
|
if (isSmall) {
|
|
if (distRatio >= 18.5 && distRatio <= 26.5) return 3; // 14_S
|
|
if (distRatio >= 14.1 && distRatio < 18.5) return 5; // 11_S
|
|
if (distRatio >= 11.6 && distRatio < 14.1) return 7; // 8_S
|
|
} else {
|
|
if (distRatio >= 18.5 && distRatio <= 26.98) return 4; // 14_L
|
|
if (distRatio >= 14.5 && distRatio < 18.5) return 6; // 11_L
|
|
if (distRatio >= 12.0 && distRatio < 14.5) return 8; // 8_L
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Relaxed area limits for high-res images
|
|
function getAreaLimits(w, h) {
|
|
const scale = Math.min(w, h) / 100; // scale relative to typical strip width ~100px
|
|
return {
|
|
minBig: GP.MIN_BIG_LOCATOR_AREA,
|
|
maxBig: Math.max(GP.MAX_BIG_LOCATOR_AREA, 200 * scale * scale),
|
|
minSmall: GP.MIN_SMALL_LOCATOR_AREA,
|
|
maxSmall: Math.max(GP.MAX_SMALL_LOCATOR_AREA, 50 * scale * scale)
|
|
};
|
|
}
|
|
|
|
// Wider ratio tolerances for narrow strips
|
|
function getRatioTols(w, h) {
|
|
const minDim = Math.min(w, h);
|
|
if (minDim < 80) return { tolBig: 0.50, tolSmall: 0.70 };
|
|
return { tolBig: 0.35, tolSmall: 0.50 };
|
|
}
|
|
|
|
function trace(fpath, fname, useRelaxed = false) {
|
|
return loadImage(fpath).then(img => {
|
|
const c = createCanvas(img.width, img.height);
|
|
const ctx = c.getContext('2d');
|
|
ctx.drawImage(img, 0, 0);
|
|
const id = ctx.getImageData(0, 0, img.width, img.height);
|
|
const w = img.width, h = img.height;
|
|
const raw = new Uint8Array(id.data.buffer);
|
|
const bgr = new Uint8Array(w * h * 3);
|
|
for (let i = 0; i < w * h; i++) {
|
|
bgr[i * 3] = raw[i * 4 + 2];
|
|
bgr[i * 3 + 1] = raw[i * 4 + 1];
|
|
bgr[i * 3 + 2] = raw[i * 4];
|
|
}
|
|
|
|
const { tolBig, tolSmall } = getRatioTols(w, h);
|
|
const limits = getAreaLimits(w, h);
|
|
|
|
// HSV masks
|
|
const hsv = Img.bgrImageToHsv(bgr, w, h);
|
|
|
|
// Tighter blue thresholds to reduce false positives
|
|
const sMinB = useRelaxed ? 40 : 30, vMinB = useRelaxed ? 40 : 20;
|
|
const blueMask = Img.hsvInRange(hsv, w, h, 180, 260, sMinB, 255, vMinB, 220);
|
|
const greenMask = Img.hsvInRange(hsv, w, h, 80, 170, 30, 255, 30, 220);
|
|
const redMask1 = Img.hsvInRange(hsv, w, h, 0, 15, 30, 255, 30, 220);
|
|
const redMask2 = Img.hsvInRange(hsv, w, h, 340, 360, 30, 255, 30, 220);
|
|
const redMask = new Uint8Array(w * h);
|
|
for (let i = 0; i < w * h; i++) redMask[i] = Math.max(redMask1[i], redMask2[i]);
|
|
|
|
const colorMask = new Uint8Array(w * h);
|
|
for (let i = 0; i < w * h; i++) {
|
|
colorMask[i] = Math.max(blueMask[i], greenMask[i], redMask[i]);
|
|
}
|
|
|
|
// Smaller morph close for narrow strips
|
|
const morphKernel = Math.min(w, h) < 80 ? 3 : 5;
|
|
const closed = Img.morphClose(colorMask, w, h, morphKernel);
|
|
const contours = Img.findContours(closed, w, h);
|
|
|
|
const candidates = [];
|
|
for (const ct of contours) {
|
|
const area = Img.contourArea(ct);
|
|
if (area < GP.MIN_CONTOUR_AREA) continue;
|
|
const brect = Img.boundingRect(ct);
|
|
const bbArea = brect.w * brect.h;
|
|
if (area / bbArea < GP.MIN_RECTANGULARITY) continue;
|
|
const rotatedRect = Img.minAreaRect(ct);
|
|
const rectArea = rotatedRect.size.w * rotatedRect.size.h;
|
|
if (area / rectArea < GP.MIN_RECTANGULARITY) continue;
|
|
const aspectRatio = Math.max(rotatedRect.size.w, rotatedRect.size.h) /
|
|
Math.max(Math.min(rotatedRect.size.w, rotatedRect.size.h), 1);
|
|
if (aspectRatio >= 0.9 && aspectRatio <= 1.1) continue;
|
|
if (aspectRatio > 4.0) continue;
|
|
const distToBigShort = Math.abs(aspectRatio - GP.BIG_LOCATOR_RATIO_SHORT);
|
|
const distToBigLong = Math.abs(aspectRatio - GP.BIG_LOCATOR_RATIO_LONG);
|
|
const distToSmall = Math.abs(aspectRatio - GP.SMALL_LOCATOR_RATIO);
|
|
const nearestBigDist = Math.min(distToBigShort, distToBigLong);
|
|
const isBig = nearestBigDist < tolBig && nearestBigDist < distToSmall;
|
|
const isSmall = distToSmall < tolSmall && distToSmall <= nearestBigDist;
|
|
if (!isBig && !isSmall) continue;
|
|
const center = rotatedRect.center;
|
|
const cx = Math.round(center.x), cy = Math.round(center.y);
|
|
const [b_, g_, r_] = Img.getBgr(bgr, w, h, cx, cy);
|
|
const [hh, ss, vv] = Img.bgrToHsv(b_, g_, r_);
|
|
let locColor = 0;
|
|
if (hh >= 180 && hh <= 260) locColor = 3;
|
|
else if (hh >= 80 && hh <= 170) locColor = 2;
|
|
else if (hh <= 15 || hh >= 340) locColor = 1;
|
|
candidates.push({
|
|
center: {x: center.x, y: center.y}, area,
|
|
width: rotatedRect.size.w, height: rotatedRect.size.h,
|
|
color: locColor, isBig, isSmall, aspectRatio,
|
|
contour: ct
|
|
});
|
|
}
|
|
|
|
const bigCands = candidates.filter(c => c.isBig && c.area >= limits.minBig && c.area <= limits.maxBig);
|
|
const smallCands = candidates.filter(c => c.isSmall && c.area >= limits.minSmall && c.area <= limits.maxSmall);
|
|
|
|
// Fallback: use largest-small as big or smallest-big as small
|
|
if (bigCands.length === 0 || smallCands.length === 0) {
|
|
// Strategy 1: two bigs → smallest as small
|
|
if (bigCands.length >= 2 && smallCands.length === 0) {
|
|
const sortedBigs = [...bigCands].sort((a, b) => a.area - b.area);
|
|
for (const big of sortedBigs) {
|
|
for (const small of sortedBigs) {
|
|
if (big === small) continue;
|
|
if (big.area <= small.area) continue;
|
|
const ar = big.area / Math.max(small.area, 1);
|
|
if (ar < 1.5 || ar > 8.0) continue;
|
|
smallCands.push(small);
|
|
}
|
|
}
|
|
}
|
|
// Strategy 2: two smalls → largest as big
|
|
if (bigCands.length === 0 && smallCands.length >= 2) {
|
|
const sortedSmalls = [...smallCands].sort((a, b) => b.area - a.area);
|
|
// largest small becomes a pseudo-big
|
|
if (sortedSmalls[0].area > sortedSmalls[1].area * 1.5) {
|
|
bigCands.push(sortedSmalls[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bigCands.length === 0 || smallCands.length === 0) {
|
|
console.log(fname.padEnd(20) + ' | -3 NO LOC (b=' + bigCands.length + ' s=' + smallCands.length + ' cand=' + candidates.length + ')');
|
|
return;
|
|
}
|
|
|
|
// Pairing
|
|
let bestPair = null, bestScore = Infinity;
|
|
for (const big of bigCands) {
|
|
for (const small of smallCands) {
|
|
if (big === small) continue;
|
|
const areaRatio = big.area / Math.max(small.area, 1);
|
|
// Allow inverted area ratio (big could be smaller if locators are reversed)
|
|
const invAreaRatio = small.area / Math.max(big.area, 1);
|
|
const yDiff = Math.abs(big.center.y - small.center.y);
|
|
const colorMatch = big.color === small.color && big.color !== 0;
|
|
// Score: prefer color match, prefer areaRatio ~4.0 OR invAreaRatio ~4.0
|
|
const arScore = Math.min(Math.abs(areaRatio - 4.0), Math.abs(invAreaRatio - 4.0));
|
|
const score = arScore + yDiff * 0.1 + (colorMatch ? 0 : 5);
|
|
// Cross-color pairs need to be far apart and on same y
|
|
if (!colorMatch)
|
|
console.log(' X-COLOR: b=' + ['?','R','G','B'][big.color] + ' s=' + ['?','R','G','B'][small.color] + ' ar=' + areaRatio.toFixed(2) + ' dist=' + Math.abs(big.center.x - small.center.x).toFixed(0));
|
|
if (score < bestScore) {
|
|
bestScore = score;
|
|
bestPair = { big, small, areaRatio, invAreaRatio, colorMatch };
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bestPair) {
|
|
console.log(fname.padEnd(20) + ' | -4 NO PAIR');
|
|
return;
|
|
}
|
|
|
|
const { big: bigLoc_, small: smallLoc_, areaRatio: areaRatio2, invAreaRatio, colorMatch } = bestPair;
|
|
|
|
// Check if area ratio is inverted - use whichever gives better areaRatio
|
|
let useAreaRatio = areaRatio2;
|
|
if (invAreaRatio > areaRatio2 && invAreaRatio >= 2.6 && invAreaRatio <= 6.0) {
|
|
useAreaRatio = invAreaRatio;
|
|
}
|
|
|
|
const smallOnLeft = smallLoc_.center.x < bigLoc_.center.x;
|
|
const loc1 = smallOnLeft ? smallLoc_ : bigLoc_;
|
|
const loc2 = smallOnLeft ? bigLoc_ : smallLoc_;
|
|
|
|
const dx = loc1.center.x - loc2.center.x;
|
|
const dy = loc1.center.y - loc2.center.y;
|
|
const dist = Math.sqrt(dx * dx + dy * dy);
|
|
const loc1Half = Math.max(loc1.width, loc1.height) / 2;
|
|
const loc2Half = Math.max(loc2.width, loc2.height) / 2;
|
|
const edgeDist = dist - loc1Half - loc2Half;
|
|
const refH = Math.max(loc1.height, loc2.height);
|
|
const distRatio = edgeDist / Math.max(refH, 1);
|
|
const bigType = useAreaRatio < (GP.AREA_RATIO_SHORT + GP.AREA_RATIO_LONG) / 2 ? 'SHORT' : 'LONG';
|
|
const paperType = matchConfig(distRatio, useAreaRatio, bigType);
|
|
|
|
const pName = paperType > 0 ? PST_NAMES[paperType] : 'UNK';
|
|
console.log(fname.padEnd(20) + ' | ' + pName.padEnd(6) + ' | dr=' + distRatio.toFixed(2) + ' ar=' + useAreaRatio.toFixed(2) + ' ' + bigType + ' | c=' + ['?','R','G','B'][bigLoc_.color] + (colorMatch?'':'✗') + ' | inv=' + (areaRatio2 < 1 ? 'YES' : 'no'));
|
|
});
|
|
}
|
|
|
|
// Test with relaxed parameters
|
|
(async () => {
|
|
const dir = '/home/ubuntu/nanocode/web-opencv/cpp/images/';
|
|
const files = fs.readdirSync(dir).filter(f => /\.(jpg|jpeg|png|JPG|PNG)$/i.test(f)).sort();
|
|
console.log('=== With RELAXED parameters ===');
|
|
for (const f of files) {
|
|
try { await trace(path.join(dir, f), f, true); } catch (e) { console.log(f + ' ERROR: ' + e.message); }
|
|
}
|
|
})();
|