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

                                 double firstCircleX = circles[0];
                                 double secondCircleX = circles[1];
                                 double distance = Math.abs(firstCircleX - secondCircleX);
                                 LOGGER.info("Distance is " + distance);
-                                // Closed loop: no assumed ratio, every move re-measures.
+                                // Closed loop on the ring's own position; no assumed ratio.
-                                int moveByOffset = aim(driver, actionProvider, distance);
+                                int moveByOffset = aim(driver, actionProvider, circles);
                                 if (moveByOffset > 0) {
                                     actionProvider.release().perform();
                                     pressed = false;
                                     LOGGER.info("Move click performed (main {}px)", moveByOffset);
                                     try {
      *  measurable movement, and it must be too small to cross the hole. */
     private static final int SEED_NUDGE = 12;
     private static final int MAX_AIM_STEPS = 5;
     private static final int MAX_STEP = 140;
+    /** Centre of the draggable ring, in page CSS px, or null if it is not there. */
+    private Double pieceCentreX(WebDriver driver) {
+        try {
+            WebElement piece = driver.findElement(By.xpath("//*[starts-with(@id, 'dx_captcha_basic_sub-slider_')]"));
+            return piece.getLocation().getX() + (piece.getSize().getWidth() / 2.0);
+        } catch (Exception e) {
+            return null;
+        }
+    }
     /**
-     * Drag onto the hole without ever assuming a ratio.
+     * Drag the ring onto the hole, deriving px-per-px as we go.
+     *
+     * Why this does not re-run circle detection: it cannot. Hough needs to resolve TWO
+     * circles of similar radius, and as the ring closes on the hole they overlap and stop
+     * being two -- so the measurement dies exactly at convergence. Measured in production
+     * after r37437: 25 of 36 attempts lost the circles on the very step after the main
+     * move, and NOT ONE ever reported aligned. The old refine() hit the same wall and
+     * silently released. Any loop built on "distance between two detected circles" is
+     * blind at the only moment that matters.
+     *
+     * So the target is fixed ONCE, from the detection already done while the two are far
+     * apart and resolvable, and from then on we track the RING'S OWN ELEMENT, which stays
+     * readable however close it gets. Verified locally against the live widget: the ring's
+     * rect tracks the drag cleanly the whole way in (+10 mouse -> +11 ring, repeatably).
+     *
-     * The old path derived px-per-px ONCE from a single probe and then trusted it for
+     * The circle x's are already CSS px relative to the bg element -- the crop in
-     * the main move and the correction alike, so one noisy probe poisoned everything
+     * getMatCircles2 uses CSS coordinates and chrome runs with
-     * downstream. Here every move is also a measurement: after each one the ratio is
-     * re-derived from what that move actually achieved, so the estimate improves as the
+     * --force-device-scale-factor=1 -- so the only conversion needed is the bg offset.
-     * piece approaches instead of being fixed at its least informed point.
+     *
-     * It also gets to see overshoot, which a single pass cannot. The gap is |c1 - c2|,
+     * Every move is also a measurement: the ratio is re-derived from what that move
-     * so it cannot tell "not there yet" from "gone past" -- but if a move makes the gap
+     * actually achieved, and it is signed, so overshoot corrects itself instead of needing
-     * GROW, we crossed the hole, and the sign of the next step flips.
+     * to be detected.
+     *
-     * @return total slider px moved, or 0 if the circles could not be read at all.
+     * @return total slider px moved, or 0 if the ring could not be located at all.
      */
-    private int aim(WebDriver driver, Actions actionProvider, double gap) throws Exception {
+    private int aim(WebDriver driver, Actions actionProvider, double[] circleXs) throws Exception {
+        Double piece = pieceCentreX(driver);
+        if (piece == null) {
+            LOGGER.warn("Aim: no ring element to track");
+            return 0;
+        }
+        int bgX;
+        try {
+            bgX = driver.findElement(By.xpath("//*[starts-with(@id, 'dx_captcha_basic_bg_')]")).getLocation().getX();
+        } catch (Exception e) {
+            LOGGER.warn("Aim: bg element gone - " + e.getMessage());
+            return 0;
+        }
+        // Of the two detected circles the ring is whichever sits at the ring element; the
+        // other one is the hole we are aiming at.
+        double a = bgX + circleXs[0], b = bgX + circleXs[1];
+        double target = (Math.abs(a - piece) <= Math.abs(b - piece)) ? b : a;
+        LOGGER.info("Aim: ring at {} target at {} ({}px to close)",
+                Math.round(piece), Math.round(target), Math.round(target - piece));
-        double ratio = 0;               // slider px per gap px, derived from real moves
+        double ratio = 0;               // ring px per mouse px, signed, derived from real moves
         int total = 0;
         int step = SEED_NUDGE;
         for (int i = 0; i < MAX_AIM_STEPS; i++) {
             actionProvider.moveByOffset(step, 0).perform();
             total += step;
-            double[] c = getMatCircles2(driver, "/tmp/" + Thread.currentThread().getName() + "-aim" + i + ".png");
+            Double now = pieceCentreX(driver);
-            if (c == null) {
+            if (now == null) {
-                LOGGER.warn("Aim step {}: lost the circles after {}px", i, total);
+                LOGGER.warn("Aim step {}: lost the ring after {}px", i, total);
                 return total;
+            }
-            double now = Math.abs(c[0] - c[1]);
-            double closed = gap - now;
+            double moved = now - piece;
-            if (closed != 0) {
+            if (Math.abs(moved) > 0.5) {
-                // What this move actually bought us, in slider px per gap px.
-                double observed = Math.abs(step) / Math.abs(closed);
+                double observed = moved / step;
-                // Blend once an estimate exists, so a single bad frame cannot swing it.
-                ratio = (ratio <= 0) ? observed : (ratio + observed) / 2;
+                ratio = (ratio == 0) ? observed : (ratio + observed) / 2;
+            }
+            double remaining = target - now;
-            LOGGER.info("Aim step {}: moved {}px, gap {} -> {}, ratio now {}",
+            LOGGER.info("Aim step {}: mouse {}px -> ring moved {}px, {}px left, ratio {}",
-                    i, step, gap, now, String.format("%.2f", ratio));
+                    i, step, Math.round(moved), Math.round(remaining), String.format("%.2f", ratio));
-            if (now <= ALIGNED_PX) {
+            if (Math.abs(remaining) <= ALIGNED_PX) {
-                LOGGER.info("Aim: aligned within {}px after {} step(s), {}px total", ALIGNED_PX, i + 1, total);
+                LOGGER.info("Aim: aligned to {}px after {} step(s), {}px of slider",
+                        Math.round(remaining), i + 1, total);
                 return total;
+            }
+            piece = now;
-            if (ratio <= 0) {                       // nothing measurable yet, probe again
+            if (ratio == 0) {           // nothing measurable yet, probe again
-                gap = now;
                 step = SEED_NUDGE;
                 continue;
+            }
-            int next = (int) Math.round(now * ratio);
+            int next = (int) Math.round(remaining / ratio);
-            if (next == 0) next = 1;
+            if (next == 0) next = (remaining > 0 ? 1 : -1);
             if (next > MAX_STEP) next = MAX_STEP;
-            // Gap grew => we are past the hole; go back instead of further away.
-            step = (closed < 0) ? -next : next;
+            if (next < -MAX_STEP) next = -MAX_STEP;
-            gap = now;
+            step = next;
+        }
-        LOGGER.info("Aim: {} steps used, {}px total", MAX_AIM_STEPS, total);
+        LOGGER.info("Aim: {} steps used, {}px of slider, still short", MAX_AIM_STEPS, total);
         return total;
+    }
     private Mat getMatCircles(WebDriver driver, String fileName) throws Exception {
         File screenshot = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
         BufferedImage fullImg = ImageIO.read(screenshot);

Subversion Repositories SmartDukaan

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