Screenshot auf bestimmtes Teilbild untersuchen

[FawKes100]

Hallöchen,
ich habe ein Programm, welches einen Screenshot machen soll und dieses auf ein bestimmtes Bild, welches in dem Screenshot auch vorkommt. Nun ist das Problem allerdings, dass dieses Teilbild nicht genauso groß ist wie das gesamte Bild. Zunächst einmal lasse ich alle Pixel in die rgb-Werte zerlegen:

for(int i=0; i<zBreite; i++)
            {
                for(int j=0; j<zHoehe; j++)
                {
                    int rgb = screen.getRGB(i, j);
                    Color color = new Color(rgb);
                    red[i][j] = color.getRed();
                    blue[i][j] = color.getBlue();
                    green[i][j] = color.getGreen();
                }
            }

Doch wie gehe ich da jetzt jeweils durch und überprüfe ob das Bild vorhanden ist? Würde theoretisch das Bild in 36*23 Teile aufteilen (da so großn auch der Teilbereich der im Bild gesucht werden soll ist) und überprüfen ob ein Teil identisch ist. Hierzu hatte ich überlegt eine Image Klasse zu schreiben, wo das Bild jeweils ein zweidimensionales Array von den RGB werten beinhaltet. Von dieser Klasse würde ich dann ebenfalls wieder ein zweidimensionales Array bilden. Doch wie schreibe ich das mit den Schleifen auf? Theoretisch bräuchte ich doch ne 4-Fache ForSchleife oder? Allerdings bekomme ich mit folgendem Programmiercode ab der 31. Spalte eine ArrayIndexOutOfBoundsException

int[][] red = new int[zBreite][zHoehe];
            int[][] green = new int[zBreite][zHoehe];
            int[][] blue = new int[zBreite][zHoehe];
           
            for(int i=0; i<zBreite; i++)
            {
                for(int j=0; j<zHoehe; j++)
                {
                    int rgb = screen.getRGB(i, j);
                    Color color = new Color(rgb);
                    red[i][j] = color.getRed();
                    blue[i][j] = color.getBlue();
                    green[i][j] = color.getGreen();
                }
            }
           
            int rot[][] = new int[zHeight][zWidth];
            int gruen[][] = new int[zHeight][zWidth];
            int blau[][] = new int[zHeight][zWidth];
           
            for(int a=0; a<zeilen; a++)
            {
                for(int b=0; b<spalten; b++)
                {
                    for(int i=0; i<zHeight; i++)
                    {
                        for(int j=0; j<zWidth; j++)
                        {
                            if(a!=0 && b!=0)
                            {
                                rot[i][j] = red[a*i][b*j];
                                gruen[i][j] = gruen[a*i][b*j];
                                blau[i][j] = blue[a*i][b*j];
                            }
                            else if(a==0 && b==0)
                            {
                                rot[i][j] = red[i][j];
                                gruen[i][j] = gruen[i][j];
                                blau[i][j] = blue[i][j];
                            }
                            else if(a!=0 && b==0)
                            {
                                rot[i][j] = red[i*a][j];
                                gruen[i][j] = gruen[i*a][j];
                                blau[i][j] = blue[i*a][j];
                            }
                            else if(a==0 && b!=0)
                            {
                                rot[i][j] = red[i][j*b];
                                gruen[i][j] = gruen[i][j*b];
                                blau[i][j] = blue[i][j*b];
                            }
                        }
                    }
                }
            }

Der Fehler passiertder letzten Möglichkeit:

else if(a==0 && b!=0)
                            {
                                rot[i][j] = red[i][j*b];
                                gruen[i][j] = green[i][j*b];
                                blau[i][j] = blue[i][j*b];
                            }

Oder ist es sogar ohne diese komplexe Logik von Schleifen möglich ein BufferedImage in mehrere gleichgroße Teile aufzuteilen, bevor die RGB Werte in Arrays abgespeichert werden etc.?

 

[Xyz1]

Such mal nach image recognition algorithm
oder genauer Template Matching:
https://docs.opencv.org/3.2.0/de/da9/tutorial_template_matching.html
die Formeln sind hier nochmal:
https://docs.opencv.org/trunk/df/dfb/group__imgproc__object.html#ga3a7850640f1fe1f58fe91a2d7583695d

ich kann dir leider nicht beim Verständnis helfen.

 

[FawKes100]

Okay, das sieht nach verdammt viel Mathematik aus
Der Vorgang der hier beschrieben wird, ähnelte ja auch grundlegend meiner Idee das Bild stück für stück zu durchwandern...
Für Python stehen bei dem zweiten Link bereits die Methode (oder wie man das da nennt), die die Funktion bilden würde. Das bedeutet nun, dass ich zu erst einmal die Klasse schreiben müsste, die diese Funktionen berechnen kann?
Zusätzlich ist beim ersten Link noch Code mit beigefügt, doch welcher Programmiersprache entspricht dieses? Wenn ich die Seite richtig verstanden habe, müsste ich den Code nur nach Java transportieren, aber ich glaube kaum dass das so einfach ist..

 

[Xyz1]

Zweitere "Methoden" sind glaube ich für Python: https://docs.opencv.org/trunk/d4/dc6/tutorial_py_template_matching.html
Ersteres bezieht sich auf die Java Lib von OpenCV (BTW die ist nebenbei über 100 MB groß, ich habe das irgendwann einfach gelassen...)
Allerdings alles nach "Code at glance:" ist Hardcore C/C++ Code (Namensräume usw. deuten darauf hin)
ja prinzipiell wird das Quellbild "irgendwie" durchlaufen/iteriert. danach wird es vermutlich auf das template hin untersucht.
wann, wo und vor allem wie du diese Funktionen und Klassen schreiben müsstest, kann ich dir nicht beantworten.