Methoden werden in falscher Reihenfolge bearbeitet

M

mac21

Aktives Mitglied
Hallo zusammen,

da ich an einem Projekt zum Einlesen von Fahrzeugscheinen arbeite (Stichwort "OCR")
habe ich folgende Klassen in einem Projekt, achtet auf die Kommentare.
Das ist KEIN fertiger Code, ich habe Unnötiges herausgelöscht, damit ihr nicht so viel lesen müsst.

Java: 
public class TestApp( ) {
		
	public String[] doOCR() {
		
		waitingScreen waitingScreen;	//Deklaration
		waitingScreen = new waitingScreen(); //Initialisierung
		
	
		for (int i = 0; i < Settings.FIELDS; i++) { //in Settings.java liegen nur Konstanten
		
		inputFile = Settings.CROPPEDPATH + Settings.CROPPEDFILE + i + "."
				+ Settings.CROPPEDFORMAT; //erzeugt einen Pfad zur Eingabe-Datei
		outputFile = Settings.TEMPPATH + Settings.TEMPNAME + i + ".xml"; //Erzeugt einen Pfad zur Ausgabe-Datei

		args = new String[] { inputFile, outputFile }; //beide Pfade in einen String packen
		argList = new Vector<String>(Arrays.asList(args)); //In Vector konvertieren (gibt die OCR-API so vor

		try {
			performTextFieldRecognition(argList); //Eingabe-Datei(ein Bild) wird per OCR eingelesen und in die XML (Ausgabedatei) geschrieben
		} catch (Exception e) {
		
		}
		results[i] = XMLreader.read(outputFile, "value"); //Wert dieser Datei wird im Array results gespeichert
	} 
	return results;	//gibt das Array zurück
	}
}

und

waitingScreen.java ist nur ein JFrame mit einem nicht endenden Fortschrittsbalken.
Java: 
public class waitingScreen extends JFrame{

	JProgressBar progressBar;
	final Dimension dim;
	
	public waitingScreen() {
		
		this.setTitle("Verarbeite...");
		this.setSize(400, 80);
		
		JFrame.setDefaultLookAndFeelDecorated(false);
		this.setUndecorated(true);
		this.setAlwaysOnTop(true);
		dim = Toolkit.getDefaultToolkit().getScreenSize();
		this.setLocation((int) ((dim.getWidth() - this.getWidth()) / 2),(int) ((dim.getHeight() - this.getHeight()) / 2));
		this.setResizable(false);;
		this.setLayout(null);
		this.setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
		this.setVisible(true);
		
		progressBar = new JProgressBar();
		progressBar.setSize(this.getWidth(), this.getHeight());
		progressBar.setIndeterminate(true);
		
		this.add(progressBar);
		
	}
	
}


Nun endlich zu meinem Problem:
Nach dem ich die Methode "doOCR()" der Klasse "TestApp" aufgerufen habe, wird zuerst der ganze OCR-Vorgang ausgeführt, und nach einigen Minuten (also wenn dieser Vorgang beendet ist) öffnet sich die Fortschrittsanzeige.

Wieso ist das so?
Sind diese Vorgänge nebenläufig, und der OCR-Vorgang hat eine höhere Priorität als das Anzeigen des waitingScreens?


Folgendes habe ich auch schon versucht, SuFu sei dank:

Erzeugen des waitingScreens erfolgt über eine Statische Methode, welche einen boolean liefert, wenn sie erfolgreich beendet wurde.

Der OCR-Vorgang wird erst gestartet, wenn die o.g. Methode "true" liefert.

Also in etwa

Java: 
while(!waitingScreen.isReady) {
//tut nichts
}

OCR-Vorgang
 
Zuletzt bearbeitet:
Das passiert, wenn du die OCR Aufgaben im UI Thread laufen lässt.
Erst wenn dieser nämlich fertig ist, kann er die Änderungen an der UI anzeigen (z.B. deine Progressbar)

Verwende also für GUI Aufgaben wie das Erstellen des Fensters ein solches Konstrukt:

Java: 
EventQueue.invokeLater(new Runnable() { 
  @Override
  public void run() {
     // dein GUI Code
  }
});
 
Hallo Anti-Held,

vielen Dank für die schnelle Antwort!

Ich füge hier noch einmal die komplette Klasse "GUI" an (ganz unten an dieser Antwort).
Am Ende der Klasse habe ich einige ActionListener eingebaut, diese rufen im Endeffekt die Methode "OCRtool.doOCR()" auf. OCRtool ist ein Interface mit nur einer Methode, da ich noch am experimentieren bin, welche OCR-API ich verwende.

Nun stellt sich mir die Frage, wo ich deinen Code einfügen+anpassen muss...
Sämtlicher Code in der Klasse "GUI" baut die Oberfläche,
dann wird die Interface-Methode aufgerufen,
woraufhin wieder eine grafische Komponente angezeigt wird (der waitingScreen).

Java: 
package de.systeccomputer.ocr;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FocusTraversalPolicy;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileNotFoundException;

import javax.imageio.ImageIO;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.WindowConstants;
import javax.xml.stream.XMLStreamException;

public class GUI {
//########## Attributes ###################################
	BufferedImage scan;
	JButton[] editButtons;
	JFrame mainFrame;
	JPanel correctPanel;
	public JPanel editPanel;
	ImagePanel scanPanel;
	JTextField[] correctFields;
	JTextArea[] correctAreas;
	JComponent[] order;
	OCRinterface OCRtool;
	JFrame logFrame;
	JTextArea logArea;

//######### Constructor ###################################		
	public GUI() throws FileNotFoundException, XMLStreamException {
		
		initComponents();
		initTabOrder();
		addComponents();	
		initListeners();
		//createLogDialog();		
	}
//######### Methods #######################################
	public void initComponents() {
		mainFrame = new JFrame("TestTitel");
		mainFrame.setSize(Settings.FRAMEWIDTH, Settings.FRAMEHEIGHT);
		final Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
		mainFrame.setLayout(null);
		mainFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		//mainFrame.setResizable(false);
		mainFrame.setLocation((int) ((d.getWidth() - mainFrame.getWidth()) / 2),(int) ((d.getHeight() - mainFrame.getHeight()) / 2));
		mainFrame.setVisible(true);

		try{
			scan = ImageIO.read(new File(Settings.FILEPATH));		
			}catch(Exception e){System.out.println("Problem beim Einlesen");}
		
		  scanPanel = new ImagePanel(mainFrame.getContentPane().getWidth()-100,(mainFrame.getContentPane().getHeight()/2), scan, this);
		  scanPanel.setSize(mainFrame.getContentPane().getWidth()-100,(mainFrame.getContentPane().getHeight()/2));
		  scanPanel.setLocation(0,0); 
		  scanPanel.setBorder(BorderFactory.createLoweredBevelBorder());
		  scanPanel.setVisible(true);
		  
		  correctPanel = new JPanel();
		  correctPanel.setSize(mainFrame.getContentPane().getWidth()-100,(mainFrame.getContentPane().getHeight()/2));
		  correctPanel.setLocation(0,(mainFrame.getContentPane().getHeight()/2+1));
		  correctPanel.setBackground(Color.BLUE);
		  correctPanel.setLayout(null);
		  correctPanel.setBorder(BorderFactory.createLoweredBevelBorder());
		  correctPanel.setVisible(true);
		  
		  editPanel = new JPanel();
		  editPanel.setSize(mainFrame.getContentPane().getWidth()-scanPanel.getWidth(),mainFrame.getContentPane().getHeight());
		  editPanel.setLocation(mainFrame.getContentPane().getWidth()-editPanel.getWidth(), 0);
		  editPanel.setBackground(Settings.EDITPANELCOLOR);
		  editPanel.setLayout(null);
		  editPanel.setBorder(BorderFactory.createLoweredBevelBorder());
		  editPanel.setVisible(true);
		
			 correctFields = new JTextField[65];
		 
		 int a = 0;
		 for(int i = 0; i < scanPanel.rectangles.length; i++) {
			 if(i != 4 && i != 27) {
			 correctFields[a] = new JTextField();
			 correctFields[a].setBounds(scanPanel.rectangles[i]);
			 correctFields[a].setVisible(true);
			 correctFields[a].setBorder(BorderFactory.createLineBorder(Color.black));
			 correctPanel.add(correctFields[a]);
			 a++;
			 }
		 }
		 
		 correctAreas = new JTextArea[2];
		 correctAreas[0] = new JTextArea();
		 correctAreas[0].setWrapStyleWord(true);
		 correctAreas[0].setBounds(scanPanel.rectangles[4]);
		 correctAreas[0].setVisible(true);
		 correctAreas[0].setLineWrap(true);
		 correctAreas[0].setBorder(BorderFactory.createLineBorder(Color.black));
		 correctPanel.add(correctAreas[0]);
		 
		 correctAreas[1] = new JTextArea();
		 correctAreas[1].setBounds(scanPanel.rectangles[27]);
		 correctAreas[1].setVisible(true);
		 correctAreas[1].setLineWrap(true);
		 correctAreas[1].setBorder(BorderFactory.createLineBorder(Color.black));
		 correctPanel.add(correctAreas[1]);
		 
		  editButtons = new JButton[3];
		  for(int i = 0; i < editButtons.length; i++) {
			  editButtons[i] = new JButton("Start");
			  editButtons[i].setSize(70, 16);
			  editButtons[i].setLocation(10, 60+i*Settings.BUTTONPADDING);
			  editButtons[i].setVisible(true);  
		  }
	}
//#########################################################
	public void addComponents() {	
		
		mainFrame.add(scanPanel); 
		mainFrame.add(correctPanel);
		mainFrame.add(editPanel);
		 for(int i = 0; i < editButtons.length; i++) {
		editPanel.add(editButtons[i]);
		 }
		try{
			mainFrame.repaint();			
		}catch(Exception es){}
	}
//#########################################################
		 public void initTabOrder() {
			 
			 order = new JComponent[Settings.FIELDS];
			 for(int i = 0; i < order.length; i++) {
				 if(i == 4) {
					 order[4] = correctAreas[0];
				 }else if(i == 27){
					 order[27] = correctAreas[1];
				 }else{
					 if(i < 4) {order[i] = correctFields[i];}
					 if(i > 4 && i <= 27) {order[i] = correctFields[i-1];}
					 if(i > 27) {order[i] = correctFields[i-2];}
				 }
			 }
			 
			  FocusTraversalPolicy policy = MyFocusTraversalPolicy.getFocusTraversal(order);
				    correctPanel.setFocusTraversalPolicy(policy);
				    correctPanel.setFocusCycleRoot(true);
		 }
//#########################################################
		 public void makeSubimages() {
			 //int fac = scanPanel.getFactor();
			 double facX = scanPanel.fakX;
			 double facY = scanPanel.fakY;
			 
			 for(int i = 0; i < order.length; i++) {
				 imgPart.parting(order[i].getX()*facX, order[i].getY()*facY, order[i].getWidth()*facX, order[i].getHeight()*facY, scan, i);
			 }
			 //imgPart.parting(scanPanel.rectangles[0].getX()*facX, scanPanel.rectangles[0].getY()*facY, scanPanel.rectangles[0].getWidth()*facX, scanPanel.rectangles[0].getHeight()*facY, scan);
		 }
//#########################################################
			public void setOCRtool(OCRinterface newOCRtool){
				this.OCRtool = newOCRtool;
			}
//#########################################################
			public OCRinterface getOCRtool(){
				return this.OCRtool;
			}
//#########################################################
			public void createLogDialog() {
				logFrame = new JFrame("Log:");
				logFrame.setVisible(true);
				//logFrame.setAlwaysOnTop(true);
				logFrame.setSize(300, 300);
				logFrame.setLayout(new BorderLayout());
				logFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
			    logArea = new JTextArea();
			    logArea.setEditable(false);
			    logArea.setLineWrap(true);
			    JScrollPane pane = new JScrollPane(logArea);
			    logFrame.add(pane);
		    }
//#########################################################
			public JTextArea getLogDialog() {
				return this.logArea;
			}
//#########################################################
		 public void initListeners() {
			 
				correctAreas[0].addKeyListener(new KeyListener() {
					
					@Override
					public void keyPressed(KeyEvent arg0) {

						if(arg0.getKeyCode() == 9) {
							arg0.consume();
							correctFields[4].requestFocus();
						}
					}
					
					@Override
					public void keyReleased(KeyEvent arg0) {}
					
					@Override
					public void keyTyped(KeyEvent arg0) {}
				});
				
				correctAreas[1].addKeyListener(new KeyListener() {
					
					@Override
					public void keyPressed(KeyEvent arg0) {

						if(arg0.getKeyCode() == 9) {
							arg0.consume();
							correctFields[26].requestFocus();
						}
					}
					
					@Override
					public void keyReleased(KeyEvent arg0) {}
					
					@Override
					public void keyTyped(KeyEvent arg0) {}
				});
		 
		editButtons[0].addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent arg0) {
							
				makeSubimages();
				String[] a = OCRtool.doOCR();
				
				for(int i = 0; i < Settings.FIELDS; i++) {
					if(i == 4) { 
						correctAreas[0].setText(a[4]);
					}else if(i == 27) {
						correctAreas[0].setText(a[27]);
					}else {
						if(i < 4) {correctFields[i].setText(a[i]);}
						 if(i > 4 && i <= 27) {correctFields[i-1].setText(a[i]);}
						 if(i > 27) {correctFields[i-2].setText(a[i]);}
					}
				}
			}
		 });
		 }			 
}

EDIT: In Eclipse sieht der Code besser aus, er tut zwar das gleiche, aber die Formatierung ist ja schrecklich^^
 
Zuletzt bearbeitet:
anti-held hat eigentlich schon gesagt was das Problem ist.
Seinen Code solltest do in der "doOCR" Methode einbauen, wenn du deinen "waitingScreen" aufrufen willst.

Noch zu deinem Code:
Java: 
waitingScreen waitingScreen;	//Deklaration
waitingScreen = new waitingScreen(); //Initialisierung
Diese zwei Zeilen kann man ruhig zu einer Zeile zusammenfassen. Vor allem wenn man mehrere lokale Variablen braucht kann es doch unübersichtlich werden.

Java: 
args = new String[] { inputFile, outputFile }; //beide Pfade in einen String packen
Dein Kommentar ist falsch. Du "packst" beide Strings in ein String Array 😉

Java: 
public class waitingScreen extends JFrame{

Klassennamen werden in Java in UpperCamelCase geschrieben.
Außerdem sollte man nicht von JFrame ableiten wenn man dessen Funktionalität nicht erweitern will.
 
Zuletzt bearbeitet:
Hallo Joose,

vielen Dank auch an dich.
Sofern ich das richtig verstanden habe (<--Fehler gefunden 😉 ) soll ich den Code so korrigieren:
(dieses Mal unbeschnitten)
Java: 
public String[] doOCR() {
		
		 
		EventQueue.invokeLater(new Runnable() { 
		  @Override
		  public void run() {
			  waitingScreen waitingScreen = new waitingScreen();
			waitingScreen.setVisible(true);
		  }
		});
				
		f = new File(Settings.TEMPPATH);
		f.mkdir();
	
		for (int i = 0; i < 1/**Settings.FIELDS*/; i++) {
		
		inputFile = Settings.CROPPEDPATH + Settings.CROPPEDFILE + i + "."
				+ Settings.CROPPEDFORMAT;
		outputFile = Settings.TEMPPATH + Settings.TEMPNAME + i + ".xml";

		args = new String[] { inputFile, outputFile };
		argList = new Vector<String>(Arrays.asList(args));

		try {
			performTextFieldRecognition(argList);
		} catch (Exception e) {
		
		}
		results[i] = XMLreader.read(outputFile, "value");
	} 
	return results;		
	}

Dies führt jedoch zum selben Ergebnis... erst die Abarbeitung des OCR-Vorgangs (Ein paar Zeilen erscheinen in der Konsole, nur zum Nachvollziehen) und DANN taucht mein WaitingScreen auf...

Apropos: 1. Danke für den Hinweis, bin immer dankbar für Feedback.
Normalerweise mache ich das auch richtig, ab und an unterläuft mit ein Fehler 😉 z.B. auch in "imgPart.java"
Anhang anzeigen 6914

2. Normalerweise trenne ich Deklaration und Initialisierung auch von einander,
"waitingScreen waitingScreen;" steht vor dem Konstrukivator ;D
"waitingScreen = new waitingScreen();" steht im Konstruktor

3. Dann verbessere ich mich: beide Pfade in ein String[] packen 😉

4. Also
Java: 
JFrame mainFrame = new JFrame()
mainFrame.set...
verwenden?
Merci, das war mir nicht bewusst.
 
Da ich gerade kein Eclipse zur Hand habe, nur unformatierten Beispielcode, wie es aussehen sollte:

Java: 
actionPerformend(...)
   final WaintingScreen waitingscreen = new WaintingScreen();
   waitingscreen.setVisible(true);
   new Thread(){
      public void run(){
          doOCR();
EventQueue.invokeLater(new Runnable() {
        public void run() {
            waitingscreen.dispose();
        }
    });
      }
   }.start();
 
Zuletzt bearbeitet:
Also mich würde mal interessieren wie das mit dem InvokeLater funktionieren soll. Wenn ich das richtig verstanden habe, dann macht der doch nichts anderes als die Swing UI auf einen eigenen EDT Thread zu packen und irgendwann zu starten. Damit kann ich doch keine Thread synchronisation hinbekommen. In dem Fall oben wird der EDT Thread sicher erst gestartet und das UI Aktualisiert wenn das OCR Ding durch ist oder?

Ich mache sowas immer mit einem SwingWorker, weil ich da auch direkt den Progress an den UI Thread weiterreichen kann zum anzeigen.

Gruß

Claus
 
Du bist mein (Anti-)Held,
und auch vielen Dank an Joose,

so klappt es perfekt!

Ich hoffe, ich habe es nun richtig verstanden:

Java: 
editButtons[0].addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent arg0) {
				
				final WaitingScreen waitingScreen = new WaitingScreen(); //Geschieht vor dem Thread, da dieser noch nicht erzeugt/gestartet wurde. 
				waitingScreen.setVisible(true); 
				   new Thread(){  //neuer anonymer Thread
					      public void run(){ //wird nach dem Starten des Threads ausgeführt
					    	  makeSubimages(); //zerlegt mein Bild in einzelne Bilder
					    	  resultStrings = OCRtool.doOCR(); //Das zurückgegebene String-Array wird in das lokale Array gespeichert
					EventQueue.invokeLater(new Runnable() { //EventQueue.invokeLater bedeutet, dass dieser Teil erst nach Abschluss der o.g. Run() ausgeführt wird?
					        public void run() {
					            waitingScreen.dispose(); //Fenster schließen
					            for(int i = 0; i < Settings.FIELDS; i++) { //der folgende Code schreibt die Werte aus dem String Array in TextFields und TextAreas
									if(i == 4) { 
										correctAreas[0].setText(resultStrings[4]);
									}else if(i == 27) {
										correctAreas[0].setText(resultStrings[27]);
									}else {
										if(i < 4) {correctFields[i].setText(resultStrings[i]);}
										 if(i > 4 && i <= 27) {correctFields[i-1].setText(resultStrings[i]);}
										 if(i > 27) {correctFields[i-2].setText(resultStrings[i]);}
									}
								}
					        }
					    });
					      }
					   }.start(); //Erst JETZT wird der Thread gestartet, durch diese Schreibweise reicht ein Anonymer Thread
						//sonst müsste ich schreiben: Thread thread = new Thread(){...}; thread.start();

			}
		 });
		 }

EDIT: Sry, die Formatierung ist echt für den A****
 
Zuletzt bearbeitet:
Ich persönlich würde die Synchronisierung "Fensteraufbau soll vor OCR geschehen" auch eher sicherstellen, indem ich die .repaint() überschreibe mit
Java: 
public void repaint()
{
  super.repaint() ;
  //
  if( isOcrJobWaiting() )
  {
    startOcrThread(); // nebenläufig, erledigt auch:
    // set_OcrThreadWaiting( false );
  } // end if
}

(Oder eben das OCR-Geschäft ganz in einen eigenen Thread auslagern, dann ist das Fenster gänzlich entkoppelt, und man kann explizit (z.B. mit booleans) synchronisieren, wann was startet/fertig ist/...)
 
Zuletzt bearbeitet:
Hallo arilou,

Das Fenster wird ja aufgebaut bevor der OCR-Vorgang gestartet wird?
Dies geschieht erst auf Knopfdruck (JButton).
Und mit dem Code von Anti-Held wird ja auch erst das WarteFenster erzeugt und DANN der Vorgang ausgeführt.
Könntest du das bitte zu meinem Verständnis genauer beschreiben?

Dann würde das funktionieren wie ich das gedacht habe:
Das WarteFenster liefert einen boolean(true), wenn es fertig ist,
erst dann kann der Vorgang starten, da er bis dahin überprüft
"ist das Fenster 'Fertig'? Dann kann ich loslegen,
wenn nicht: neuer schleifendurchlauf"

Verstehe ich das richtig?
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Bilder Reihenfolge beim auslesen eines Verzeichnisses in falscher Reihenfolge
Antworten: 4
ThreadPoolExecutor | Die Aufgaben sollen reihe nach bearbeitet werden
Antworten: 6
JCIFS - Smb - Datei kann nur von einem Benutzer bearbeitet werden
Antworten: 1
PaintComponent zeichnet in falscher reihenfolge
Antworten: 8
Ausgabe in falscher Reihenfolge
Antworten: 7

Zurück
Oben