großzügiges Pixelraster über Bildschirm legen

[berndoa]

Hallo,
ich hab ein schon älteres Programm bei dem ich mittels Robot auf schätzungsweise 10 verschiedene Buttons auf dem Bildschirm klicke.
Oer DOM da was zu erreichen geht leider nicht (aus dem Source Code weiß ich dass da nur eine Canvas drauf ist, die von einem Javascript Code geändert wird. Kann also die Buttons nicht direkt ansteuern),
daher muss ich wohl oder übel händisch die Position jedes Buttons ablesen und auf die (x,y) Koordinate klicken lassen.
Was etwas nervig ist wenn ich bspw. auf meinen Computer, Browser und Co. das Skript ausgerichtet habe und dann das Programm woanders nutzen will.
Denn da wird ja durch Auflösung und Co. das wieder anders sein und die Buttons an anderen Positionen sein.

Um mir bei einem Übergang das Leben leichter zu machen, würde ich mir gerne eine Art Raster über den Bildschirm legen um wenigstens einfach die Koordinaten ablesen zu können.

Ich stelle mir das recht simpel vor:
Bei x=10,20,30,..., 10*k Pixel wird jeweils eine senkrechte Linie gezogen.
Und entsprechend bei den y=10*k Pixel werden entsprechend waagrechte Linien gezogen.
Dann ist Alles auf dem Bildschirm zumindest einem 10x10 Pixel Quadrat zuzuordnen.
Und wenn ich halt bspw. sehe dass ein button seinen Mittelüunkt so grob oben links im betreffenden Quadrat hat, dann wird die Positione sowas wie (13,22) oder so sein.

Ich schätze dann halt die Position, auf absolute Präzision kommt es nicht an, 2-3 Pixel Abweichung sind locker verkraftbar.

Aber ja, so würde ich gerne in bspw. 10 pixel Abstand gerne senkrecht und waagrecht Linien über den Bildschirm zeichnen, natürlich ideallerweise dass jede 50 pixel Linie ne Beschriftung hat oder so.

Koordinatensystem halt, im Prinzip, nur nicht so hohe Präzision.

Läst sich sowas mit Java Quick and Dirty umsetzen?
Geht nur drum dass ich es drüberlege, vll. Scree nshot des Ganz mache und in aller Seelenruhe dann alle Positionen ablesen kann die ich brauche 🙂

 

[berndoa]

Hallo,
ich hab ein schon älteres Programm bei dem ich mittels Robot auf schätzungsweise 10 verschiedene Buttons auf dem Bildschirm klicke.
Oer DOM da was zu erreichen geht leider nicht (aus dem Source Code weiß ich dass da nur eine Canvas drauf ist, die von einem Javascript Code geändert wird. Kann also die Buttons nicht direkt ansteuern),
daher muss ich wohl oder übel händisch die Position jedes Buttons ablesen und auf die (x,y) Koordinate klicken lassen.
Was etwas nervig ist wenn ich bspw. auf meinen Computer, Browser und Co. das Skript ausgerichtet habe und dann das Programm woanders nutzen will.
Denn da wird ja durch Auflösung und Co. das wieder anders sein und die Buttons an anderen Positionen sein.

Um mir bei einem Übergang das Leben leichter zu machen, würde ich mir gerne eine Art Raster über den Bildschirm legen um wenigstens einfach die Koordinaten ablesen zu können.

Ich stelle mir das recht simpel vor:
Bei x=10,20,30,..., 10*k Pixel wird jeweils eine senkrechte Linie gezogen.
Und entsprechend bei den y=10*k Pixel werden entsprechend waagrechte Linien gezogen.
Dann ist Alles auf dem Bildschirm zumindest einem 10x10 Pixel Quadrat zuzuordnen.
Und wenn ich halt bspw. sehe dass ein button seinen Mittelüunkt so grob oben links im betreffenden Quadrat hat, dann wird die Positione sowas wie (13,22) oder so sein.

Ich schätze dann halt die Position, auf absolute Präzision kommt es nicht an, 2-3 Pixel Abweichung sind locker verkraftbar.

Aber ja, so würde ich gerne in bspw. 10 pixel Abstand gerne senkrecht und waagrecht Linien über den Bildschirm zeichnen, natürlich ideallerweise dass jede 50 pixel Linie ne Beschriftung hat oder so.

Koordinatensystem halt, im Prinzip, nur nicht so hohe Präzision.

Läst sich sowas mit Java Quick and Dirty umsetzen?
Geht nur drum dass ich es drüberlege, vll. Scree nshot des Ganz mache und in aller Seelenruhe dann alle Positionen ablesen kann die ich brauche 🙂

Ich habe nochmal überlegt was konkret zu tun wäre:
1) Screenshot mit java machen und mal als jpg oder so speichern.
2) jenes jpg wie folgt bearbeiten:
wenn wir die realen bildschirmlänge/breite mittels Toolkit.getDefaultToolkit().getScreenSize() haben und auch die "länge und breite" des bildes wissen (also von was bis was die koordinaten des bildes gehen),
dann kann man ja jede reale bildschirmkoordinate in eine bildkoordinate umrechnen.
dementsprechend lässt sich ein "zeichen eine linie von (10,0) bis (10,855) auf dem bildschirm" umrechnen in ein entsprechendes kommando um eine passend elinie auf dem bild zu zeichnen.

also entsprechende umrechnung von bildschirm zu bildkoordinaten machen und so linien auf dem bild einzeichnen wie sie in "real" 10 pixel voneinander entfernt wären.

Frage ist nur:
1. wie zeichne ich generell mit java einfach einem gegebenen jpg linien und punkte ein?
2. wie komme ich praogrammiertechnishc an die "dimensionen" der bilddatei, also die dimensionen der bildfläche die ich sehen würde wenn ich das bild in paint aufmachen würde?

wenn ich die 2 sachen wüsste, könnte ich das umsetzen.

Gut, die 50 pixel abstandsmarkierungen ins bild schreiben ist sicherlich auch irgendwie machbar.

 

[temi]

Vielleicht ist hier was dabei, das du nutzen kannst und BufferedImage hat ja Methoden, um die Größe abzurufen.

 

[mihe7]

Warum kein transparentes Window über den ganzen Bilschirm legen, per Maus ein Rechteck ziehen und die Koordinaten ausgeben?

 

[yfons123]

du kannst über F12 im browser dir die elemente ausgeben lassen in welcher position diese im DOM sind
zb

div1.div2.canvas3

dann lässt du dir zb durch javafx webview dir eine ansicht bauen ( muss ja nicht sichtbar sein ) oder anders
und dann von deiner gebauten ansicht sagst du "gib mir canvas3 koordinaten" da deine ansicht immer passend ist und nicht vom browser abhängig ist könnte es vllt so funtkionieren

 

[berndoa]

Ich habe mir mal ein Proramm zusammengebaut, das soweit ich sehe bisher mal meine Zwecke erfüllt:

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

import java.awt.Dimension;
import java.awt.Toolkit;
// importing Java AWT class 
import java.awt.*;   


public class DrawTest{
    
    int rewidth=0;
    int reheight=0;
    int imwidth=0;
    int imheight=0;
    int griddist=20;
    
    public DrawTest(){
        
        Dimension size=Toolkit.getDefaultToolkit().getScreenSize();   
    
        // getWidth() method returns the imheight of the screen
        rewidth = (int)size.getWidth();
        // getHeight() method returns the imheight of the screen
        reheight = (int)size.getHeight();
        
        try{
            // the line that reads the image file
            BufferedImage mazeImage = ImageIO.read(new File("C:/Users/d-sch/Desktop/Tesseract Kram/inputpic2.jpg"));

            

            imwidth          = mazeImage.getWidth();
            imheight         = mazeImage.getHeight();

            System.out.println("(imwidth,imheight)= ("+imwidth+","+imheight+");"+"(rewidth,reheight)= ("+rewidth+","+reheight+");");
            
            
            Graphics2D g2d = mazeImage.createGraphics();
            g2d.setColor(Color.BLACK);
            BasicStroke bs = new BasicStroke(2);
            g2d.setStroke(bs);
            g2d.setPaint(Color.BLACK);
            g2d.setFont(new Font("TimesRoman", Font.PLAIN, 18));
            
            
            g2d.fillRect(reToimX(0),reToimY(0), reToimX(rewidth), reToimY(9+griddist));
            g2d.fillRect(reToimX(0),reToimY(0), reToimX(9+griddist), reToimY(reheight));

                                                        
            // draw the black vertical and horizontal lines
            //vertical lines
            for(int x=9;x<rewidth;x=x+griddist){
                g2d.setPaint(Color.BLACK);
                g2d.drawLine(reToimX(x),reToimY(1),reToimX(x),reToimY(reheight-1));
                System.out.println("x-linie bei "+x);
                if((x%(2*griddist))==9){
                    g2d.setPaint(Color.WHITE);
                    g2d.drawString(""+x, reToimX(x-1), reToimY(9+griddist));
                }
            }
            
      g2d.setPaint(Color.WHITE);
            //horizontal lines
            for(int y=9;y<reheight;y=y+griddist){
                g2d.setPaint(Color.BLACK);
                g2d.drawLine(reToimX(1),reToimY(y),reToimX(rewidth-1),reToimY(y));
                System.out.println("y-linie bei "+y);
                if((y%(2*griddist))==9){
                    g2d.setPaint(Color.WHITE);
                    g2d.drawString(""+y, reToimX(5), reToimY(y-1));
                }
            }
            
            
            /*
            for(int i=0;i<21;i++){
             g2d.drawLine((imgDim.width+2)*i, 0, (imgDim.width+2)*i,  imgDim.height-1);
             g2d.drawLine(0, (imgDim.height+2)*i, imgDim.width-1, (imgDim.height+2)*i);
            }
            */
            
            File outputfile = new File("output.jpg");
            ImageIO.write(mazeImage, "jpg", outputfile);
        
        }
        catch(Exception e){}
    
        
    }
    
    public static void main (String[] args){
        DrawTest part=new DrawTest();
    }
    
    public int reToimX(int rex){
        int x=(int)((1.0*rex/rewidth)*imwidth);
        return x;
    }
    
    public int reToimY(int rey){
        int y=(int)((1.0*rey/reheight)*imheight);
        return y;
    }


    
}

Scheint es auf den ersten Blick mal soweit zu tun.
Ich mache einen Screenshot, lasse das programm laufen und erhalte mein Bild mit dem Raster drüber 🙂

Kann ich dann in aller Seelenruhe die Koordinaten bildlich ablesen.
Hofe nur dass die Umrechnung von "realen" koordinaten in Bildkoordinaten so richtig ist :-/

 

[berndoa]

du kannst über F12 im browser dir die elemente ausgeben lassen in welcher position diese im DOM sind
zb

dann lässt du dir zb durch javafx webview dir eine ansicht bauen ( muss ja nicht sichtbar sein ) oder anders
und dann von deiner gebauten ansicht sagst du "gib mir canvas3 koordinaten" da deine ansicht immer passend ist und nicht vom browser abhängig ist könnte es vllt so funtkionieren

womit genau meisnt du da, dass ich das ablesen könnte?

konkret würde ich bspw. auf einer Seite vom online roulette wie dieser:

European Roulette

oddsmatrix-static.casinomodule.com

gerne wissen an welcher Position (idealerweise gleich mit eingerechneter bildschirmskalierung)
sich bspw. die 28 befindet, wo deren Mittelpunkt so ist.

Bisher komme oich beim Objekte "Untersuchen" nur soweit dass das Ganze Teil da eine riesige Canvas ist.
Aber komme nicht explizit an die einzelne Rot, Null, Drehen, etc. Taste dran :-/

 

[Oneixee5]

Canvas ist ein grafisches Element, wie ein Bild. Es hat aber weitere Eigenschaften, mit denen man darauf zeichnen oder Events verarbeiten kann. Ein Canvas existiert zwar im DOM aber stellt selbst keine Elemente für DOM zur Verfügung.
Ich könnte mir ein Browser-Plugin vorstellen, wenn das "älteres Programm" ein Browser ist bzw. einbindet. Diese stellt dann alle Informationen z.B.: per localhost - REST bereit. Diese Infos könnte dann eine Anwendung nutzen. In den Infos könnten dann u.a. Position und Größe des Browsersfensters enthalten sein.