Probleme mit Zeichenprogramm

[Kerberus]

Ich schreibe für meine Maturarbeit ein spezialisiertes Zeichenprogramm. Leider tretten dabei ein paar kleine Probleme auf. Wenn ich eine neue Zeichenfläche erstelle und diese dann verschiebe gibt es Darstellungsprobleme. Es sieht fast so aus, als werde die "Zeichnung" verschoben. Weiss jemand an was das liegen könnte?

Die Jar-Datei kann unter
http://www.osmaur.ch/nico/java/
herunter geladen werden.

Bis jetzt funktioniert erst das Rechteck-Tool. (Das zweite von rechts in der Toolbar.)
Leider werden die Grafiken nicht angezeigt. Wie kann ich diese in einer Jar-Datei laden?

 

[Beni]

Sobald ich dein Prog starte, saugt die VM 99% meiner CPU ab. Arbeitest du mit Multithreading? Vielleicht eine Endlosschlaufe? So richtig angucken kann ich das so nicht...

Fügst du das "Canvas" mehrmals ein? Eine Component kann nur eine einzige Parent-Component haben.
Und AWT & Swing nicht mischen!

 

[bummerland]

Sobald ich dein Prog starte, saugt die VM 99% meiner CPU ab. Arbeitest du mit Multithreading? Vielleicht eine Endlosschlaufe? So richtig angucken kann ich das so nicht...

Bei mir auch... :roll: :cry:

 

[Kerberus]

Schliesse mal die Preview. Dann sollte der RAM-Verbrauch stark abnehmen.
Ja. Ich arbeite mit Multithreading und Swing unt AWT mische ich auch nicht.

 

[Beni]

Dieser Code verursacht etwa dasselbe Problem:

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;

import javax.swing.JDesktopPane;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;

public class Main {
	public static void main (String args[]) {

		JDesktopPane desktop = new JDesktopPane();
		JInternalFrame jif = new JInternalFrame( "test", false, false );
		jif.getContentPane().add( new JScrollPane( new Paint() ));
		jif.setSize( 200, 200 );
		
		desktop.add( jif );
		
		jif.show();
		
		JFrame frame = new JFrame();
		frame.getContentPane().add( desktop );
		frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
		frame.setSize( 500, 500 );
		frame.setLocationRelativeTo( null );
		frame.setVisible( true );
	}
}

class Paint extends JPanel{
	public Paint(){
		setPreferredSize( new Dimension( 300, 300 ) );
	}
	
	protected void paintComponent( Graphics g ) {
        Graphics2D d2 = (Graphics2D)g;
        d2.setColor(new Color(255, 255, 255));
        d2.fillRect(0, 0, getWidth(), getHeight() );
        d2.setColor(new Color(0, 0, 0));
        
        AffineTransform transa = new AffineTransform();
        double rotat = 0;
        
        float a = 10, b = 10, c = 50, d = 50;
        
        transa.rotate(rotat, a + c / 2, b + d / 2);
        d2.setTransform(transa);
        d2.draw(new Rectangle2D.Float(a, b, c, d));
        transa.rotate(-rotat, a + c / 2, b + d / 2);
        d2.setTransform(transa);
	}
}

Ich hab eine Version ohne das "AffineTransform" geschrieben, und dann gabs keine Probleme mehr:

	protected void paintComponent( Graphics g ) {
        Graphics2D d2 = (Graphics2D)g;
        d2.setColor(new Color(255, 255, 255));
        d2.fillRect(0, 0, getWidth(), getHeight() );
        d2.setColor(new Color(0, 0, 0));
        
     //   AffineTransform transa = new AffineTransform();
        double rotat = 0;
        
        float a = 10, b = 10, c = 50, d = 50;
        
        Graphics2D temp = (Graphics2D)d2.create();
        
        //transa.rotate(rotat, a + c / 2, b + d / 2);
        temp.rotate(rotat, a + c / 2, b + d / 2 );
        //temp.setTransform(transa);
        temp.draw(new Rectangle2D.Float(a, b, c, d));
	}

Aber eine Erklärung, wieso das so ist, kenn ich nicht.


P.S. Eine Frage über OOP: Wer sollte zeichnen? Das Panel, welches eigentlich keine Informationen über Rechtecke, Ellipsen, etc... hat, oder sollten diese Objekte sich selbst zeichnen? Wenn man noch ein praktisches Interface macht, muss das Panel nichteinmal mehr wissen, was es zeichnet... (nur eine Anregung, es sieht auf den ersten Blick komplizierter aus, aber es beim zweiten Blick wirds einfacher :wink: )

 

[Kerberus]

Nun dieser Code sieht meinem ziemlich ähnlich, wenn nicht schon fast gleich Decompiliert?

Falls ja: Vielleicht hast du gesehen, dass jedes OwnJPanel eine eigene Speicherverwaltung besitzt. (Habe dies als nötig erachtet, weil ich mehrere Zeichenflächen auf einmal verwalten möchte.) Mit diesem System kann ich im CanvasChooser eine Zeichenfläche auswählen und dann direkt exportieren.
Mit deiner Idee müsste ich ja im Hauptthread eine Speicherverwaltung haben, die alle Daten zu allen Zeichenflächen speichert, oder?

Noch eine Frage: Sollte ich jede Zeichenfläche als eigenen Thread laufen lassen und sobald sie den Fokus verliert die Priorität auf ein Minimum setzten? Kann ich damit Arbeitsspeicher sparen oder würde noch mehr verbraucht werden?


Bewirkt rotate() das gleiche, wie wenn ich mit AffineTransform drehe?

 

[Beni]

Nun dieser Code sieht meinem ziemlich ähnlich, wenn nicht schon fast gleich Decompiliert?

Falls ja: Vielleicht hast du gesehen, dass jedes OwnJPanel eine eigene Speicherverwaltung besitzt. (Habe dies als nötig erachtet, weil ich mehrere Zeichenflächen auf einmal verwalten möchte.) Mit diesem System kann ich im CanvasChooser eine Zeichenfläche auswählen und dann direkt exportieren.
Mit deiner Idee müsste ich ja im Hauptthread eine Speicherverwaltung haben, die alle Daten zu allen Zeichenflächen speichert, oder?

Ich wollte was anderes sagen:

Am Beispiel des Rechteckes: jetzt speicherst du die Daten in einem Vector, den du später wieder ausliest.

        interne_daten_verwaltung.addElement("r");
        interne_daten_verwaltung.addElement(x_1.getText());
        interne_daten_verwaltung.addElement(y_1.getText());
        interne_daten_verwaltung.addElement(width.getText());
        interne_daten_verwaltung.addElement(height.getText());

Du könntest auch eine Klasse "Rechteck" schreiben, welche diese Daten speichert. Dann kann man die so setzen:

  interne_daten_verwaltung.addElement( new Rechteck( x, y, w, h, filled, [... etc] ));

Wenn du noch ein Interface "Paintable" machst:

public interface Paintable{
  public void paint( Graphics g );
}

Und "Rechteck" etwa so aufbaust:

public class Rechteck implements Paintable{
  private double x, y, w, h;

  [... etc... ]

  public void paint( Graphics g ){
    g.drawRect( x, y, w, h );
  }
}

Dann wird der KTEXParser fast überflüssig, weil seine "parse"-Methode noch etwa so aussieht:

public void parseKTEX(Vector v, Graphics g){
  for( int i = 0; i < v.size(); i++ )
    ((Paintable) v.get(i) ).paint( g );
}

Der Vorteil? Das Rechteck ist eine abgeschlossene Einheit, wenn Du noch was daran ändern musst, dann musst du nur im Rechteck was ändern.
Und: neue Figuren sind einfacher herzustellen, weil auch diese nur eine neue Klasse brauchen.

Noch eine Frage: Sollte ich jede Zeichenfläche als eigenen Thread laufen lassen und sobald sie den Fokus verliert die Priorität auf ein Minimum setzten? Kann ich damit Arbeitsspeicher sparen oder würde noch mehr verbraucht werden?

Ich hab zwar noch nicht durchblickt, wieso du Threads benötigst, aber ob du jetzt 1 Thread oder 10 hast, macht noch keinen Unterschied (wenns dann zuviele werden wird viel CPU-Zeit nur für die Organisation dieser Threads versoffen).

Bewirkt rotate() das gleiche, wie wenn ich mit AffineTransform drehe?

Ich hoffe es :? . Und wenn man einen Winkel != 0 eingibt, rotiert das Bild jedenfalls...

 

[Kerberus]

Hmm. Das mit der eigenen Rechteck-Klasse muss ich wirklich einbauen, glaub ich. Danke für den Tipp
Damit würde das Speichern der Datei auch sehr viel einfacher werden. Bis jetzt (in einer kompletten Beta-Version die ich schon geschrieben habe) war die Speicher und die Lade-Routine über eine A4-Seite lang (ohne Kommentare).

Werde mal einige Änderungen an meinem Programm vornehmen
(Damit ich später effektiv mit dem Programm arbeiten kann, muss es relativ perfekt sein. Denn leider ist das Programm nur die Hälfte meiner Maturarbeit.)

 

[Kerberus]

Was mit gerade aufgefallen ist:
double zu verwenden macht kein Sinn, denn es können ja nur komplette Pixel ausgewählt werden.
Ausser bei der Rotation muss double verwendet werden.[/code]

 

[Beni]

Kommt drauf an, wenn Du das als Vektorgraphik auffasst, gibt es keine "echte" Grösse des Bildes. Dann sollte man einfach das genauste nehmen, was man hat :wink:

 

[Kerberus]

Ok, wenn ich rotate() verwende geht alles perfekt.
Leider habe ich immer noch einen hohen Speicherverbrauch durch "Preview", der praktisch das ganze Programm lahm legt. Nur, wenn ich mit meinem 1.5 GB RAM Computer arbeite, erhalte ich eine akzeptable Leistung.

 

[bummerland]

also bei meinem 1 GB ist der rechner total "abgekackt"...

 

[Kerberus]

Liegt sicher nicht nur am RAM.
Habe einen Doppelprozessorrechner. 2* 1.8GHz G5

 

[Beni]

Ist zwar ein anderes Thema, aber ich bin gerade draufgestossen:

    public void internalFrameClosing(InternalFrameEvent e)
    {
        if(runner != null)
            runner = null;
    }

Du hast vielleicht einen Thread der noch im System rumgurckt, weil du damit den Thread ja eigentlich nicht abschaltest. (Ich weiss nicht, wie sich der Garbage-Collector bei einem Thread verhaltet).


Zum Topic: du erstellst alle 250 Millisekunden ein neues Image, ich vermute, das zerrt an der Leistung.
Wieso benutzt du da überhaupt einen Thread? Eigentlich muss man ja nur dann die Prewiev neu herstellen, wenn sich tatsächlich was verändert. (Stichwort "Listener implemtieren", steht irgendwo in der FAQ).

 

[Kerberus]

@Beni So, habe deinen Rat befolgt und einen Listener implementiert. Funktionierte alles perfekt. Nur leider wurde dadurch die CPU-Auslastung nicht reduziert. Wenn man die PreviewCanvas allerdings mit setVisible(false) verschwinden liess, senkte diese sich von knapp 100% auf ca 5%
Das hat mich auf die Idee gebracht, dass es sein könnte, dass die Canvas periodisch neu gezeichnet wird, vom System oder von was auch immer. Daher habe ich einen boolean-Wert integriert, der mir sagt, ob mein Listener das Neu-Zeichnen veranlasst hat, oder das System, etc. Des weiteren habe ich noch ein weiteres BufferedImage-Objekt erstellt, welches mir als Puffer dient. Somit konnte ich die CPU-Auslastung auf konstante <10% senken. Nur beim Starten des Programmes steigt diese kurz auf 100% an, weiss jedoch noch nicht warum.