Miglioramento al mio codice Mandelbrot

Question

Ho il seguente codice di set Mandelbrot in C. Sto facendo il calcolo e creando un file .ppm per l'immagine finale frattale. Il punto è che la mia immagine frattale è capovolta, nel senso che è ruotata di 90 gradi. Puoi controllare eseguendo il mio codice: ./mandel> test.ppm

D'altra parte, voglio anche cambiare i colori. Voglio ottenere questa immagine frattale:

Il mio problema finale è che il mio codice non controlla il tempo di esecuzione del mio codice. Ho anche il codice per questa parte, ma quando termina l'esecuzione del codice non stampa il tempo di esecuzione. Se qualcuno può apportare le opportune modifiche al mio codice e aiutarmi a realizzare questa immagine frattale e rendere visibile il tempo trascorso, sarei felice.

#include <math.h> 
#include <stdlib.h> 
#include <time.h> 
#include <stdio.h> 

void color(int red, int green, int blue) 
{ 
    fputc((char)red, stdout); 
    fputc((char)green, stdout); 
    fputc((char)blue, stdout); 
} 

int main(int argc, char *argv[]) 
{ 
    int w = 600, h = 400, x, y; 
    //each iteration, it calculates: newz = oldz*oldz + p, where p is the current pixel, and oldz stars at the origin 
    double pr, pi;     //real and imaginary part of the pixel p 
    double newRe, newIm, oldRe, oldIm; //real and imaginary parts of new and old z 
    double zoom = 1, moveX = -0.5, moveY = 0; //you can change these to zoom and change position 
    int maxIterations = 1000;//after how much iterations the function should stop 

    clock_t begin, end; 
    double time_spent; 

    printf("P6\n# CREATOR: E.T/mandel program\n"); 
    printf("%d %d\n255\n",w,h); 

    begin = clock(); 

    //loop through every pixel 
    for(x = 0; x < w; x++) 
    for(y = 0; y < h; y++) 
    { 
     //calculate the initial real and imaginary part of z, based on the pixel location and zoom and position values 
    pr = 1.5 * (x - w/2)/(0.5 * zoom * w) + moveX; 
     pi = (y - h/2)/(0.5 * zoom * h) + moveY; 
     newRe = newIm = oldRe = oldIm = 0; //these should start at 0,0 
     //"i" will represent the number of iterations 
     int i; 
     //start the iteration process 
     for(i = 0; i < maxIterations; i++) 
     { 
      //remember value of previous iteration 
      oldRe = newRe; 
      oldIm = newIm; 
      //the actual iteration, the real and imaginary part are calculated 
      newRe = oldRe * oldRe - oldIm * oldIm + pr; 
      newIm = 2 * oldRe * oldIm + pi; 
      //if the point is outside the circle with radius 2: stop 
      if((newRe * newRe + newIm * newIm) > 4) break; 
     } 

     color(i % 256, 255, 255 * (i < maxIterations)); 

    } 

    end = clock(); 

    time_spent = (double)(end - begin)/CLOCKS_PER_SEC; 
    printf("Elapsed time: %.2lf seconds.\n", time_spent); 

    return 0; 
} 

Answer 1

Parte 1: è necessario scambiare l'ordine dei cicli a:

for(y = 0; y < h; y++) 
for(x = 0; x < w; x++) 

che vi darà il frattale correttamente orientata.

Parte 2: per ottenere il tempo per stampare, si dovrebbe stampare a stderr da quando si stampa l'output ppm a stdout:

fprintf(stderr, "Elapsed time: %.2lf seconds.\n", time_spent); 

Parte 3: Per ottenere una colorazione uniforme continuo, è necessario utilizzare il metodo Conta Iterazione Normalizzata o qualcosa di simile. Qui è un sostituto per la sezione colorazione che ti dà qualcosa di simile a ciò che si desidera:

if(i == maxIterations) 
     color(0, 0, 0); // black 
    else 
    { 
     double z = sqrt(newRe * newRe + newIm * newIm); 
     int brightness = 256. * log2(1.75 + i - log2(log2(z)))/log2(double(maxIterations)); 
     color(brightness, brightness, 255); 
    } 

Non è del tutto lì perché mi tipo di fatto una semplice implementazione approssimativa del metodo normalizzato Iterazione Conte.

Non è una colorazione completamente continuo, ma è sorta di stretta.