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);
-                                LOGGER.info("Starting Checkdistance method");
+                                double[] cal = calibrate(driver, actionProvider, distance);
-                                int moveByOffset = checkDistance(driver, wait10Sec, actionProvider, distance, slideButton);
+                                int moveByOffset = cal == null ? 0 : (int) cal[0];
                                 if (moveByOffset > 0) {
-                                    LOGGER.info("Margin Offset - " + slideButton.getCssValue("margin-left"));
+                                    // Move, then measure again and close the remainder BEFORE
-                                    LOGGER.info("Ending Checkdistance method " + moveByOffset);
+                                    // releasing. Releasing on the first computed offset committed
+                                    // the whole calibration error to the final position.
-                                    actionProvider.moveByOffset(moveByOffset, 0).release().perform();
+                                    actionProvider.moveByOffset(moveByOffset, 0).perform();
+                                    refine(driver, actionProvider, cal[1]);
+                                    actionProvider.release().perform();
-                                    LOGGER.info("Move click performed");
+                                    LOGGER.info("Move click performed (main {}px)", moveByOffset);
                                     try {
                                         try {
                                             wait5Sec.until(ExpectedConditions.visibilityOfElementLocated(By.className("dx_captcha_basic_bar-inform")));
                                             LOGGER.warn("Failed = " + counter);
                                         } catch (Exception notFailedException) {
             LOGGER.warn("Could not read regDate from the Oppo response: " + e.getMessage());
             return null;
+        }
+    }
+    /**
+     * Slider pixels to nudge when working out how far the puzzle piece travels per
+     * slider pixel.
+     *
+     * This was 15, which was the reason the captcha only solved about 9% of the time.
+     * The piece moves roughly 1.7 px per slider px, so a 15 px nudge closed the gap by
+     * only ~25 px -- and Hough circle detection is worth about +/-2-3 px per circle, so
+     * the ratio was being derived from a measurement with ~20% noise in it. That error
+     * then multiplied across the whole remaining travel: on a 150 px gap it landed ~30 px
+     * out, and the target hole is only ~30 px across, so it missed entirely.
+     *
+     * A 60 px nudge closes ~100 px, so the same detection noise is ~5% instead of ~20%.
+     */
+    private static final int CALIBRATION_NUDGE = 60;
+    /** Stop correcting once the piece is within this many px of the hole. */
+    private static final double ALIGNED_PX = 2.0;
+    /**
+     * @return {sliderPxToMove, sliderPxPerCirclePx}, or null when the circles could not
+     *         be read. Returned rather than stored on a field: this is a singleton and
+     *         the Oppo secondary and tertiary jobs run it concurrently.
+     */
-    private int checkDistance(WebDriver driver, WebDriverWait wait3Sec, Actions actionProvider, double distance, WebElement slideButton) throws Exception {
+    private double[] calibrate(WebDriver driver, Actions actionProvider, double distance) throws Exception {
+        actionProvider.moveByOffset(CALIBRATION_NUDGE, 0).perform();
-        //actionProvider.moveToElement(slideButton).clickAndHold().moveByOffset(1, 0).perform();
-        actionProvider.moveByOffset(15, 0).perform();
         String fileName2 = "/tmp/" + Thread.currentThread().getName() + "-moved.png";
         double[] movedCircles = getMatCircles2(driver, fileName2);
-        if (movedCircles == null) return 0;
+        if (movedCircles == null) return null;
-        double movedFirst = movedCircles[0];
+        double movedDistance = Math.abs(movedCircles[0] - movedCircles[1]);
-        double movedSecond = movedCircles[1];
+        double closed = distance - movedDistance;
+        LOGGER.info("Calibration: gap {} -> {} after {}px, closed {}",
-        //System.out.println("Test Offset Move " + testMove);
+                distance, movedDistance, CALIBRATION_NUDGE, closed);
-        LOGGER.info("Found Moved " + movedFirst + " ," + movedSecond);
+        // A non-positive value means the piece did not move, or moved away from the
+        // hole -- either way the ratio is meaningless and guessing would waste the try.
+        if (closed <= 0) return null;
+        double sliderPerCircle = CALIBRATION_NUDGE / closed;
-        double movedDistance = Math.abs(movedFirst - movedSecond);
+        int moveBy = (int) Math.round(movedDistance * sliderPerCircle);
-        double moved = distance - movedDistance;
+        return new double[]{moveBy, sliderPerCircle};
+    }
+    /**
+     * Measure again after the main move and close whatever is left. The old code
+     * committed its single computed offset blind, so any calibration error went
-		/*LOGGER.info("Original distance " + distance);
+     * straight into the final position with nothing to catch it.
+     */
+    private int refine(WebDriver driver, Actions actionProvider, double sliderPerCircle) throws Exception {
+        String fileName = "/tmp/" + Thread.currentThread().getName() + "-refine.png";
-		LOGGER.info("Moved Distance " + movedDistance);
+        double[] circles = getMatCircles2(driver, fileName);
-		LOGGER.info("Moved " + moved);*/
+        if (circles == null) return 0;
+        double remaining = Math.abs(circles[0] - circles[1]);
-        if (moved == 0) return 0;
+        if (remaining <= ALIGNED_PX) return 0;
-        int moveBy = (int) ((movedDistance) * (15 / moved));
+        int correction = (int) Math.round(remaining * sliderPerCircle);
-        //int moveBy = (int) distance - 21;
+        if (correction == 0) return 0;
+        LOGGER.info("Refine: {}px of gap left -> nudging {}px", remaining, correction);
+        actionProvider.moveByOffset(correction, 0).perform();
-        return moveBy;
+        return correction;
+    }
     private Mat getMatCircles(WebDriver driver, String fileName) throws Exception {
         File screenshot = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);

Subversion Repositories SmartDukaan

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