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.

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.

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.

#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.

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.

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?

Das ist wohl nicht so gewollt, oder?

Genau! Das verstehe ich nicht.

if(!isInside)

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

Danke MFK...

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.