PixelSearch Topic is solved

[glnklein]

PixelSearch, sucht standardmäßig von oben links nach oben rechts und geht dann ein zeile nach unten bis zum erfolgreichen finden der farbe.

ist es möglich die suche vom Zentrum zu beginnen und kreisförmig nach ausen zu suchen

habe die selbe frage zwar auch ins englishe Forum geschrieben , bin mir aber nicht sicher ob bei der Google übersetzung die frage richtig verstanden werden kann

[Mod edit: Das Topic wurde ins 'Spiele'-Unterforum verschoben.]

[garry]

nicht die richtige Antwort, lediglich ein Test Skript um im richtigem Bereich ( Rechteck ) zu suchen

Code: Select all

;- Pixelsearchxxx
;- mousemove to RED rectangle 
#Requires AutoHotkey v1
setworkingdir,%a_scriptdir%
setbatchlines -1
Gui,2:  -DPIScale +AlwaysOnTop -Caption +Border
Gui,2:Color,RED
CoordMode, Pixel,screen
CoordMode, Mouse,screen
bgr := 0xFF0000  ;- RED
xx:=100,WA:=A_screenwidth,HA:=A_screenheight
;-
x3:=(WA*45)/xx,y3:=(HA*45)/xx,w3:=(WA*10)/xx,h3:=(HA*10)/xx   ;- GUI area RED
x1:=x3,y1:=y3,x2:=x3+w3,y2:=y3+h3                             ;- search in this  area 
Gui, 2:Show, x%x3% y%y3% w%w3% h%h3%,COLOR_TEST
return
;------------
$space::
While GetKeyState("space", "P") {
 ;PixelSearch,XF,YF, 0, 0, A_ScreenWidth, A_ScreenHeight, %bgr%,0,RGB Fast
 PixelSearch,XF,YF,x1,y1,x2,y2, %bgr%,0,RGB Fast
 If (!ErrorLevel)
     mousemove,%xf%,%yf%,0
 else	 
  ToolTip,NOT FOUND = %bgr% 
}
tooltip
SoundBeep, 1000
Return
;------------
esc::exitapp
;============

[Noitalommi_2]

Hi.

PixelSearch, sucht standardmäßig von oben links nach oben rechts und geht dann ein zeile nach unten bis zum erfolgreichen finden der farbe.

ist es möglich die suche vom Zentrum zu beginnen und kreisförmig nach ausen zu suchen
[...]

Nicht mit PixelSearch aber was erhoffst du dir davon?

[glnklein]

danke für die antworten ,

@Noitalommi_2
eine suche von der mitte nach aussen ist genauer als von der obersten linken ecke zur untersten rechten .

habe es jetzt mal so getestet was es aber langsamer macht da ja 3 mal gesucht wird und auch im kleinen bereich

Code: Select all

-------------------------------------------------------------------------------------------------
		
		
		radius:=90
		radiusdurch3:=% Round(radius/3)  
		radiusdurch2:=% Round(radius/2)  
		radiusdurch1:=radius
		
		
		PixelSearch, Px, Py,X-radiusdurch3, Y-radiusdurch3, X+radiusdurch3, Y+radiusdurch3, suche, 6, FAST RGB
		If ErrorLevel 
		{
			PixelSearch, Px, Py,X-radiusdurch3, Y-radiusdurch2, X+radiusdurch2, Y+radiusdurch2, suche, 6, FAST RGB
			If ErrorLevel 
			{
			
				PixelSearch, Px, Py,X-radiusdurch3, Y-radiusdurch1, X+radiusdurch1, Y+radiusdurch1, suche, 6, FAST RGB
				If ErrorLevel 
				{
				
				}
		
			}
		}

	

;-------------------------------------------------------------------------------------------------

[just me]

Moin,

bei Deinem Ansatz überschneiden sich die Suchbereiche. Der erste Bereich wird im schlechtesten Fall 3 mal durchsucht. Das dauert!

@Noitalommi_2
eine suche von der mitte nach aussen ist genauer als von der obersten linken ecke zur untersten rechten .

'Genauer' ist es allenfalls, wenn Du bei mehreren möglichen Treffern im Suchbereich die Position des Pixels sucht, das am nächsten zur Mitte liegt. Ist das so? Und wie definierst Du 'am nächsten zur Mitte'?

[glnklein]

Moin,

bei Deinem Ansatz überschneiden sich die Suchbereiche. Der erste Bereich wird im schlechtesten Fall 3 mal durchsucht. Das dauert!

@Noitalommi_2
eine suche von der mitte nach aussen ist genauer als von der obersten linken ecke zur untersten rechten .

'Genauer' ist es allenfalls, wenn Du bei mehreren möglichen Treffern im Suchbereich die Position des Pixels sucht, das am nächsten zur Mitte liegt. Ist das so? Und wie definierst Du 'am nächsten zur Mitte'?

stimmt er sucht im schlechtesten Fall 3 mal das stört mich ja ,
als definition würde ich den bildschirm mittelpunkt verwenden

Code: Select all

x :=A_ScreenWidth/2
y :=A_ScreenHeight/2

deine idee mit dem am nächsten zur mitte gefunden pixel hört sich gut an , hab auch mal rum getestet aber die berechnung bekomme ich nicht hin ,hast du da eine idee die ich weiter/erweitern kann als basis zum verstehen ?

vorallem hört pixelsearch ja nach einem gefunden pixel auf

[Noitalommi_2]

@Noitalommi_2
eine suche von der mitte nach aussen ist genauer als von der obersten linken ecke zur untersten rechten .

Bei einem Suchbereich von 180x180 Pixel wie in deinem Beispiel, spielt es eigentlich keine Rolle wo die Suche beginnt.
Ich habe eben einen Benchmark mit 60 x PixelSearch und einem Suchbereich von 555x555 Pixel gemacht.
Einmal war die gesuchte Farbe auf dem ersten Pixel und das zweite mal auf dem letzten Pixel (308025).
Die Differenz über eine Sekunde Laufzeit betrug lediglich eine ms, also pro PixelSearch ist das fast nichts.
Wenn wir über einen moderaten Suchbereich sprechen, ist es im Grunde egal wo die Suche startet, ob nun oben links, unten rechts oder in der Mitte.

Zu erwähnen ist noch, dass es scheinbar eine Korrelation zwischen der Geschwindigkeit mit der PixelSearch ausgeführt wird und den dargestellten Frames pro Sekunde gibt.
Also, dass die FPS-Zahl beeinflusst, wie häufig PixelSearch pro Sekunde ausgeführt wird.

[glnklein]

Wie hast du den die pixelsuche von der Mitte nach aussen messen können.

[glnklein]

Im Grunde geht es mir darum das wenn der Pixel in der Mitte gefunden wurde und sich dann nach links verschiebt um sagen wir 20 Pixel , zur gleichen Zeit taucht rechts bei 50 Pixel auch die gesuchte Farbe auf , dann würde pixelsuche den bei 50 Pixel als erstes finden und das ist nicht gut .
Ich möchte die der Mitte am nächsten gefunden Pixel Priorität geben .

Hoffe es ist verständlich

[glnklein]

das ist nun das beste was ich hinbekommen habe , leider ist es im vergleich sehr langsam .
bekommt man das nicht schneller ?

Code: Select all

#SingleInstance Force
CoordMode, Pixel, Screen
CoordMode, Mouse, Screen
CoordMode, ToolTip, Screen
x :=A_ScreenWidth/2
y :=A_ScreenHeight/2-22 ; minus 22 weil die #taskleiste in Windows 11  22pixel hat
	
		
radius:=50
px1=0	
hCircle := makeCircle(0x00FF00, r := radius, 2, 240)	
	
	radiusdurch:=% Round(radius/radius)  
	
	loop %radius%
	{

		PixelSearch, Px, Py,X-radiusdurch*A_INDEX, Y-radiusdurch*A_INDEX, X+radiusdurch*A_INDEX, Y+radiusdurch*A_INDEX, 0xFFFFFF, 1, FAST RGB
		
		if Px=
		{
		
		
		}
		else
		{
		
			if (Px < px1)
			{
			ende=1
			}
		
		if ende=1
		{
		ToolTip, %Px%x%Py%, %Px%,%Py%
		;break ; klammert man Break aus sieht man wie lange eine suche dauern würde 
		}
		
		
		
		px1:=Px
		}
		
	}
	
	
	
		
		
return
makeCircle(color, r := 50, thickness := 10, transparency := 254) {
	static HWND := MakeGui()
	d := 2 * r

	; https://autohotkey.com/board/topic/7377-create-a-transparent-circle-in-window-w-winset-region/
	outer := DllCall("CreateEllipticRgn", "Int", 0, "Int", 0, "Int", d, "Int", d)
	inner := DllCall("CreateEllipticRgn", "Int", thickness, "Int", thickness, "Int", d - thickness, "Int", d - thickness)
	DllCall("CombineRgn", "UInt", outer, "UInt", outer, "UInt", inner, "Int", 3) ; RGN_XOR = 3
	DllCall("SetWindowRgn", "UInt", HWND, "UInt", outer, "UInt", true)

	Gui %HWND%:Color, % color
	Gui %HWND%:Show, xCenter yCenter w%d% h%d% NoActivate
	WinSet Transparent, % transparency, % "ahk_id " HWND

	return HWND
}

MakeGui() {
	Gui New, +E0x20 +AlwaysOnTop +ToolWindow -Caption +Hwndhwnd
	return hwnd
}

[Noitalommi_2]

@glnklein

Hier, das sucht spiralförmig von der Mitte nach außen.
Wenn keine Pixelfarbe gefunden wird, dauert ein kompletter Durchlauf bei mir ~240ms. (200x200)
Wenn du die Größe auf 100x100 reduzierst, geht es deutlich schneller ~72ms
Wenn die gesuchte Farbe gefunden wird, geht es natürlich schneller, weil dann nicht der komplette Bereich bis zum Ende durchsucht wird.

Ist V2 aber wolltest ja eh wechseln.

Code: Select all

#Requires AutoHotkey 2.0
#SingleInstance

CoordMode "Mouse"

X1 := A_ScreenWidth/2-100
Y1 := A_ScreenHeight/2-100
X2 := A_ScreenWidth/2+100
Y2 := A_ScreenHeight/2+100
Farbe := 0xFF0000

F8:: {

    if SpiralPixelSearch(&AusgabeVarX, &AusgabeVarY, X1, Y1, X2, Y2, Farbe)
        MouseMove AusgabeVarX, AusgabeVarY
}


SpiralPixelSearch(&CenterX, &CenterY, X1, Y1, X2, Y2, Color) { ; 0/1

    Width := X2-X1
    Height := Y2-Y1
    CenterX := Width/2
    CenterY := Height/2
    Found := 0

    HDC := DllCall("GetDC", "Ptr", 0, "Ptr")
    HCDC := DllCall("CreateCompatibleDC", "Ptr", HDC, "Ptr")
    HBITMAP := DllCall("CreateCompatibleBitmap", "Ptr", HDC, "Int", Width, "Int", Height, "Ptr")
    DllCall("SelectObject", "Ptr", HCDC, "Ptr", HBITMAP)
    DllCall("BitBlt", "Ptr", HCDC, "Int", 0, "Int", 0, "Int", Width, "Int", Height, "Ptr", HDC, "Int", X1, "Int", Y1, "UInt", 0xCC0020)

    Loop Height {

        Index := A_Index
        Loop Index {

            CenterY := CenterY+(Index & 1 ? 1 : -1)
            BGR := DllCall("GetPixel", "Ptr", HCDC, "Int", CenterX, "Int", CenterY, "UInt")
            RGB := BGR >> 16 & 0xFF | BGR & 0xFF00 | (BGR & 0xFF) << 16
            if RGB = Color {
                CenterX := X1+CenterX
                CenterY := Y1+CenterY
                Found := 1
                break 2
            }
        }
        Loop Index {

            CenterX := CenterX+(Index & 1 ? -1 : 1)
            BGR := DllCall("GetPixel", "Ptr", HCDC, "Int", CenterX, "Int", CenterY, "UInt")
            RGB := BGR >> 16 & 0xFF | BGR & 0xFF00 | (BGR & 0xFF) << 16
            if RGB = Color {
                CenterX := X1+CenterX
                CenterY := Y1+CenterY
                Found := 1
                break 2
            }
        }
    }
    DllCall("ReleaseDC", "Ptr", 0, "Ptr", HDC)
    DllCall("DeleteDC", "Ptr", HCDC)
    DllCall("DeleteObject", "Ptr", HBITMAP)
    return Found
}

[glnklein]

wie lange dauert den im vergleich meine code den ich gepostet habe nur so im vergleich .

sooo schnell wollte ich aber auch nicht umsteigen , ich versteh deine code ja noch nicht mal richtig

[Noitalommi_2]

wie lange dauert den im vergleich meine code den ich gepostet habe nur so im vergleich .

Weis nicht, dein Code schaut irgendwie ramponiert aus, fehlt da nicht etwas?

sooo schnell wollte ich aber auch nicht umsteigen , ich versteh deine code ja noch nicht mal richtig

Da gibt es doch nicht viel zu verstehen, drück F8 und wenn sich ein roter Pixel im Suchbereich befindet, wird der Cursor dort hingesetzt.
Der Suchbereich hat sein Zentrum in der Bildschirmmitte und ist 200x200 Pixel groß.

[just me]

Moin,

@Noitalommi_2's Skript ist ein gutes Beispiel dafür, dass die Syntax von AHK v1.1 und v2 nicht immer stark unterschiedlich ist. Deshalb hier mal die v1 Version:

Code: Select all

SpiralPixelSearch(ByRef CenterX, ByRef CenterY, X1, Y1, X2, Y2, Color) { ; 0/1
   Width := X2 - X1
   Height := Y2 - Y1
   CenterX := Ceil(Width / 2)
   CenterY := Ceil(Height / 2)
   Found := 0

   HDC := DllCall("GetDC", "Ptr", 0, "Ptr")
   HCDC := DllCall("CreateCompatibleDC", "Ptr", HDC, "Ptr")
   HBITMAP := DllCall("CreateCompatibleBitmap", "Ptr", HDC, "Int", Width, "Int", Height, "Ptr")
   DllCall("SelectObject", "Ptr", HCDC, "Ptr", HBITMAP)
   DllCall("BitBlt", "Ptr", HCDC, "Int", 0, "Int", 0, "Int", Width, "Int", Height, "Ptr", HDC, "Int", X1, "Int", Y1, "UInt", 0xCC0020)

   Loop, %Height% {
      Index := A_Index
      Loop, %Index% {
         CenterY := CenterY + (Index & 1 ? 1 : -1)
         BGR := DllCall("GetPixel", "Ptr", HCDC, "Int", CenterX, "Int", CenterY, "UInt")
         RGB := (BGR >> 16) & 0xFF | BGR & 0xFF00 | (BGR & 0xFF) << 16
         If (RGB = Color) {
            CenterX := X1 + CenterX
            CenterY := Y1 + CenterY
            Found := 1
            Break 2
         }
      }
      Loop, %Index% {
         CenterX := CenterX + (Index & 1 ? -1 : 1)
         BGR := DllCall("GetPixel", "Ptr", HCDC, "Int", CenterX, "Int", CenterY, "UInt")
         RGB := (BGR >> 16) & 0xFF | BGR & 0xFF00 | (BGR & 0xFF) << 16
         If (RGB = Color) {
            CenterX := X1 + CenterX
            CenterY := Y1 + CenterY
            Found := 1
            Break 2
         }
      }
   }
   DllCall("ReleaseDC", "Ptr", 0, "Ptr", HDC)
   DllCall("DeleteDC", "Ptr", HCDC)
   DllCall("DeleteObject", "Ptr", HBITMAP)
   Return Found
}

Ich sehe hier ein paar mögliche Probleme:

• Das Pixel im Zentrum wird nicht geprüft.
• Die Routine funktioniert nur mit quadratischen Suchbereichen, obwohl in X1, Y1, X2 und Y2 beliebige Koordinaten übergeben werden können.
• Wenn es darum geht, dass dem Zentrum nächste Pixel der gesuchten Farbe zu finden, kann das schief gehen, weil in den Schleifen immer 'von Außen nach Innen' gesucht und beim ersten Treffer abgebrochen wird.

[Noitalommi_2]

@just me
Ja, stimmt.

Als Alternative könnte man es so handhaben, dass der gesamte Bereich standardmäßig von oben links nach unten rechts durchsucht wird und bei einem Treffer die Koordinaten in ein Array gepackt werden. Am Ende des Durchlaufs werden die Koordinaten ausgewertet und die am nächsten zur Mitte liegenden ausgegeben.
Das hat aber den Nachteil, dass der Bereich immer komplett abgegrast wird. Der Vorteil, die genannten Probleme fallen weg.

[Noitalommi_2]

Habe die Idee mal umgesetzt und finde 65ms für ein 100x100 Pixel großen Suchbereich ganz passabel mit 200x100 Pixel sind es bereits schon 120ms, was noch ok ist.
Wenn mehrere gleiche Farben gefunden werden, gibt das Skript die Koordinaten aus, die dem Zentrum am nächsten sind.
Mein Versuch, daraus auch eine v1-Version zu machen ist gescheitert, komme damit nicht mehr klar.

Code: Select all

#Requires AutoHotkey 2.0
#SingleInstance

CoordMode "Mouse"

X1 := 1690
Y1 := 880
X2 := 1790
Y2 := 980
Color := 0xFF0000


F8:: {

	if CenterPixelSearch(&OutputVarX, &OutputVarY, X1, Y1, X2, Y2, Color)
		MouseMove OutputVarX, OutputVarY
}

CenterPixelSearch(&OutputVarX, &OutputVarY, X1, Y1, X2, Y2, Color) { ; 0/1

    Width := X2-X1
    Height := Y2-Y1
	CenterX := Ceil(Width/2)
	CenterY := Ceil(Height/2)
	OutputVarX := OutputVarY := ""

    HDC := DllCall("GetDC", "Ptr", 0, "Ptr")
    HCDC := DllCall("CreateCompatibleDC", "Ptr", HDC, "Ptr")
    HBITMAP := DllCall("CreateCompatibleBitmap", "Ptr", HDC, "Int", Width, "Int", Height, "Ptr")
    DllCall("SelectObject", "Ptr", HCDC, "Ptr", HBITMAP)
    DllCall("BitBlt", "Ptr", HCDC, "Int", 0, "Int", 0, "Int", Width, "Int", Height, "Ptr", HDC, "Int", X1, "Int", Y1, "UInt", 0xCC0020)

	Coords := [	[],
				[],
				[]]
    Loop {

        Y := A_Index-1
		Loop {

			X := A_Index-1
			BGR := DllCall("GetPixel", "Ptr", HCDC, "Int", X, "Int", Y, "UInt")
			RGB := BGR >> 16 & 0xFF | BGR & 0xFF00 | (BGR & 0xFF) << 16
			if Color = RGB {

				Coords[1].Push(X)
				Coords[2].Push(Y)
				Coords[3].Push(Abs(CenterX-X)+Abs(CenterY-Y))
			}

        }until A_Index = Width
    }until A_Index = Height

	DllCall("ReleaseDC", "Ptr", 0, "Ptr", HDC)
	DllCall("DeleteDC", "Ptr", HCDC)
	DllCall("DeleteObject", "Ptr", HBITMAP)

	if !Coords[3].Length
		return 0
	Min_ := Min(Coords[3]*)
	For Index, Range in Coords[3]
		if Range = Min_ {
			OutputVarX := X1+Coords[1][Index]
			OutputVarY := Y1+Coords[2][Index]
			break
		}
	return 1
}

[just me]

Hi @Noitalommi_2, gut. Dann spendiere ich mal eine v1 Version:

Code: Select all

CenterPixelSearch(ByRef OutputVarX, ByRef OutputVarY, X1, Y1, X2, Y2, Color) { ; 0/1
   Width := X2 - X1
   Height := Y2 - Y1
   CenterX := Ceil(Width / 2)
   CenterY := Ceil(Height / 2)
   OutputVarX := ""
   OutputVarY := ""
   Found := 0

   HDC := DllCall("GetDC", "Ptr", 0, "Ptr")
   HCDC := DllCall("CreateCompatibleDC", "Ptr", HDC, "Ptr")
   HBITMAP := DllCall("CreateCompatibleBitmap", "Ptr", HDC, "Int", Width, "Int", Height, "Ptr")
   DllCall("SelectObject", "Ptr", HCDC, "Ptr", HBITMAP)
   DllCall("BitBlt", "Ptr", HCDC, "Int", 0, "Int", 0, "Int", Width, "Int", Height, "Ptr", HDC, "Int", X1, "Int", Y1, "UInt", 0xCC0020)

   MinDist := Width + Height
   SY := 0
   Loop, %Height% {
      SX := 0
      Loop, %Width% {
         BGR := DllCall("GetPixel", "Ptr", HCDC, "Int", SX, "Int", SY, "UInt")
         RGB := ((BGR & 0xFF0000) >> 16) | (BGR & 0x00FF00) | ((BGR & 0x0000FF) << 16)
         If (Color = RGB) {
            Dist := Abs(CenterX - SX) + Abs(CenterY - SY)
            If (Dist < MinDist) {
               OutputVarX := SX + X1
               OutputVarY := SY + Y1
               MinDist := Dist
               Found := 1
            }
         }
         SX++
      }
      SY++
   }

   DllCall("ReleaseDC", "Ptr", 0, "Ptr", HDC)
   DllCall("DeleteDC", "Ptr", HCDC)
   DllCall("DeleteObject", "Ptr", HBITMAP)

   Return Found
}

[Noitalommi_2]

@just me
Danke dafür.

Mit einem Suchbereich von 100x100 Pixel ergab der Benchmark im Durchschnitt ~66ms bei mir. (SetBatchLines -1)

[glnklein]

das ist ja super , vielen dank an alle ich werde testen was für mich am besten funktioniert .

Super Forum

[glnklein]

mag sich einer der experten gerade noch dieses Problem ansehen , eigentlich ist es gelöst ich finde nur den GuiControl Befehl nicht um den kreis 1 und 2 in der Größe zu verändern wenn sie bereits vorhanden sind

viewtopic.php?f=9&t=129726