FRACTALES DE JULIA ET MANDELBROT EN SDL julia, mandelbrot, fractale, algorithme, sdl, Source N°43863

Information sur la source

Catégorie :Maths & Algorithmes Classé sous : julia, mandelbrot, fractale, algorithme, sdl Niveau : Débutant Date de création : 22/08/2007 Vu / téléchargé: 3 125 / 155

Auteur : patarotalexandre

Site perso

Ecrire un message privé

Note :

1,00 / 10

1
2
3
4
5
6
7
8
9
10

Commentaire sur cette source (3)

Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale

-Déjà courants sur ce site, les algorithmes pour dessiner les fractales sont assez simple...mais comme je n'ai pas bien compris le principe en regardant les sources déjà présentes, j'ai essayé d'en faire une plus simple (à part les petites fonctions de zoom et de décalage) qui tient dans une fonction, je crois, assez claire.
Cette source a donc pour objectif de vous donner envie de dessiner des fractales par vous-meme, et de mieux comprendre la façon dont on dessine les ensembles de Julia.
-Plusieurs fractales sont enregistrées, il n'y a pas quel celle de Mandelbrot. Vous pouvez les voir en appuyant sur le bouton "home" (c'est une flèche au dessus de fin pour ceux qui savent pas) et quitter le plein écran avec "échap" ou y revenir avec "F2". Le zoom ce fait avec les haut et bas de page et le déplacement...avec les touches directionelles.

Source

/***************************************************************/
/********Juste la fonction de dessin ici, le reste dans le zip**/
/***************************************************************/
void fdessinfractale(int zoom, int Xrepereinit, int Yrepereinit, double paramCx, double paramCy){
pixel=SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, bits, 0, 0, 0, 0);
px=0;
while (px<width){
py=0;
while (py<height){
position.x=px;
position.y=py;
Xinit=0;Yinit=0;
Xinit=(int)(Xrepereinit-(width/2));
Yinit=(int)(Yrepereinit-(height/2));
Xrepere=4*((px+Xinit)/((double)(zoom*width)));
Yrepere=4*((py+Yinit)/((double)(zoom*height)));
Zx=Xrepere;
Zy=Yrepere;
if(paramCx!=0&&paramCy!=0){Cx=paramCx;Cy=paramCy;}
else{Cx=Xrepere;Cy=Yrepere;};
n=0;
while ( n<255 && (Zx*Zx+Zy*Zy)<=4 ){copie=Zx;
Zx=Zx*Zx-Zy*Zy+Cx;
Zy=2*copie*Zy+Cy;
n++;
};
if(n==255&&borderonly==1){SDL_FillRect(pixel, NULL, SDL_MapRGB(pixel->format, 255, 255 , 255));}
else{SDL_FillRect(pixel, NULL, SDL_MapRGB(pixel->format, n, n , 0));};
SDL_BlitSurface(pixel, NULL, ecran, &position);
py++;
};
px++;
};
SDL_Flip(ecran);
};

/***************************************************************/
/********Juste la fonction de dessin ici, le reste dans le zip**/
/***************************************************************/

void fdessinfractale(int zoom, int Xrepereinit, int Yrepereinit, double paramCx, double paramCy){
    pixel=SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, bits, 0, 0, 0, 0);
    px=0;
    while (px<width){
    py=0;
    while (py<height){
            position.x=px;
            position.y=py;
            Xinit=0;Yinit=0;
            Xinit=(int)(Xrepereinit-(width/2));
            Yinit=(int)(Yrepereinit-(height/2));
            Xrepere=4*((px+Xinit)/((double)(zoom*width)));
            Yrepere=4*((py+Yinit)/((double)(zoom*height)));
            Zx=Xrepere;
            Zy=Yrepere;
            if(paramCx!=0&&paramCy!=0){Cx=paramCx;Cy=paramCy;}
            else{Cx=Xrepere;Cy=Yrepere;};
            n=0;
            while ( n<255 && (Zx*Zx+Zy*Zy)<=4 ){copie=Zx;
                                              Zx=Zx*Zx-Zy*Zy+Cx;
                                              Zy=2*copie*Zy+Cy;
                                              n++;
                                             };
            if(n==255&&borderonly==1){SDL_FillRect(pixel, NULL, SDL_MapRGB(pixel->format, 255, 255 , 255));}
            else{SDL_FillRect(pixel, NULL, SDL_MapRGB(pixel->format, n, n , 0));};
            SDL_BlitSurface(pixel, NULL, ecran, &position);
            py++;
                     };
    px++;
    };
SDL_Flip(ecran);
};

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Fractale
- Fractalesetup.ex524 279 octets
- main.c 10 631 octets

Télécharger le zip

Sources du même auteur

Toutes les sources de patarotalexandre

Sources de la même categorie

Toutes les sources de la catégorie Maths & Algorithmes

Sources en rapport avec celle ci

Commentaires

Commentaire de DeAtHCrAsH le 24/08/2007 16:56:06

Un installeur pour une simple fractale ?
T'as passé plus de temps à faire l'installeur que la fractale je parie ... Ma fois ... Une de plus!
Commentaire de patarotalexandre le 29/08/2007 22:10:44

Je réponds à DeAtHCrAsH pour lui dire qu'il existe Innosetup qui fait les installeurs facilement, il n'y a qu'à mettre son Exécutable dans les options, donc au niveau du temps ca va et la source ne fait pas que dessiner une fractale, elle utilise la sdl avec la bascule entre le mode plein écran ou non (pour les débutants comme moi, cela peut être utile dans un jeu) et le zoom, etc... D'autant plus qu'elle est pour les débutants mais c'est vrai qu'il y a déjà plusieurs sources du genre (je le signale dans la description et j'y explique pourquoi je l'ai ajoutée).
Commentaire de tit_toinou le 01/01/2008 16:20:16

Salut patarotalexandre,
pour changer un pixel de ton ecran, ta solution est de blitter sur cet ecran une surface de 1pixel de large et de 1pixel de hauteur..
J'ai plus rapide !
Suis ce tuto http://anomaly.developpez.com/tutoriel/sdl/partie1/ ;)
Si tu a besoin de mettre de la transparence dans tes pixels, tu dois appeler les fonctions SDL_LockSurface(de ta surface) et SDL_UnLockSurface(de ta surface)..

Bonne Lecture..

Ajouter un commentaire

Discussions en rapport avec ce code source

Mandelbrot, Julia par Novae

Texte & SDL en mode Video par Gaelle

Qui sait l'algorithme pour calculer les racines? par TMT

librairie SDL et coonio.h par gloom

conversion de la partie fractionnaire en base n par Alucard

Device context et StretchBlt ? par tavernier

Algorithme de mélange par C2S

aide sur l'algorithme AMR par semecurbep

map basic?????? par Sfoued2003

algorithme de gauss et decomposition LU par speedamine