| """openTARS 2.9.2: mouse preciso. |
| |
| Lógica pura (sem X, sem pyautogui) dos cliques e arrastos, testável sozinha: |
| |
| - ancora(): "top-left", "canto superior esquerdo", "oben links"... -> ponto da tela |
| - caminho(): os pontos de um arrasto "de gente": sai devagar do lugar |
| (apps como o Chrome/Brave só entendem que é arrasto depois |
| de uns pixels com o botão apertado), acelera e freia no fim |
| - recorte_em_volta(): a região em volta de um ponto |
| - mudanca(): quanto a tela mudou entre duas capturas (o clique pegou?) |
| """ |
|
|
| import re |
| import unicodedata |
|
|
|
|
| |
| |
| |
| MARGEM_ANCORA = 48 |
|
|
| _VERTICAL = { |
| "topo": ("top", "upper", "topo", "cima", "alto", "superior", "arriba", "haut", "oben", "obere", "oberen"), |
| "base": ("bottom", "lower", "baixo", "inferior", "embaixo", "abajo", "bas", "unten", "untere", "unteren"), |
| } |
| _HORIZONTAL = { |
| "esquerda": ("left", "esquerda", "esquerdo", "izquierda", "izquierdo", "gauche", "links", "linke", "linken"), |
| "direita": ("right", "direita", "direito", "derecha", "derecho", "droite", "rechts", "rechte", "rechten"), |
| } |
| _CENTRO = ("center", "centre", "middle", "centro", "meio", "medio", "milieu", "mitte") |
|
|
|
|
| def _normalizar(texto): |
| texto = unicodedata.normalize("NFKD", str(texto or "").lower()) |
| texto = "".join(c for c in texto if not unicodedata.combining(c)) |
| return re.findall(r"[a-z]+", texto) |
|
|
|
|
| def ancora(nome, largura, altura, margem=MARGEM_ANCORA): |
| """(x, y) do lugar da tela chamado 'nome', ou None se não for um lugar. |
| 'top-left' -> perto do canto superior esquerdo; 'left' -> meio da |
| borda esquerda; 'center' -> centro.""" |
| palavras = set(_normalizar(nome)) |
| if not palavras: |
| return None |
| vertical = next((k for k, v in _VERTICAL.items() if palavras & set(v)), None) |
| horizontal = next((k for k, v in _HORIZONTAL.items() if palavras & set(v)), None) |
| centro = bool(palavras & set(_CENTRO)) |
| if not (vertical or horizontal or centro): |
| return None |
| |
| metade = bool(palavras & {"half", "metade", "mitad", "moitie", "halfte", "haelfte"}) |
| margem = max(0, min(margem, largura // 4, altura // 4)) |
| if horizontal == "esquerda": |
| x = largura // 4 if metade else margem |
| elif horizontal == "direita": |
| x = largura - largura // 4 if metade else largura - 1 - margem |
| else: |
| x = largura // 2 |
| if vertical == "topo": |
| y = altura // 4 if metade else margem |
| elif vertical == "base": |
| y = altura - altura // 4 if metade else altura - 1 - margem |
| else: |
| y = altura // 2 |
| return x, y |
|
|
|
|
| |
| |
| |
| EMPURRAO_PX = 14 |
| PASSOS_ARRASTO = 24 |
|
|
|
|
| def caminho(x0, y0, x1, y1, passos=PASSOS_ARRASTO, empurrao=EMPURRAO_PX): |
| """Pontos inteiros de (x0, y0) até (x1, y1), sem o de partida e |
| terminando exatamente no destino. Os primeiros cobrem só 'empurrao' px |
| (em 3 passos); o resto vai com aceleração e freada (ease-in-out).""" |
| dx, dy = x1 - x0, y1 - y0 |
| distancia = (dx * dx + dy * dy) ** 0.5 |
| if distancia < 1: |
| return [(int(x1), int(y1))] |
| pontos = [] |
| inicio = min(1.0, empurrao / distancia) |
| for i in (1, 2, 3): |
| f = inicio * i / 3 |
| pontos.append((round(x0 + dx * f), round(y0 + dy * f))) |
| resto = max(2, passos - 3) |
| for i in range(1, resto + 1): |
| s = i / resto |
| suave = s * s * (3 - 2 * s) |
| f = inicio + (1 - inicio) * suave |
| pontos.append((round(x0 + dx * f), round(y0 + dy * f))) |
| pontos[-1] = (int(x1), int(y1)) |
| limpos = [] |
| for p in pontos: |
| if not limpos or limpos[-1] != p: |
| limpos.append(p) |
| return limpos |
|
|
|
|
| def recorte_em_volta(x, y, raio, largura, altura): |
| """(x0, y0, x1, y1) do quadrado de lado 2*raio em volta de (x, y), |
| empurrado pra dentro da imagem (sem encolher, se couber).""" |
| lado = 2 * raio |
| x0 = min(max(0, x - raio), max(0, largura - lado)) |
| y0 = min(max(0, y - raio), max(0, altura - lado)) |
| return x0, y0, min(largura, x0 + lado), min(altura, y0 + lado) |
|
|
|
|
| SEMELHANCA_COR = 30 |
|
|
|
|
| def _mesma_cor(a, b): |
| return abs(a[0] - b[0]) + abs(a[1] - b[1]) + abs(a[2] - b[2]) <= SEMELHANCA_COR |
|
|
|
|
| def encaixar(imagem, x, y, raio=20): |
| """Se o ponto caiu numa área lisa (errou o botão |
| por pouco), vai pro centro do elemento INTEIRO mais perto (uma mancha |
| de cor própria que cabe na região). Caiu em cima de algo: fica.""" |
| try: |
| img = imagem.convert("RGB") |
| if not (0 <= x < img.width and 0 <= y < img.height): |
| return x, y |
| x0, y0, x1, y1 = recorte_em_volta(x, y, 3, img.width, img.height) |
| cor = img.getpixel((x, y)) |
| if not all(_mesma_cor(cor, img.getpixel((i, j))) for i in range(x0, x1) for j in range(y0, y1)): |
| return x, y |
| x0, y0, x1, y1 = recorte_em_volta(x, y, raio, img.width, img.height) |
| regiao = img.crop((x0, y0, x1, y1)) |
| largura, altura = regiao.size |
| px = regiao.load() |
| visto = [[False] * largura for _ in range(altura)] |
| lx, ly = x - x0, y - y0 |
| melhor = None |
| for j in range(altura): |
| for i in range(largura): |
| if visto[j][i]: |
| continue |
| semente = px[i, j] |
| pilha, pontos = [(i, j)], [] |
| visto[j][i] = True |
| while pilha: |
| a, b = pilha.pop() |
| pontos.append((a, b)) |
| for na, nb in ((a + 1, b), (a - 1, b), (a, b + 1), (a, b - 1)): |
| if 0 <= na < largura and 0 <= nb < altura and not visto[nb][na] \ |
| and _mesma_cor(px[na, nb], semente): |
| visto[nb][na] = True |
| pilha.append((na, nb)) |
| xs = [a for a, _ in pontos] |
| ys = [b for _, b in pontos] |
| bx0, bx1, by0, by1 = min(xs), max(xs), min(ys), max(ys) |
| |
| |
| if (bx0 <= lx <= bx1 and by0 <= ly <= by1 and (lx, ly) in set(pontos)) \ |
| or bx0 == 0 or by0 == 0 or bx1 == largura - 1 or by1 == altura - 1 \ |
| or len(pontos) < 12: |
| continue |
| dx = max(bx0 - lx, 0, lx - bx1) |
| dy = max(by0 - ly, 0, ly - by1) |
| d = dx * dx + dy * dy |
| if melhor is None or d < melhor[0]: |
| melhor = (d, (bx0 + bx1) / 2, (by0 + by1) / 2) |
| if melhor is None: |
| return x, y |
| return round(x0 + melhor[1]), round(y0 + melhor[2]) |
| except Exception: |
| return x, y |
|
|
|
|
| |
| |
| |
| LARGURA_COMPARACAO = 320 |
| LIMIAR_PIXEL = 40 |
| FRACAO_MUDOU = 0.002 |
|
|
|
|
| def mudanca(antes, depois): |
| """Fração (0–1) dos pixels que mudaram entre duas capturas do mesmo |
| lugar. Compara em tamanho pequeno: rápido e ignora ruído de 1 px.""" |
| if antes is None or depois is None or antes.size != depois.size: |
| return None |
| largura = min(LARGURA_COMPARACAO, antes.width) |
| altura = max(1, round(antes.height * largura / antes.width)) |
| a = antes.convert("RGB").resize((largura, altura)) |
| b = depois.convert("RGB").resize((largura, altura)) |
| pa, pb = a.load(), b.load() |
| mudados = 0 |
| for j in range(altura): |
| for i in range(largura): |
| ca, cb = pa[i, j], pb[i, j] |
| if abs(ca[0] - cb[0]) + abs(ca[1] - cb[1]) + abs(ca[2] - cb[2]) > LIMIAR_PIXEL: |
| mudados += 1 |
| return mudados / (largura * altura) |
|
|
|
|
| def mudou(fracao): |
| return fracao is not None and fracao >= FRACAO_MUDOU |
|
|
|
|
| |
| |
| |
| |
| |
| |
| _PALAVRAS_JANELA = {"janela", "window", "ventana", "fenetre", "fenster", "titlebar", "barra de titulo", |
| "title bar", "barre de titre", "titelleiste", "barra de titulo"} |
| _PALAVRAS_ABA = {"aba", "tab", "guia", "pestana", "onglet", "reiter", "tabs", "abas"} |
| _RE_MAXIMIZAR = {"maximize", "maximizar", "maximizada", "maximiser", "maximieren", "tela cheia", "full screen", |
| "fullscreen", "pantalla completa", "plein ecran", "vollbild", "inteira"} |
| _RE_RESTAURAR = {"restore", "restaurar", "restaure", "wiederherstellen", "normal", "unmaximize"} |
|
|
|
|
| def fala_de_janela(texto): |
| """'janela do openTARS', 'barra de título', 'the firefox window' (mas não 'aba do YouTube').""" |
| n = " ".join(_normalizar(texto)) |
| palavras = set(n.split()) |
| if palavras & _PALAVRAS_ABA: |
| return False |
| return bool(palavras & _PALAVRAS_JANELA) or any(p in n for p in _PALAVRAS_JANELA if " " in p) |
|
|
|
|
| def sem_palavras_de_janela(texto): |
| """'a janela do openTARS' -> 'openTARS'.""" |
| fora = {"a", "o", "the", "la", "le", "die", "der", "da", "do", "de", "of", "del", "du", "des"} |
| fora |= {p for p in _PALAVRAS_JANELA if " " not in p} |
| fora |= {"barra", "titulo", "title", "bar", "barre", "titre", "titelleiste", "sua", "your", "minha", "my"} |
| return " ".join(p for p in str(texto or "").split() if " ".join(_normalizar(p)) not in fora).strip() |
|
|
|
|
| def lugar_da_janela(lugar, area, tamanho=None): |
| """Onde pôr a janela: (x, y, largura, altura) do retângulo EXTERNO (com a |
| borda), largura/altura None = não muda o tamanho; ou 'maximizar' / |
| 'restaurar'; ou None se 'lugar' não é um lugar conhecido. |
| |
| area = (x, y, largura, altura) da área útil (sem painéis, _NET_WORKAREA); |
| tamanho = (largura, altura) da janela por fora, pra encostar nos cantos |
| da direita/de baixo e centralizar.""" |
| palavras = set(_normalizar(lugar)) |
| n = " ".join(_normalizar(lugar)) |
| if palavras & _RE_MAXIMIZAR or any(p in n for p in _RE_MAXIMIZAR if " " in p): |
| return "maximizar" |
| if palavras & _RE_RESTAURAR: |
| return "restaurar" |
| ax, ay, al, aa = area |
| vertical = next((k for k, v in _VERTICAL.items() if palavras & set(v)), None) |
| horizontal = next((k for k, v in _HORIZONTAL.items() if palavras & set(v)), None) |
| centro = bool(palavras & set(_CENTRO)) |
| metade = bool(palavras & {"half", "metade", "mitad", "moitie", "halfte", "haelfte"}) |
| if not (vertical or horizontal or centro): |
| return None |
| if metade: |
| if horizontal and not vertical: |
| return (ax if horizontal == "esquerda" else ax + al // 2, ay, al // 2, aa) |
| if vertical and not horizontal: |
| return (ax, ay if vertical == "topo" else ay + aa // 2, al, aa // 2) |
| largura, altura = tamanho or (al // 2, aa // 2) |
| largura, altura = min(largura, al), min(altura, aa) |
| if horizontal == "esquerda": |
| x = ax |
| elif horizontal == "direita": |
| x = ax + al - largura |
| else: |
| x = ax + (al - largura) // 2 |
| if vertical == "topo": |
| y = ay |
| elif vertical == "base": |
| y = ay + aa - altura |
| else: |
| y = ay + (aa - altura) // 2 |
| return (x, y, None, None) |
|
|
