WebSVN – SmartDukaan – Diff – //trunk/profitmandi-cron/src/main/java/com/smartdukaan/cron/scheduled/CheckOppoWarrantyTask.java

 import nu.pattern.OpenCV;
 import org.apache.commons.io.FileUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.opencv.core.Core;
 import org.opencv.core.Mat;
+import org.opencv.core.Scalar;
 import org.opencv.core.Size;
 import org.opencv.imgcodecs.Imgcodecs;
 import org.opencv.imgproc.Imgproc;
 import org.json.JSONObject;
 import org.openqa.selenium.*;
                                         + " - reloading. Cause: " + e.getMessage());
                                 driver.get("https://support.oppo.com/in/warranty-check/");
                                 installResponseCapture(driver);
                                 break;
+                            }
+                            Double ringPageX = pieceCentreX(driver);
+                            double[] circles = null;
+                            if (ringPageX == null) {
+                                LOGGER.warn("No ring element to anchor detection on");
+                            } else {
+                                int bgLeft = driver.findElement(
+                                        By.xpath("//*[starts-with(@id, 'dx_captcha_basic_bg_')]")).getLocation().getX();
-                            double[] circles = getMatCircles2(driver, fileName);
+                                circles = getMatCircles2(driver, fileName, ringPageX - bgLeft);
+                            }
                             if (circles != null) {
                                 double firstCircleX = circles[0];
                                 double secondCircleX = circles[1];
                                 double distance = Math.abs(firstCircleX - secondCircleX);
                                 LOGGER.info("Distance is " + distance);
         Mat circles = new Mat();
         Imgproc.HoughCircles(medianBlur, circles, Imgproc.HOUGH_GRADIENT, 1, 15, 50, 20, 17, 25);
         return circles;
+    }
+    /** Anything within this many px of the ring's known centre IS the ring, not the hole. */
+    private static final double RING_EXCLUSION_PX = 30;
+    /** A real hole sits at least this far below the frame's mean luminance. */
+    private static final double MIN_HOLE_DARKNESS = 15;
+    /** Mean luminance inside a detected circle, clamped to the image. */
+    private double meanInside(Mat gray, double[] circle) {
+        int r = (int) Math.max(3, circle[2] * 0.6);            // inner core, avoids the rim
+        int x0 = (int) Math.max(0, circle[0] - r), y0 = (int) Math.max(0, circle[1] - r);
+        int x1 = (int) Math.min(gray.cols(), circle[0] + r), y1 = (int) Math.min(gray.rows(), circle[1] + r);
+        if (x1 - x0 < 2 || y1 - y0 < 2) return Double.MAX_VALUE;
+        return Core.mean(gray.submat(y0, y1, x0, x1)).val[0];
+    }
+    /**
+     * Locate the hole. The RING is not detected -- its exact position comes from the DOM
+     * (dx_captcha_basic_sub-slider_), so hough only has to find one thing instead of two.
+     *
+     * The old version demanded TWO circles whose radii matched within 3px and returned
+     * null otherwise, so a puzzle where the hole was found perfectly well still failed if
+     * the ring was missed or the radii differed by 4px. It was also re-detecting something
+     * already known exactly.
+     *
+     * param1 is the Canny HIGH threshold: edges weaker than it are discarded before circle
+     * finding begins. At 100 a low-contrast hole produces no edge at all. Measured on four
+     * live puzzles, hole-vs-background contrast was 98, 103, 28 and 117 -- the 28 (a pale
+     * lilac background) cannot survive 100, which is the mechanism behind "60% of attempts
+     * never find the circles". Dropped to 50.
+     *
+     * @param ringRelX ring centre in px relative to the bg element's left edge
+     * @return {ringRelX, holeRelX} -- shape kept so callers are unchanged -- or null
+     */
-    private double[] getMatCircles2(WebDriver driver, String fileName) throws Exception {
+    private double[] getMatCircles2(WebDriver driver, String fileName, double ringRelX) throws Exception {
         File screenshot = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
         BufferedImage fullImg = ImageIO.read(screenshot);
         // Get the location of element on the page
         WebElement imageElement = driver.findElement(By.xpath("//*[starts-with(@id, 'dx_captcha_basic_bg_')]"));
         Imgproc.GaussianBlur(gray, gray, new Size(9, 9), 2, 2);
         Mat circles = new Mat();
         Imgproc.HoughCircles(gray, circles, Imgproc.HOUGH_GRADIENT, 1.0,
 , // min distance between centers
 , 20, // param1 (Canny high threshold), param2 (accumulator threshold)
-, 50); // minRadius, maxRadius (adjust as needed)
+, 50); // minRadius, maxRadius
-        if (circles.cols() < 2) {
+        if (circles.cols() < 1) {
             new File(fileName).delete();
             return null;
+        }
+        // Dropping param1 to 50 lets weak edges through, which also lets textured
+        // backgrounds (the sand images especially) produce spurious circles. Without the
+        // old two-circle pairing there is nothing else to reject them, so verify the
+        // candidate is actually a HOLE: it must be materially darker than the picture as
+        // a whole. Measured on live puzzles the hole runs 28-117 luminance below the
+        // median, so 15 rejects noise while keeping even the faintest real hole.
+        Scalar frameMean = Core.mean(gray);
+        // OpenCV returns circles strongest-accumulator first, so take the first candidate
+        // that is not the ring and does look like a hole.
         for (int i = 0; i < circles.cols(); i++) {
-            double[] c1 = circles.get(0, i);
+            double[] c = circles.get(0, i);
-            for (int j = i + 1; j < circles.cols(); j++) {
+            if (Math.abs(c[0] - ringRelX) < RING_EXCLUSION_PX) continue; // that is the ring
-                double[] c2 = circles.get(0, j);
+            double darkness = frameMean.val[0] - meanInside(gray, c);
-                if (Math.abs(c1[2] - c2[2]) < 3) { // check similar radius
-                    new File(fileName).delete();
+            if (darkness < MIN_HOLE_DARKNESS) {
-                    return new double[] {
+                LOGGER.info("Rejecting circle at {}px: only {} darker than the frame",
-                            c1[0], c2[0] // x-coordinates
+                        Math.round(c[0]), Math.round(darkness));
-                    };
+                continue;
-                }
+            }
+            new File(fileName).delete();
+            return new double[] { ringRelX, c[0] };
+        }
+        LOGGER.info("Detected {} circle(s) but all sat on the ring at {}px", circles.cols(), Math.round(ringRelX));
         new File(fileName).delete();
         return null;
+    }

Subversion Repositories SmartDukaan

(root)//trunk/profitmandi-cron/src/main/java/com/smartdukaan/cron/scheduled/CheckOppoWarrantyTask.java – Rev 37446 → 37450