Pixelzahl in Java

Question

Ok, nachdem für den ganzen Nachmittag kämpfen, kann ich nicht scheinen, um die richtige Antwort zu bekommen. Grundsätzlich habe ich eine sehr einfache Einrichtung, die meine Leinwand, ein BufferedImage, mit einem weißen Hintergrund füllt. Ich zeichne dann ein Polygon von Punkten, die von meinem args-Array kommen. Displayweise funktioniert das perfekt. Das Problem tritt auf, wenn ich die Anzahl der Pixel zählen will, die das Polygon (das gefüllt ist) verbraucht.

Um dies zu tun, ich durchgeschleift die Leinwand und jedes Pixel verglichen, um die getRGB Verfahren verwendet wird, und wenn es nicht weiß ist (die Hintergrundfarbe), ich einen Zähler erhöht. Das Ergebnis, das ich immer bekomme, ist jedoch die Dimension der Leinwand (640 * 480), was bedeutet, dass die gesamte Leinwand weiß ist.

Ich gehe davon aus das Polygon, so dass auf dem Bildschirm gezeichnet wird nicht auf die Leinwand hinzugefügt, und oben schwimmt? Das ist die einzige Antwort, die ich mir vorstellen kann, aber könnte völlig falsch sein.

Was Ich mag würde in der Lage sein, die Anzahl der Pixel zu zählen, die nicht weiß sind. Irgendwelche Vorschläge?

Code:

public class Application extends JPanel { 

public static int[] xCoord = null; 
public static int[] yCoord = null; 
private static int xRef = 250; 
private static int yRef = 250; 
private static int xOld = 0; 
private static int yOld = 0; 
private static BufferedImage canvas; 
private static Polygon poly; 

public Application(int width, int height) { 
    canvas = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); 
    fillCanvas(Color.WHITE); 
    poly = new Polygon(xCoord, yCoord, xCoord.length);  

    //Loop through each pixel 
    int count = 0; 
    for (int i = 0; i < canvas.getWidth(); i++) 
     for (int j = 0; j < canvas.getHeight(); j++) { 
      Color c = new Color(canvas.getRGB(i, j)); 
      if (c.equals(Color.WHITE)) 
       count++; 
     } 
    System.out.println(count); 
} 

public void paintComponent(Graphics g) { 
    super.paintComponent(g); 
    Graphics2D g2 = (Graphics2D) g; 
    g2.drawImage(canvas, null, null); 
    g2.fillPolygon(poly); 

} 

public void fillCanvas(Color c) { 
    int color = c.getRGB(); 
    for (int x = 0; x < canvas.getWidth(); x++) { 
     for (int y = 0; y < canvas.getHeight(); y++) { 
      canvas.setRGB(x, y, color); 
     } 
    } 
    repaint(); 
} 


public static void main(String[] args) {  
    if (args != null) 
     findPoints(args); 

    JFrame window = new JFrame("Draw"); 
    Application panel = new Application(640, 480); 

    window.add(panel); 
    Dimension SIZE = new Dimension(640, 480); 
    window.setPreferredSize(SIZE); 
    window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
    window.setVisible(true); 
    window.pack();  
}//end main 

Die Methode ‚Findpoints (args)‘ ist zu lang, um zu Posten, aber im Grunde alle es tut es die Argumentwerte nimmt und stellt eine Liste von Punkten.

Vielen Dank im Voraus, Boot

Answer 1

einfach ein Ausrufezeichen fügen Sie den Booleschen Wert in Ihrem Zustand zu invertieren:

if (!c.equals(Color.WHITE)) 

Ein schneller Weg ist, den RGB-Wert statt zuerst eine Farbe zu überprüfen Objekt davon:

if ((rgb & 0xFFFFFF) != 0xFFFFFF) 

---

erstellen BufferedIm Alter, zeichne das Polygon und zähle. Im Grunde ist dies:

BufferedImage img = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB_PRE); 
Graphics2D g = img.createGraphics(); 
g.fill(polygon); 
g.dispose(); 
countThePixels(img); 

Answer 2

Beim Erstellen/füllen die Leinwand, Sie arbeiten mit einem BufferedImage Objekt. Das Poligon wird in einem Objekt Polygon erfasst. Das eigentliche Rendern auf dem Bildschirm erfolgt durch Manipulieren eines Graphics Objekts - in gewisser Weise ist das Polygon "schwebend"; Das heißt: Es wird nicht auf der Leinwand angezeigt, sondern wird darüber gemalt, wenn das Graphics-Objekt gerendert wird.

Sie müssen tatsächlich das Polygon auf der Leinwand selbst machen, oder die Pixel erhalten von der Graphics-Objekt und Ihre Berechnung auf dieser Schnittstelle