# Programm sehr langsam. Windows 7?



## FaceToFace (9. Feb 2010)

Grüß Gott.
Ich habe hier im Forum ein Programm gefunden, dass ein Fenster nachzeichnet, dafür aber immer nur die Farbe von einem Pixel ermittelt und diese dann überträgt. Nun habe ich aber ein sehr seltsames Problem: Das Programm läuft unter Windows 7(64-bit), bzw Vista(32-bit) extrem langsam. Es benötig für jede Zeile zu je 30 Pixeln ca 5 sec. Dies ist wirklich sehr lang, da ich für 300 Zeilen dann sehr lang brauche. Bei einem anderen PC ist das aber nicht so: Er hat Windows XP(32-Bit) und einen Pentium 4 mit 3,00 GHz. Er benötigt für das ganze Bild(diesmal 300*400) nur 20 Sekunden. Der andere Computer hat aber einen Core i5 und der sollte rein theoretisch schneller als ein P4 sein . Also meine frage: Liegt es nun am Betriebssystem, oder an meiner Java-Version(sollte die neueste sein)?. Kann mir das echt nicht erklären.

Hier aber erstmal das Programm. Es funktioniert nur am Anfang dauert es auch ein bisschen. Wäre auch nett wenn ihr es probieren könntet und vll Betriebssystem + Zeit(muss nicht fürs ganze Bild sein) angeben könntet:


```
import java.awt.*;
/**
 * Beschreiben Sie hier die Klasse Test.
 *
 * @author (Ihr Name)
 * @version (eine Versionsnummer oder ein Datum)
 */
class CrappyDrawTest extends Frame
{
 public static void main(String[] args)
    {
        CrappyDrawTest t = new CrappyDrawTest();
    }
 
    CrappyDrawTest()
            {
 
            super("Kleiner Screen");
            setLayout(new FlowLayout());
            setSize(500,400);
            setLocation(200,100);
            getMinimumSize();
            this.show();
           }
 
   public void paint(Graphics g)
   {
        int x = 1, y = 1;
        while(y <= 400)
        {
            try
            {
                //Ermitteln der Pixelfarbe
                Robot rob = new Robot();
                Color clr = rob.getPixelColor(x, y);
                System.out.println(y +" " + x + clr);
                g.setColor(clr);
            }
            catch(Exception e)
            {
                System.out.println(e);
            }
            //Zeichnen
            g.fillRect(x,y, 1, 1);
            x++;
            if(x > 30)
            {
                y++;
                x=1;
            }
        }
    }
}
```

mfg Face


----------



## eRaaaa (9. Feb 2010)

Okay zwei Sachen

a) du erstellst bei jedem Pixel einen neuen Robot...erstelle den einmal und gut ist(das könnte es auch schon gewesen sein, ansonsten muss man mal weiter schauen)
also
	
	
	
	





```
Robot rob=null;
	try {
	    rob = new Robot();
	} catch (AWTException e1) {
	    e1.printStackTrace();
	}
	while (y <= 400) {
//hier dann die Schleife ohne Robot rob = new Robot();
//...
}
```
/edit: noch besser wahrscheinlich wäre es das ganze nicht in der paint-Methode zu machen?!

b) hat nichts mit dem Problem zu tun, aber this.show() ist deprecated, benutze 
	
	
	
	





```
this.setVisible
(true);
```

c) mal ne andere Frage: wieso benutzt du nicht die Methode createScreenCapture() und packst das BufferedImage in ein JLabel oder so ?!

```
public class CrappyDrawTest extends JFrame {
    JLabel label;
    JPanel panel;

    public static void main(String[] args) {
	new CrappyDrawTest();
    }

    CrappyDrawTest() {
	super("Kleiner Screen");
	setLayout(new FlowLayout());
	getMinimumSize();
	label = new JLabel();
	panel = new JPanel();
	add(panel);
	setDefaultCloseOperation(EXIT_ON_CLOSE);
	setLocationRelativeTo(null);
	// Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
	// int x = (int) d.getWidth();
	// int y = (int) d.getHeight();
	paintWindow(400, 200);
	pack();
	setVisible(true);
    }

    private void paintWindow(int x, int y) {
	BufferedImage bi = null;
	try {
	    bi = new Robot().createScreenCapture(new Rectangle(x, y));
	} catch (AWTException e) {
	    e.printStackTrace();
	}
	label.setIcon(new ImageIcon(bi));
	panel.add(label);
    }
}
```


----------



## FaceToFace (9. Feb 2010)

Ich habe den Bot nun umgeändert und es geht nun etwas schneller, aber immer noch kein Vergleich zum anderen Computer. Wie soll ich das ganze nicht in der Paint-Methode machen? Ich weiß es gibt viel einfachere und bessere Methoden, aber ich will nur wissen warum das auf dem XP-Computer viel schneller rennt, als auf dem Windows7/Vista Computer..

mfg


----------



## Gast2 (9. Feb 2010)

Habs mal mit laufen lassen:

Windows Vista 32Bit, 2 GB RAM, 1,8GHz Core2Duo - Needed 239304 milliseconds ~ gut 4 Minuten für die 400 Zeilen.


----------



## FaceToFace (9. Feb 2010)

Bei mir dauert es gute 7 Minuten für die 400 Zeilen mit je 30 Pixel... Aber die CPU Auslastung ist aber immer bei 5%...

@eRaaaa:
zu c): Weil ich eig nur die Geschwindigkeit vergleichen will. Und das geht damit im Moment am besten. Und das Ergebnis ist nun, dass es bei einem XP-Computer um 6,5 Minuten schneller geht . Ich denke es liegt an Windows. Ich muss später nämlich Programme schreiben die viel berechnen und auch Zeit brauchen... wie sollen die dann gehen, wenn selbst dieses Programm so langsam läuft?

Gibt es sonst noch andere Programme mit denen ich die Geschwindigkeit berechnen kann(in Java)? Vielleicht ist es ja nur bei diesem einen Programm...

mfg


----------



## Murray (9. Feb 2010)

Wie lasst ihr das Programm laufen? In Eclipse? Oder von der Kommandozeile aus? Mir scheint nämlich das System.out.println() der limitierende Faktor zu sein (ohne wird es bei mir erheblich schneller) - und das würde sich in einer IDE, die die Konsolenausgaben in irgendeiner Form verarbeitet, möglicherweise anders auswirken als beim Start direkt von der Kommnadozeile aus.


----------



## FaceToFace (9. Feb 2010)

Ich habe das s.o.pln schon weggelöscht, aber so viel unterschied ist da nicht...

Ich führe esmit BlueJ aus oder als Jar Datei.. Beide das selbe Ergebnis...

mfg


----------



## Gast2 (9. Feb 2010)

Ich hatte es in Eclipse 3.5/jdk 1.6.0_14 gestartet


----------



## Murray (9. Feb 2010)

Mach dir doch mal 'ne Ausgabe in die paint Methode:

```
public void paint(Graphics g)
   {
   	
   	long t0 = System.currentTimeMillis();
          /* jetzt der ganze Rest */
        System.out.println( "paint finished in " + (System.currentTimeMillis()-t0) + "ms");
   }
```
Was passiert? Ist die paint-Methode so langsam, oder wird sie sehr oft aufgerufen?


----------



## FaceToFace (9. Feb 2010)

Da steht dann: paint finsihed in 323250ms rund 5 Minuten....

Das gibts doch nicht! CPU Auslastung bei 2 %...

mfg


----------



## Murray (9. Feb 2010)

Seltsam - bei mir (Win XP, Pentium M 2GHz, Anwendung von der Kommandozeile aus gestartet) läuft die paint-Methode mit SysOuts in ca 7Sek, ohne SysOuts in etwa 250ms und mit Wiederverwendung des Robots in 60-150ms


----------



## FaceToFace (9. Feb 2010)

Hmm. Komisch....
Bei mr dauert jeder Pixel 31(!) Millisekunden.
Habe das Programm jetzt so umgeschriebe, das es einem die Millisekunden die das Programm für das Pixel gebraucht hat, ausgibt.

```
import java.awt.*;
/**
 * Beschreiben Sie hier die Klasse Test.
 *
 * @author (Ihr Name)
 * @version (eine Versionsnummer oder ein Datum)
 */
class CrappyDrawTest extends Frame
{
 public static void main(String[] args)
    {
        CrappyDrawTest t = new CrappyDrawTest();
    }
 
    CrappyDrawTest()
            {
 
            super("Kleiner Screen");
            setLayout(new FlowLayout());
            setSize(200,400);
            setLocation(200,100);
            getMinimumSize();
            this.setVisible(true);
           }
 
   public void paint(Graphics g)
   {
       long t0 = System.currentTimeMillis();
       try
        {
            //Ermitteln der Pixelfarbe
            Robot rob = new Robot();                
        }
        catch(Exception e)
        {
            System.out.println(e);
        }
        int x = 1, y = 15;
        while(y <= 400)
        {
            long te = System.currentTimeMillis();
            try
            {
                //Ermitteln der Pixelfarbe
                Robot rob = new Robot();
                Color clr = rob.getPixelColor(x, y);
                
                g.setColor(clr);
            }
            catch(Exception e)
            {
                System.out.println(e);
            }
            //Zeichnen
            g.fillRect(x,y, 1, 1);
            x++;
            if(x > 30)
            {
                y++;
                x=1;
            }
            long dif = System.currentTimeMillis() - te;
            System.out.println("Dieser Pixel dauerte " + dif + "ms");
        }
        System.out.println( "paint finished in " + (System.currentTimeMillis()-t0) + "ms");
    }
}
```

Ich denke es liegt wirklich an XP bzw Vista/7...
Können es vielleicht noch mehr testen?

mfg


----------



## eRaaaa (9. Feb 2010)

Also du hast ja in Zeile 45 immer noch den Robot drin?! (Deine Schleife(n) sieht eig. auch sehr komisch aus  )

Wie sieht es denn mit diesem relativ schlanken Programm aus? Hast du damit auch Probleme unter Windows Vista & / ?


```
import java.awt.AWTException;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Robot;
import java.awt.image.BufferedImage;

import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class CrappyDrawTest {

    public static void main(String[] args) throws AWTException {
	BufferedImage image = new BufferedImage(30, 400,BufferedImage.TYPE_INT_RGB);
	Graphics g = image.getGraphics();
	Robot rob = new Robot();
	long te = System.currentTimeMillis();
	for (int i = 0; i < image.getHeight(); i++) {
	    for (int j = 0; j < image.getWidth(); j++) {
		g.setColor(rob.getPixelColor(j, i));
		g.fillRect(j, i, 1, 1);
	    }
	}
	System.out.println( "paint finished in " + (System.currentTimeMillis()-te) + " ms");
	JFrame frame = new JFrame();
	JPanel panel = new JPanel();
	panel.add(new JLabel(new ImageIcon(image)));
	frame.add(panel);
	frame.pack();
	frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	frame.setLocationRelativeTo(null);
	frame.setVisible(true);
    }
}
```
Läuft bei mir zwischen 200 und 300 ms


----------



## FaceToFace (9. Feb 2010)

WEnn du das Programm meinst, dass du mir geschrieben hast: Ja das funktioniert gut^^

Stimmt den habe ich noch nicht weggelöscht . Aber wenn ich ihn nun wegllösche seht dann: Cannot find variable rob.

Obwohl ich über der Schleife habe:

```
try
        {
            //Ermitteln der Pixelfarbe
            Robot rob = new Robot();                
        }
        catch(Exception e)
        {
            System.out.println(e);
        }
```
Ich verstehs grad nicht??

mfg


----------



## eRaaaa (9. Feb 2010)

```
Robot rob=null;
    try {
        rob = new Robot();
//......
```

.......:autsch:


----------



## FaceToFace (9. Feb 2010)

Gut so gehts.
Aber die Zeit proPixel beträgt immer noch 30 ms...

Liegt wohl irklich an Windows.

mfg


----------



## Ausnahmsweise (9. Feb 2010)

Ist die Aero-Oberfläche an oder aus?


----------



## FaceToFace (9. Feb 2010)

Ich denke mal an.
Wie schaltet man das denn ab?


----------



## Gast2 (9. Feb 2010)

Sieht so aus als ob es an Aero liegt.

Ohne Aero: Needed 1074 milliseconds
Mit Aero: Needed 229102 milliseconds

Ist ja spannend... Ich hab jetzt bei beiden Runs den Code aus dem ersten Posting genommen und nur noch die Zeitmessung in die eingefügt.

Am einfachsten kannst du AERO deaktivieren indem du bei "Designs" -> "Windows klassisch" aussuchst.


----------



## FaceToFace (9. Feb 2010)

Vielen Dank. Ohne Aero geht es vedammt viel schneller.

Aber wen ich die Anwedung weiter send, muss derjenige auch sein Aero deaktivieren und dannausführen... Schlecht gemacht wer auch immer 

mfg


----------



## Cola_Colin (9. Feb 2010)

createScreenCapture() geht zuminest mit Windows 7 x64 auch mit Aero im Bruchteil einer Sekunde, das auslesen der Pixel aus dem BufferedImage ist dann sicher schneller als das abfragen der Pixel vom Robot


----------



## _Moe_ (20. Feb 2010)

Erstmal danke für die Vorarbeit. Ich arbeite gerade auch mit getPixelColor() und hab gestaunt, als ich von meinen Rechnern (zwei mal WinXP) auf die beiden Win7 von nem Kumpel umgestiegen bin und geflucht, wieso das da nicht geht.
Mir dann auf den (schnellen) Lappi Win7 drauf gemacht und er braucht halt echt lange...

Danke auch für die Tips mit den Work-Arounds: Sobald ich zeit hab, mach ich das mit dem Screene.

VG


----------



## Cybercooperation (20. Feb 2010)

wollte nur auch mal was zu sagen:

also erstmal dauert bei mir ein pixel ca. 15-20mili sek. (Ubuntu, Medion-Netbook 1GB RAM, 2x 1.60GHz)

insgesammt (glaub ich) 1811 (oder 18111?) oder so....


aber ich find das interessant das die anwendung auf verschiedenen pcs unabhängig von der eigentlichen leißtung unterschiedlich läuft. kann mir das mit meinen sachen auch probieren?
wie kann man das möglichst umgehn?:rtfm:


----------



## Onkel Hatti (20. Feb 2010)

Ich hab das Programm auch ausprobiert und hatte ein bischen darn gespielt, aber auf bessere Werte als 25ms/Punkt kam ich auch nicht.
Gerade in so einem Fall denke ich, man kann das Programm nur mit einem Profiler bearbeiten und sich für langsame Abläufe einen effizienteren Code einfallen lassen. 
Ich hab mal nen Datenbank-Programm gemacht und mir für eine Abfrage einen wunderbaren View gestrickt. Der dauerte dann aber in der Abfrage immer 2 s. Auch die SELECT Anweisung direkt dauerte mir zu lange. Es ging dann am schnellsten, indem ich die betroffenen Tabellen einzeln abgefragt habe und sie in meinem Programm selbst zusammengesetzt habe, so das das gewünschte Ergebnis kam.

Hatti


----------

