import time import pyautogui import keyboard def calibrate_monitor(): """ Simple interactive calibration using the mouse and keyboard. 1) Move to top-left of target area and press 'c' 2) Move to bottom-right of target area and press 'c' Returns monitor dict compatible with mss. """ print("Calibration step:") print("1. Move mouse to the TOP-LEFT corner of the bar area, then press 'c'.") keyboard.wait("c") top_left = pyautogui.position() print(f"Top-left set at: {top_left}") time.sleep(0.5) print("2. Move mouse to the BOTTOM-RIGHT corner of the bar area, then press 'c'.") keyboard.wait("c") bottom_right = pyautogui.position() print(f"Bottom-right set at: {bottom_right}") monitor = { "top": top_left.y, "left": top_left.x, "width": max(1, bottom_right.x - top_left.x), "height": max(1, bottom_right.y - top_left.y), } print(f"Monitor calibrated: {monitor}") return monitor import cv2 import numpy as np class Detector: """ Fast color detector that works on a downscaled ROI for speed. Returns x-coordinates (in scaled image space) for red and green detections. """ def __init__( self, scale: float = 0.6, red_tol: int = 12, kernel_size: int = 3, ): self.scale = float(scale) self.red_tol = red_tol self.kernel = np.ones((kernel_size, kernel_size), np.uint8) # HSV color ranges for red (two ranges) and green self.red_lower1 = np.array([0, 120, 70]) self.red_upper1 = np.array([10, 255, 255]) self.red_lower2 = np.array([170, 120, 70]) self.red_upper2 = np.array([180, 255, 255]) self.green_lower = np.array([40, 70, 70]) self.green_upper = np.array([80, 255, 255]) def _to_bgr(self, frame): # mss gives BGRA; drop alpha if frame.shape[2] == 4: return cv2.cvtColor(frame, cv2.COLOR_BGRA2BGR) return frame def process(self, frame): """ Process the captured frame and return (red_x, green_x) in scaled coords or (None, None). """ bgr = self._to_bgr(frame) # Downscale for faster processing if self.scale != 1.0: small = cv2.resize( bgr, (0, 0), fx=self.scale, fy=self.scale, interpolation=cv2.INTER_LINEAR, ) else: small = bgr hsv = cv2.cvtColor(small, cv2.COLOR_BGR2HSV) # Red mask (combine two ranges) mask_r1 = cv2.inRange(hsv, self.red_lower1, self.red_upper1) mask_r2 = cv2.inRange(hsv, self.red_lower2, self.red_upper2) mask_red = cv2.bitwise_or(mask_r1, mask_r2) # Green mask mask_green = cv2.inRange(hsv, self.green_lower, self.green_upper) # Clean up and enlarge regions a bit to avoid missing fast thin lines mask_red = cv2.morphologyEx(mask_red, cv2.MORPH_CLOSE, self.kernel, iterations=1) mask_red = cv2.dilate(mask_red, self.kernel, iterations=2) mask_green = cv2.morphologyEx(mask_green, cv2.MORPH_OPEN, self.kernel, iterations=1) mask_green = cv2.dilate(mask_green, self.kernel, iterations=1) red_x = self._find_red_center_x(mask_red) green_x = self._find_green_avg_x(mask_green) return red_x, green_x def _find_red_center_x(self, mask_red): contours, _ = cv2.findContours(mask_red, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) if not contours: return None # Choose the largest contour and compute its centroid largest = max(contours, key=cv2.contourArea) area = cv2.contourArea(largest) if area < 3: # ignore tiny noise return None M = cv2.moments(largest) if M["m00"] == 0: return None cx = int(M["m10"] / M["m00"]) return cx def _find_green_avg_x(self, mask_green): pts = cv2.findNonZero(mask_green) if pts is None: return None xs = pts[:, 0, 0] if xs.size == 0: return None return int(np.mean(xs)) import time import sys import pyautogui import keyboard import numpy as np from mss import mss from calibrate import calibrate_monitor from detector import Detector def main(): print("Press 's' to calibrate and start...") keyboard.wait("s") monitor = calibrate_monitor() print("Calibration complete. Script running! Press ESC to stop.") # Tunable parameters SCALE = 0.6 # downscale factor for processing (lower = faster, less precise) CLICK_TOLERANCE_PIXELS = 14 # in scaled-image pixels MIN_CLICK_INTERVAL = 0.08 # seconds between allowed clicks (debounce) detector = Detector(scale=SCALE) sct = mss() prev_red = None last_click_time = 0.0 # Precompute vertical click position (middle of monitor) click_y = monitor["top"] + monitor["height"] // 2 while True: # Grab frame frame = np.array(sct.grab(monitor)) red_x_s, green_x_s = detector.process(frame) now = time.monotonic() # Map scaled coords back to absolute screen coords def to_screen_x(scaled_x): if scaled_x is None: return None return int(scaled_x / detector.scale) + monitor["left"] red_x_screen = to_screen_x(red_x_s) green_x_screen = to_screen_x(green_x_s) clicked = False if red_x_s is not None and green_x_s is not None: # 1) direct overlap within tolerance if abs(red_x_s - green_x_s) <= CLICK_TOLERANCE_PIXELS: if now - last_click_time >= MIN_CLICK_INTERVAL: pyautogui.click(x=green_x_screen, y=click_y) last_click_time = now clicked = True # 2) crossing between frames: red was left and now right of green (or vice versa) elif prev_red is not None and ((prev_red - green_x_s) * (red_x_s - green_x_s) <= 0): if now - last_click_time >= MIN_CLICK_INTERVAL: pyautogui.click(x=green_x_screen, y=click_y) last_click_time = now clicked = True # Update previous red (scaled coords) prev_red = red_x_s if clicked: # tiny sleep to reduce chance of multiple clicks for same pass time.sleep(0.02) # Stop condition if keyboard.is_pressed("esc"): print("Stopped.") break if __name__ == "__main__": main()