Ergebnis 1 bis 3 von 3

Thema: Polygon Problem

  1. #1
    Member
    Registriert seit
    Jan 2004
    Beiträge
    4
    Renommee
    10

    Polygon Problem

    Hallo,

    bei folgendem Code (java-applet) springen die Farben der jeweiligen Seiten hin und her. Ich finde den Fehler nicht! Danke für jede Hilfe.

    Sollte ein Würfel aus 6 Polygonen sein, aber irgendwie springen entweder die SEiten oder die Farben vertauschen sich.

    Code:
    package untitled2;
    
    import java.awt.*;
    import java.awt.event.*;
    import java.applet.*;
    
    
    public class Wuerfel extends Applet {
    
        // 8 Eckpunkte 1-8
        // mit je 3 Koordinaten 1,2,3
        double p[][] = new double[9][4];
    
        int x=1, y=2, z=3;
    
        public void init() {
            setBackground(new Color(255,255,255));
    
            // 8 Eckpunkte im lokalen Würfel-Koordinatensystem
            // Nullpunkt = Mittelpunkt
            p[1][x] = -100; p[1][y] = -100; p[1][z] = -100;
            p[2][x] = +100; p[2][y] = -100; p[2][z] = -100;
            p[3][x] = +100; p[3][y] = -100; p[3][z] = +100;
            p[4][x] = -100; p[4][y] = -100; p[4][z] = +100;
            p[5][x] = -100; p[5][y] = +100; p[5][z] = -100;
            p[6][x] = +100; p[6][y] = +100; p[6][z] = -100;
            p[7][x] = +100; p[7][y] = +100; p[7][z] = +100;
            p[8][x] = -100; p[8][y] = +100; p[8][z] = +100;
    
            /*       8 - - - - - 7
                   / |         / |
                  5 - - - - - 6  |
                  |  |        |  |
                  |  4 - - - -|- 3
                  | /         | /
                  1 - - - - - 2
            */
        }
    
        // Rotationswinkel
        double angle_x = 0.01;
        double angle_y = 0.0075;
        double angle_z = 0.005;
    
        Image buffer;
        Graphics2D gBuffer;
    //------------------------------------------------------------------
        public void paint(Graphics g) {
    
            // Double-Buffering
            if (buffer==null) {
                buffer=createImage(this.getSize().width, this.getSize().height);
                gBuffer=(Graphics2D)buffer.getGraphics();
            }
            gBuffer.clearRect(0,0,this.getSize().width, this.getSize().height);
    
            //3D POLYGON
            try
            {
              Thread.sleep(20);
            }
            catch(Exception e)
            {
              
            }
            int[] seiten = new int[6];
            int[] sort = new int[6];
            
            seiten[0] = ((int)p[1][z])+((int)p[2][z])+((int)p[5][z])+((int)p[6][z]);
            seiten[1] = ((int)p[2][z])+((int)p[3][z])+((int)p[6][z])+((int)p[7][z]);
            seiten[2] = ((int)p[3][z])+((int)p[4][z])+((int)p[7][z])+((int)p[8][z]);
            seiten[3] = ((int)p[1][z])+((int)p[4][z])+((int)p[5][z])+((int)p[8][z]);
            seiten[4] = ((int)p[5][z])+((int)p[6][z])+((int)p[7][z])+((int)p[8][z]);
            seiten[5] = ((int)p[1][z])+((int)p[2][z])+((int)p[3][z])+((int)p[4][z]);
          
            for(int i=0; i<=5; i++)
            {
              sort[i]=seiten[i];
            }
            qsort(sort, 0, sort.length -1);
            
            for(int i=0; i<=5; i++)
            {
              for(int j=0; j<=5; j++)
              {
                if (sort[i] == seiten[j])
                {             
                  if (j == 0) 
                  {
                    int[] x2_p={((int)(p[1][x])+200),((int)(p[2][x])+200),((int)(p[6][x])+200),((int)(p[5][x])+200)};
                    int[] y2_p={(int)(p[1][y])+200,(int)(p[2][y])+200,(int)(p[6][y])+200,(int)(p[5][y])+200};
                    gBuffer.fillPolygon(x2_p,y2_p,x2_p.length);
                    gBuffer.setColor(new Color(0,255,0));
                  }
                  if (j == 1)
                  {
                    int[] x2_p={((int)(p[2][x])+200),((int)(p[3][x])+200),((int)(p[7][x])+200),((int)(p[6][x])+200)};
                    int[] y2_p={(int)(p[2][y])+200,(int)(p[3][y])+200,(int)(p[7][y])+200,(int)(p[6][y])+200};
                    gBuffer.fillPolygon(x2_p,y2_p,x2_p.length);
                    gBuffer.setColor(new Color(0,255,0));
                  }
                   if (j == 2)
                  {
                    int[] x2_p={((int)(p[3][x])+200),((int)(p[4][x])+200),((int)(p[8][x])+200),((int)(p[7][x])+200)};
                    int[] y2_p={(int)(p[3][y])+200,(int)(p[4][y])+200,(int)(p[8][y])+200,(int)(p[7][y])+200};
                    gBuffer.fillPolygon(x2_p,y2_p,x2_p.length);
                    gBuffer.setColor(new Color(0,255,0));
                  }
                  if (j == 3)
                  {
                    int[] x2_p={((int)(p[1][x])+200),((int)(p[4][x])+200),((int)(p[8][x])+200),((int)(p[5][x])+200)};
                    int[] y2_p={(int)(p[1][y])+200,(int)(p[4][y])+200,(int)(p[8][y])+200,(int)(p[5][y])+200};
                    gBuffer.fillPolygon(x2_p,y2_p,x2_p.length);
                    gBuffer.setColor(new Color(0,255,0));
                  }
                  if (j == 4)
                  {
                    int[] x2_p={((int)(p[5][x])+200),((int)(p[6][x])+200),((int)(p[7][x])+200),((int)(p[8][x])+200)};
                    int[] y2_p={(int)(p[5][y])+200,(int)(p[6][y])+200,(int)(p[7][y])+200,(int)(p[8][y])+200};
                    gBuffer.fillPolygon(x2_p,y2_p,x2_p.length);
                    gBuffer.setColor(new Color(0,255,0));
                  }
                  if (j == 5)
                  {
                    int[] x2_p={((int)(p[1][x])+200),((int)(p[2][x])+200),((int)(p[3][x])+200),((int)(p[4][x])+200)};
                    int[] y2_p={(int)(p[1][y])+200,(int)(p[2][y])+200,(int)(p[3][y])+200,(int)(p[4][y])+200};
                    gBuffer.fillPolygon(x2_p,y2_p,x2_p.length);
                    gBuffer.setColor(new Color(255,255,0));
                  }
                  System.out.print(j + " ");
                }
              }
            }
            System.out.println("");
           
            // Lokale Würfel-Koordinaten
            // in Welt-Koordinaten: +200 der Wert 200 ist variabel
           //3D LINIEN
            /* gBuffer.drawLine((int)(p[1][x])+200,(int)(p[1][y])+200,(int)(p[2][x])+200,(int)(p[2][y])+200);
            gBuffer.drawLine((int)(p[1][x])+200,(int)(p[1][y])+200,(int)(p[3][x])+200,(int)(p[3][y])+200);
            gBuffer.drawLine((int)(p[1][x])+200,(int)(p[1][y])+200,(int)(p[6][x])+200,(int)(p[6][y])+200);
            gBuffer.drawLine((int)(p[1][x])+200,(int)(p[1][y])+200,(int)(p[8][x])+200,(int)(p[8][y])+200);
            gBuffer.drawLine((int)(p[2][x])+200,(int)(p[2][y])+200,(int)(p[3][x])+200,(int)(p[3][y])+200);
            gBuffer.drawLine((int)(p[2][x])+200,(int)(p[2][y])+200,(int)(p[4][x])+200,(int)(p[4][y])+200);
            gBuffer.drawLine((int)(p[2][x])+200,(int)(p[2][y])+200,(int)(p[5][x])+200,(int)(p[5][y])+200);
            gBuffer.drawLine((int)(p[2][x])+200,(int)(p[2][y])+200,(int)(p[7][x])+200,(int)(p[7][y])+200);
            gBuffer.drawLine((int)(p[3][x])+200,(int)(p[3][y])+200,(int)(p[4][x])+200,(int)(p[4][y])+200);
            gBuffer.drawLine((int)(p[3][x])+200,(int)(p[3][y])+200,(int)(p[6][x])+200,(int)(p[6][y])+200);
            gBuffer.drawLine((int)(p[3][x])+200,(int)(p[3][y])+200,(int)(p[8][x])+200,(int)(p[8][y])+200);
            gBuffer.drawLine((int)(p[4][x])+200,(int)(p[4][y])+200,(int)(p[1][x])+200,(int)(p[1][y])+200);
            gBuffer.drawLine((int)(p[4][x])+200,(int)(p[4][y])+200,(int)(p[7][x])+200,(int)(p[7][y])+200);
            gBuffer.drawLine((int)(p[4][x])+200,(int)(p[4][y])+200,(int)(p[5][x])+200,(int)(p[5][y])+200);
            gBuffer.drawLine((int)(p[5][x])+200,(int)(p[5][y])+200,(int)(p[6][x])+200,(int)(p[6][y])+200);
            gBuffer.drawLine((int)(p[5][x])+200,(int)(p[5][y])+200,(int)(p[7][x])+200,(int)(p[7][y])+200);
            gBuffer.drawLine((int)(p[6][x])+200,(int)(p[6][y])+200,(int)(p[7][x])+200,(int)(p[7][y])+200);
            gBuffer.drawLine((int)(p[6][x])+200,(int)(p[6][y])+200,(int)(p[8][x])+200,(int)(p[8][y])+200);
            gBuffer.drawLine((int)(p[7][x])+200,(int)(p[7][y])+200,(int)(p[8][x])+200,(int)(p[8][y])+200);
            gBuffer.drawLine((int)(p[8][x])+200,(int)(p[8][y])+200,(int)(p[5][x])+200,(int)(p[5][y])+200);
            gBuffer.drawLine((int)(p[1][x])+200,(int)(p[1][y])+200,(int)(p[5][x])+200,(int)(p[5][y])+200);
            gBuffer.drawLine((int)(p[2][x])+200,(int)(p[2][y])+200,(int)(p[6][x])+200,(int)(p[6][y])+200);
            gBuffer.drawLine((int)(p[3][x])+200,(int)(p[3][y])+200,(int)(p[7][x])+200,(int)(p[7][y])+200);
            gBuffer.drawLine((int)(p[4][x])+200,(int)(p[4][y])+200,(int)(p[8][x])+200,(int)(p[8][y])+200);
    
            gBuffer.setColor(new Color(0,0,0));
    */
            
    
            // Verzögerung
            //try {Thread.sleep(0);}
            //catch (InterruptedException e) {}
    
            double px, py, pz;
    
            for (int i=1;i<9;i++) {
    
                px = p[i][x];
                py = p[i][y];
                pz = p[i][z];
    
                // Rotation um x-Achse
                p[i][y] =(py*Math.cos(angle_x)-pz*Math.sin(angle_x));
                p[i][z] =(py*Math.sin(angle_x)+pz*Math.cos(angle_x));
    
                py = p[i][y];
                pz = p[i][z];
          
                // Rotation um y-Achse
                p[i][x] =(px*Math.cos(angle_y)+pz*Math.sin(angle_y));
                p[i][z] =(-px*Math.sin(angle_y)+pz*Math.cos(angle_y));
    
                px = p[i][x];
    
                // Rotation um z-Achse
                p[i][x] =(px*Math.cos(angle_z)-py*Math.sin(angle_z));
                p[i][y] =(py*Math.cos(angle_z)+px*Math.sin(angle_z));
            }
            g.drawImage (buffer, 0, 0, this);
            repaint();
        }
        
        
        static void qsort (int a[], int l, int r) {
            // nur absteigen, wenn Array mehr als 1 Element hat (l < r)
            if (l < r) {
                int r2 = partition (a, l, r);
                qsort (a, l, r2);
                qsort (a, r2 + 1, r);
            }
        }
    
        static int partition (int a[], int m, int n) {
           int x = a[m];  // Pivot-Element
           int j = n + 1;
           int i = m - 1;
    
           while (true) {
               j--;
               while (a[j] > x) j--;
               i++;
               while (a[i] < x) i++;
               if (i < j) exchange (a, i, j);
               else return j;
           }
       }
       static void exchange (int a[], int m, int n) {
         int t = a[m];
         a[m] = a[n];
         a[n] = t;
       }
       
        public void update(Graphics g) {paint(g);}
    }
    BEGIN GEEK CODE BLOCK
    Version: 3.12
    GMU d- s++: a--- C++ UL+++ P++ L++ E--- W N o- K- w--
    O+ M- V- PS+++ PE- Y PGP- t+ 5 X+++ R-- tv++ b+ DI- D
    G++ e h-- r++ y+
    END GEEK CODE BLOCK

    Non-Geek: Someone who thinks a kilobyte is 1000 bytes.
    Geek: Someone who thinks a kilometre is 1024 metres

  2. #2
    Moderator
    Registriert seit
    Jun 2001
    Beiträge
    1.327
    Renommee
    846

    Re: Polygon Problem

    Ich teste das nachher mal bei mir, um den Fehler zu sehen. Aber mir fällt jetzt schon was auf:

    1. Sortieren geht übrigens auch per Arrays.sort(array). Ist ein getunter Quicksort.

    2. Den event-dispatching Thread solltest du nicht schlafen lassen. Der ist zu wichtig. Du solltest eher darauf achten, Berechnungen dort schnell zu beenden. Also mach doch lieber eine Schleife in der start-Methode, in der das sleep() und das repaint() aufgerufen wird. (alternativ benutze javax.swing.Timer)
    Aktuelle Probleme der Doppelwoche:
    [29 Logik] Fahnenjagd

  3. #3
    Moderator
    Registriert seit
    Jun 2001
    Beiträge
    1.327
    Renommee
    846

    Re: Polygon Problem

    Der Fehler ist selbstgemacht. Du berechnest ja pro Seite eine Tiefeninformation, um die Polygone in der richtgen Reihenfolge zu zeichnen. Diese Tiefen sortierst du und ordnest sie dann wieder den einzelnen Seiten zu. Und bei der Zuordnung machst du einen Fehler, wenn zwei Seiten die gleiche Tiefe haben.
    Das kannst du umgehen, indem du direkt deine Seiten anhand der Tiefeninformation sortierst und nicht die Tiefeninformation allein.
    Aktuelle Probleme der Doppelwoche:
    [29 Logik] Fahnenjagd

Aktive Benutzer

Aktive Benutzer

Aktive Benutzer in diesem Thema: 1 (Registrierte Benutzer: 0, Gäste: 1)

Ähnliche Themen

  1. "polygon button" erstellen
    Von cymerou im Forum Java
    Antworten: 2
    Letzter Beitrag: 13.03.2005, 21:50

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •