[Anfänger] Apfelmännchen



  • Hallo, ich habe die aufgabe gestellt bekommen diese Mandelbrotmenge zu zeichnen in einem Intervall (-2,1) und (-1.5,1.5). Nun habe ich mich da eingelesen und hab so in etwa verstanden welche bedingungen erfüllt werden müssen, damit noch eine komplexe Zahl zu der Menge gehört.

    Was ich allerdings nicht verstehe bzw wovon ich garkeine ahnung habe, ist wie man bei C++ Bilder plottet oder einzelne Pixels im Bild setzt. Gibt es irgendwo etwas dazu nachzulesen? Ich wollte, bevor ich überhaupt mit der aufgabe anfange, erstmal sowas wie einen kreis oder linie überhaupt zeichnen können.



  • Grafiken kann man mit Standart C++ nicht Zeichnen, da musst du auf die API von deinem Betriebbsystem zugreiffen.

    Du könntest dir auch eine passende Grafik Bibliothek herunterladen, im Spiele Bereich hier im Forum da wird für 2D Spiele öfters die SDL empfohlen.

    http://www.libsdl.org/ <-- Da findest du die SDL.



  • Standard-C++ kennt keine Grafikausgabe. Nimm die API deines Systems, z.B. die WinAPI. Erstell dort ein Fenster und bei WM_PAINT zeichneste dann. Gibt's genug Tutorials für. 😉



  • Nun ich kenn mich einigermaßen mit gnuplot aus. Könnte ich die einzelne Koordinaten in eine Textdatei speichern und sie dan mit gnuplot darstellen?


  • Mod

    Namal schrieb:

    Nun ich kenn mich einigermaßen mit gnuplot aus. Könnte ich die einzelne Koordinaten in eine Textdatei speichern und sie dan mit gnuplot darstellen?

    gnuplot kennt sogar eine Direktanbindung an ein Programm per Bibliothek. Jedoch ist es immer noch ein Plotprogramm und nicht dazu gedacht, die Grafikausgabe eines Programms zu ersetzen. Der Versuch wird zu nichts brauchbarem führen.



  • Ok, könnt ihr mir dann ein tutorial empfehlen?



  • Hallo, hab die Frage jetzt im Grafikunterforum gestellt, aber dort antwortet mir leider niemand. Also ich habe das mit Hilfe von glut so versucht:

    #include <GL/glut.h> 
    
    double MinRe = -2.0; 
    double MaxRe = 1.0; 
    double MinIm = -1.2; 
    double MaxIm = MinIm+(MaxRe-MinRe); 
    double Re_factor = (MaxRe-MinRe)/(399); 
    double Im_factor = (MaxIm-MinIm)/(399); 
    unsigned MaxIterations = 100; 
    
    void draw() 
    { 
    
       glClear(GL_COLOR_BUFFER_BIT ); 
       //Draw order 
    
       glBegin(GL_POINTS); 
    
             for(unsigned y=0; y<400; ++y) 
       { 
         double c_im = MinIm + y*Im_factor; 
         for(unsigned x=0; x<400; ++x) 
         { 
             double c_re = MinRe + x*Re_factor; 
    
             double Z_re = c_re, Z_im = c_im; 
             bool isInside = true; 
              int k=0; 
             for(unsigned n=0; n<MaxIterations; ++n) 
             { 
    
                 double Z_re2 = Z_re*Z_re, Z_im2 = Z_im*Z_im; 
                 if(Z_re2 + Z_im2 > 4) 
                 { 
                     isInside = false; 
                     break; 
                 } 
                 Z_im = 2*Z_re*Z_im + c_im; 
                 Z_re = Z_re2 - Z_im2 + c_re; 
                 k++; 
             } 
             if(isInside) 
                         {   
                            float col=(100-k)/100.0; 
                            glColor3f(col,col,col); 
                            glVertex2f(x,y); 
                         } 
         } 
    } 
    
       glEnd(); 
    
       glFlush(); 
    } 
    
    //Main program 
    int main(int argc, char **argv) 
    { 
       glutInit(&argc, argv); 
       //Simple buffer 
       glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB ); 
       glutInitWindowPosition(400,50); 
       glutInitWindowSize(400,400); 
       glutCreateWindow("new window"); 
       glClearColor(1,1,1,1); 
    
       glMatrixMode(GL_PROJECTION); 
       glLoadIdentity(); 
       glOrtho(0.0,400.0,0.0,400.0,-1.0,1.0); 
    
       glutDisplayFunc(draw); 
       glutMainLoop(); 
       return 0; 
    }
    

    Aber es scheint so, dass die Abhängigkeit von der Anzahl der Schritte nicht dargestellt wird und ich verstehe leider nicht warum. Es ist doch richtig, dass wenn ich col = 0 habe, dann schwarz bekomme und bis col = 1 die Graustufen bis weiß, aber es scheint so zu sein, dass der Zähller immer die Maximale anzahl erreicht.



  • Alternativ zur Live-Anzeige kannst du auch einfach ein Bild abspeichern. Ein recht einfaches Format ist PGM. Da gibt es auch eine ASCII-Text-Version von:

    P2    # P2 -> ASCII-Graustufenbild
    10 5  # Breite und Hoehe
    9     # maximaler Intensitaetswert
    0 0 0 0 0 9 0 0 0 0
    0 2 4 2 0 0 9 0 0 0
    0 4 8 4 0 0 0 9 0 0
    0 2 4 2 0 0 0 0 9 0
    0 0 0 0 0 0 0 0 0 9
    

    Das als .pgm abspeichern und freuen.



  • Namal schrieb:

    if(isInside) 
    {   
      float col=(100-k)/100.0;
      fprintf(stdout, "k: %d, glcolor3f(%f,%f,%f)\n", k, col, col, col);
      glColor3f(col,col,col); 
      glVertex2f(x,y);
    

    Wenn ich mir an dieser Stelle eine Testausgabe einbaue, ist k konstant(=100) und col damit auch(=0.0). Das ist wohl nicht so gewollt, oder?



  • Furble Wurble schrieb:

    Das ist wohl nicht so gewollt, oder?

    Genau! Das verstehe ich nicht.



  • if(!isInside)
    


  • MFK schrieb:

    if(!isInside)
    

    BAAAAH. ICh kapier es nicht. Warum funktioniert es so aber andersrum nicht?



  • if(isInside) 
                         {   
                            float col=0; 
                            glColor3f(col,col,col); 
                            glVertex2f(x,y); 
                         } 
    if(!isInside) 
                         {   
                            float col=(100-k)/100.0; 
                            glColor3f(col,col,col); 
                            glVertex2f(x,y); 
                         }
    

    Danke MFK...



  • Namal schrieb:

    Warum funktioniert es so aber andersrum nicht?

    k zeigt an, nach wievielen Iterationen deine Schleife abgebrochen wurde. Den Abbruch signalisierst du, indem du isInside auf false setzt. Die interessanten Werte stehen also dann in k, wenn isInside false ist.


Log in to reply