begin process at 2010 02 10 12:27:03
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Maths & Algorithmes

 > FRACTALE TREE (ARBRE) VERSION GLUT

FRACTALE TREE (ARBRE) VERSION GLUT


 Information sur la source

Note :
8,5 / 10 - par 4 personnes
8,50 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Maths & Algorithmes Niveau :Débutant Date de création :04/03/2005 Vu :3 991

Auteur : Jarod1980

Ecrire un message privé
Commentaire sur cette source (16)
Ajouter un commentaire et/ou une note

 Description

Cliquez pour voir la capture en taille normale
Programme permettant de générer la fractale tree avec affichage graphique (Librairie Glut).
N'hésitez pas à mettre des commentaires.
Pour ceux qui utilisent Dev-Cpp comme moi, n'oublier pas de mettre dans projet=>Options du Projets=>Paramètres=>éditeur de liens:
-lopengl32
-lglut32
-lglu32

Source

  • #include <stdio.h>
  • #include <stdlib.h>
  • #include <math.h>
  • #include <GL/glut.h>
  • #define drand48 1.0/RAND_MAX*rand
  • #define srand48 srand
  • #define max 30000 /* nombre d'iterations */
  • #define seed 68111
  • void display();
  • void keyboard(unsigned char key, int x, int y);
  • int main(int argc, char** argv)
  • {
  • /* initialisation GLUT */
  • glutInit(&argc,argv);
  • /* ModeRGB */
  • glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
  • /* Taille de la fenêtre */
  • glutInitWindowSize(300,300);
  • /* Position fenêtre */
  • glutInitWindowPosition(0,0);
  • /* Titre fenêtre */
  • glutCreateWindow("Tree Fractale");
  • /* Enregistrements des callbacks */
  • glutDisplayFunc(display);
  • glutKeyboardFunc(keyboard);
  • /* Couleurs de fond noir */
  • glClearColor(0.0, 0.0, 0.0, 0.0);
  • /* Tracé en vert */
  • glColor3f(0.0, 1.0, 0.0);
  • /* activation de la matrice de projection */
  • glMatrixMode(GL_PROJECTION);
  • /* Réinitialisation de la matrice de transformation */
  • glLoadIdentity();
  • /* Rotation autour de l'axe x */
  • glRotatef(0.0,0.1,0.0,0.0);
  • /* visualisation de la matrice */
  • gluOrtho2D(-1.0, 1.0, 0.0, 2.5);
  • glMatrixMode(GL_MODELVIEW);
  • /* Boucle principale */
  • glutMainLoop();
  • return 0;
  • }
  • void display( void )
  • {
  • int i;
  • GLfloat x,y,r,xn,yn;
  • /* Efface la fenêtre */
  • glClear(GL_COLOR_BUFFER_BIT);
  • srand48(seed);
  • x = 0.5f; /*position initiale */
  • y = 0.0f;
  • for(i=1 ; i<=max; i++)
  • {
  • r = drand48();
  • if (r<=0.1)
  • {
  • xn = 0.05*x;
  • yn = 0.6*y;
  • }
  • else if((r>0.1) && (r<0.2))
  • {
  • xn = 0.05*x;
  • yn = -0.5*y+1.0;
  • }
  • else if ((r>0.2) && (r<0.4))
  • {
  • xn = 0.46*x-0.32*y;
  • yn = 0.39*x+0.38*y+0.6;
  • }
  • else if((r>0.4) && (r<0.6))
  • {
  • xn = 0.47*x-0.15*y;
  • yn = 0.17*x+0.42*y+1.1;
  • }
  • else if ((r>0.6) && (r<0.8))
  • {
  • xn = 0.43*x+0.28*y;
  • yn = -0.25*x+0.45*y+1.0;
  • }
  • else
  • {
  • xn = 0.42*x+0.26*y;
  • yn = -0.35*x+0.31*y+0.7;
  • }
  • glBegin(GL_POINTS);
  • glVertex2f(xn,yn);
  • x = xn;
  • y = yn;
  • glEnd();
  • }
  • glFlush(); /* Efface les buffers */
  • }
  • void keyboard(unsigned char key, int x, int y)
  • {
  • exit(0); /* Appuyer sur une touche pour sortir */
  • }
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <GL/glut.h>

#define drand48 1.0/RAND_MAX*rand 
#define srand48 srand    
#define max 30000		/* nombre d'iterations */
#define seed 68111

void display();
void keyboard(unsigned char key, int x, int y);

int main(int argc, char** argv)
{
/* initialisation GLUT */
 glutInit(&argc,argv);
 /* ModeRGB */
 glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);    
 /* Taille de la fenêtre */ 
 glutInitWindowSize(300,300);       
 /* Position fenêtre */              
 glutInitWindowPosition(0,0);   
 /* Titre fenêtre */    
 glutCreateWindow("Tree Fractale");
 /* Enregistrements des callbacks */                
 glutDisplayFunc(display);         
 glutKeyboardFunc(keyboard);                        

/* Couleurs de fond noir */
 glClearColor(0.0, 0.0, 0.0, 0.0);  
 /* Tracé en vert */                  
 glColor3f(0.0, 1.0, 0.0);   
 /* activation de la matrice de projection */                          
 glMatrixMode(GL_PROJECTION);     
 /* Réinitialisation de la matrice de transformation */
 glLoadIdentity();    
 /* Rotation autour de l'axe x */          
 glRotatef(0.0,0.1,0.0,0.0);  
 /* visualisation de la matrice */                  
 gluOrtho2D(-1.0, 1.0, 0.0, 2.5);
 glMatrixMode(GL_MODELVIEW);                      

/* Boucle principale */
 glutMainLoop();                                      
 return 0;
}

void display( void )
{
     int i;
   GLfloat x,y,r,xn,yn;
   /* Efface la fenêtre */
   glClear(GL_COLOR_BUFFER_BIT);                         
   srand48(seed);		
   
   x     = 0.5f;  /*position initiale */
   y     = 0.0f;
   for(i=1 ; i<=max; i++)
   {
      r = drand48();
      if (r<=0.1)
      { 
         xn = 0.05*x;
         yn = 0.6*y;
      }
      else if((r>0.1) && (r<0.2))
      { 
         xn  = 0.05*x;
         yn  = -0.5*y+1.0;
      }
      else if ((r>0.2) && (r<0.4))
      {
         xn  = 0.46*x-0.32*y;
         yn  = 0.39*x+0.38*y+0.6;
      }  
      else if((r>0.4) && (r<0.6))
      {
         xn  = 0.47*x-0.15*y;
         yn  = 0.17*x+0.42*y+1.1;
      }
      else if ((r>0.6) && (r<0.8))
      {
         xn  = 0.43*x+0.28*y;
         yn  = -0.25*x+0.45*y+1.0;
      }  
      else 
      {
         xn  = 0.42*x+0.26*y;
         yn  = -0.35*x+0.31*y+0.7;
      }  
     
      glBegin(GL_POINTS);
      glVertex2f(xn,yn);
      x = xn;
      y = yn;
     glEnd();
    }
 glFlush(); /* Efface les buffers */
}
void keyboard(unsigned char key, int x, int y)
{
 exit(0); /* Appuyer sur une touche pour sortir */
}



 Sources du même auteur

Source avec une capture FRACTALE NEWTON-RAPHSON VERSION GLUT
Source avec Zip FAST FOURIER TRANSFORM
TRANSFORMEE DE FOURIER DISCRETE
Source avec une capture COURBE DE GUMOWSKI & MIRA VERSION GLUT
Source avec une capture COURBE DE GUMOWSKI-MIRA

 Sources de la même categorie

Source avec Zip OPERATION SUR LES MATRICES CARREES AVEC CLASSE GENERIQUE par chouhad
Source avec une capture OPÉRATIONS SUR MATRICES C++ par Minilogus
[DEV-C++] CALCUL DE LA RACINE CARRÉE D'UN RÉEL par Jhep
PROGRAMME QUI CALCUL LE PPCM ET LE PGCD par AnoSantino
EVALUER UNE EXPRESSION MATHÉMATIQUE par begueradj

Commentaires et avis

Commentaire de Zazour le 05/03/2005 12:33:53

super ton arbre,mais a quoi sert la variable seed?

Commentaire de Kirua le 05/03/2005 13:42:08

Superbe fractale :) ça faisait un moment que je n'étais plus capable de regarder un arbre sans y voir une fractale, tu ne m'aides pas sur la voie de la guérison :)

Pour ta grande for: tu peux mettre une continue; à la fin de chaque if()..., ça te permet de ne pas devoir faire deux tests dans toutes tes if. tu vois ce que je veux dire ou je dois expliciter?

Commentaire de Jarod1980 le 05/03/2005 13:46:24

Salut,
En fait, la variable seed sert de générateur de nombres pseudo-aléatoires que l'on va utiliser avec la fonction srand48 ici dans mon programme.

Commentaire de Kirua le 05/03/2005 13:51:51

tu devrais quand même déclarer des constantes et pas des defines.

#define drand48 1.0/RAND_MAX*rand

pourquoi pas:

#define drand48  ((double)rand()/(double)RAND_MAX)

et d'ailleurs plus généralement: pourquoi pas:

inline double drand48()
{
return (double)rand() / (double)RAND_MAX;
}

faut vivre avec son langage :)


quoique... en fait t'as tout fait en C apparemment, mais si d'aventure tu te mettais au C++ ;)

Commentaire de Jarod1980 le 05/03/2005 13:53:29

Kirua,
Désolé de ne pas contribuer à ta guérison (lol). J'ai déjà entendu parlé de "continue" mais je ne l'ai jamais utilisé.
En cas si tu peux expliciter son utilisation, ça serait bien.
Merci encore pour tous vos commentaires.

Commentaire de Jarod1980 le 05/03/2005 13:57:14

Très bonne remarque Kirua à propos de drand48. Je n'y avais pas pensé.

Commentaire de Kirua le 05/03/2005 14:05:23

C'est pas bien compliqué, il y a deux mots à retenir:

continue et
break

Ça ne fonctionne que dans le cadre d'une boucle (while / for), et dans le cas de break ça fonctionne aussi avec les switch.

L'effet est simple:

continue: arrête l'exécition de la boucle et la fait tout de suite passer à l'itération (le bouclage) suivante. exemple:

for(int i = 1; i <= 10; ++i)
{
  if(i == 5)
     continue;
  cout << i;
}

ce code affiche:

1
2
3
4
//il manque 5
6
7
8
9
10

quand on est arrivé à 5, on est tout de suite passé à 6 sans l'écrire.

Pour break, c'est un peu différant: on ne passe pas à l'itération suivante: on quitte la boucle (on la "casse" = break en anglais):

for(int i = 1; i <= 10; ++i)
{
  if(i == 5)
     break;
  cout << i;
}

ce code affiche:

1
2
3
4

Et c'est tout ! Bien sûr, ce code est idiot, mais comme ça tu vois. Concrètement, pour ton code on va faire comme ça:

        if (r<=0.1)
        {
         xn = 0.05*x;
         yn = 0.6*y;
continue;
        }

        if(r<0.2)
        {
         xn = 0.05*x;
         yn = -0.5*y+1.0;
continue;
        }

        if (r<0.4)
        {
         xn = 0.46*x-0.32*y;
         yn = 0.39*x+0.38*y+0.6;
continue;
        }

...

Tu vois: on évite chaque fois un test de plus! Mais attention, on a oublié ceci:

        glBegin(GL_POINTS);
        glVertex2f(xn,yn);
        x = xn;
        y = yn;
       glEnd();

En fait, tu aurais dû appeler le glBegin() avant la for, et le glEnd() après la for. tu aurais aussi dû appeler le glVertex2f() dans chaque if(), et comme ça tu n'aurais pas eu de souci :) je te laisse modifier ça, ça devrait être sensiblement plus rapide.

Commentaire de Jarod1980 le 05/03/2005 14:25:26

Kirua,
Tout simplement un grand merci pour tes explications. Je vais tester ça.
Merci encore.

Commentaire de Zazour le 05/03/2005 14:51:56

la variable seed n'est pas trés significative,que je mette 1 ou 100000 c'est pareil,c'est normal ?

Commentaire de Kirua le 05/03/2005 18:22:19

Ben, seed détermine la séquence de chiffres ... d'habitude on met time(NULL) cmme valeur, comme ça ça change à chaque exécution. Mais c'est pas anormal que les arbres soient sensiblement pareils.

Commentaire de TeLeTUbIz le 11/03/2005 19:09:20

Très bonne remarque de Kirua sur le continue. Moi qui le trouvait sale, preuve que parfios mieux vaut l'utiliser.
Ce serait bien un executable, mon glut marche pas sous GCC... (manque GLUT_RGB et GLUT_SINGLE)

Commentaire de LordBob le 17/03/2005 18:45:38

nickel cette source !!!
:)

Commentaire de Lightness1024! le 02/04/2005 12:48:09

moi aussi dernierement j'ai progé un générateur d'arbres procéduraux. voir:

http://serhum.epsylon.org/arbres14.png

par contre je sais pas comment tu peux faire le tiens en si peu de lignes, le miens en fait 1000.

Commentaire de Kirua le 09/04/2005 12:51:38

tes arbres sont en 3D. c'est super beau, mais forcément t'as bcp de code pr le rendering.

Commentaire de gabriel_jm le 12/07/2005 17:29:53

bonjour,
en fait j'ai essayé de faire marcher ce code chez moi, mais devcpp ne reconnait pas les fonctions glut, alors que dois je faire?
merci

Commentaire de Jarod1980 le 14/07/2005 13:47:14

Salut,
Gabriel_JM essais d'aller jeter un coup d'oeil sur ce site:

http://www.dil.univ-mrs.fr/~garreta/generique/autres/OGL/

Tu pourras télécharger la même version de Glut que moi. Normalement il n'y aura plus de problèmes de compilation.
Ne pas oublier de faire projet=>Options du Projets=>Paramètres=>éditeur de liens:
-lopengl32
-lglut32
-lglu32
avant de compiler.

 Ajouter un commentaire




Nos sponsors


Sondage...

CalendriCode

Février 2010
LMMJVSD
1234567
891011121314
15161718192021
22232425262728

Consulter la suite du CalendriCode

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,998 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales