CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2012 02 07 09:44:14

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

FRACTALE DE KOCH

Information sur la source

Note :

10,00 / 10

Catégorie :OpenGL Classé sous :Fractale, Koch, SDL, OpenGL Niveau :Débutant Date de création :28/12/2007 Date de mise à jour :12/01/2008 19:12:34 Vu / téléchargé :5 946 / 222

Auteur : CChargy

Ecrire un message privé

Site perso

Commentaire sur cette source (39)

Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale

Générateur d'images fractales a partir du procédé de Koch!

Toutes les infos ici : http://colin.chargy.free.fr/Wiki/index.php?title=F ractale

Il ya dans le zip un exécutable Windows (renommer en .exx) et un exécutable Linux (sans extensions).

Source

#include <SDL/SDL.h>
#include <SDL/SDL_opengl.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdexcept>
#include <string>
#include <vector>
#include <math.h>
#include <fstream>
using namespace std;
const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067;
class Ligne
{
public:
double x1, y1, x2, y2;
};
vector<Ligne> Lignes;
int Split(vector<string>* vecteur, string chaine, char separateur)
{
vecteur->resize(1);
vecteur[0].empty();
int longeur = chaine.length();
for(int i = 0; i < longeur; ++i)
{
if(chaine.at(i) == separateur)
{
vecteur->resize(vecteur->size() + 1);
}
else
{
vecteur->at(vecteur->size() - 1).resize(vecteur->at(vecteur->size() - 1).size() + 1);
vecteur->at(vecteur->size() - 1).at(vecteur->at(vecteur->size() - 1).size() - 1) = chaine.at(i);
}
}
return vecteur->size();
}
void LireFichier()
{
ifstream fichier("geo.frac");
//Lecture du fichier
string Fichier, Ligne;
vector<string> Parties;
char ch;
while(fichier.get(ch))
Fichier += ch;
int nblignes = Split(&Parties, Fichier, '\n');
for(int i = 0; i < nblignes; i++)
{
Ligne = Parties[i];
if(Ligne[Ligne.size() - 1] == '\r') Ligne.erase(Ligne.size() - 1);
if((Ligne[0] != '/') && (Ligne[1] != '/'))
{
vector<string> SousParties, SousPartiesDebut, SousPartiesFin;
if((Split(&SousParties, Ligne, '>') == 2) && (Split(&SousPartiesDebut, SousParties[0], ',') == 2) && (Split(&SousPartiesFin, SousParties[1], ',') == 2))
{
Lignes.resize(Lignes.size() + 1);
Lignes[Lignes.size() - 1].x1 = atoi(SousPartiesDebut[0].c_str());
Lignes[Lignes.size() - 1].y1 = atoi(SousPartiesDebut[1].c_str());
Lignes[Lignes.size() - 1].x2 = atoi(SousPartiesFin[0].c_str());
Lignes[Lignes.size() - 1].y2 = atoi(SousPartiesFin[1].c_str());
}
}
}
}
void Calcul()
{
Uint32 temps = 0;
int size = Lignes.size();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
for(int i = 0; i < size; i++)
{
if(temps + 50 < SDL_GetTicks())
{
temps = SDL_GetTicks();
glBegin(GL_QUADS);
glColor3ub(0, 0, 255);
glVertex2d(250, 100);
glVertex2d(-250, 100);
glVertex2d(-250, -100);
glVertex2d(250, -100);
glColor3ub(200, 55, 55);
glVertex2d(200, 50);
glVertex2d(-200, 50);
glVertex2d(-200, -50);
glVertex2d(200, -50);
glColor3ub(255, 0, 0);
glVertex2d((((400 * i) / size) - 200), 50);
glVertex2d(-200, 50);
glVertex2d(-200, -50);
glVertex2d((((400 * i) / size) - 200), -50);
glEnd();
glFlush();
SDL_GL_SwapBuffers();
}
if(Lignes.size() >= Lignes.max_size()) return;
Lignes.resize(Lignes.size() + 3);
Lignes.at(Lignes.size() - 3).x2 = Lignes.at(i).x2;
Lignes.at(Lignes.size() - 3).y2 = Lignes.at(i).y2;
Lignes.at(Lignes.size() - 3).x1 = Lignes.at(i).x1 + (2 * (Lignes.at(i).x2 - Lignes.at(i).x1) / 3);
Lignes.at(Lignes.size() - 3).y1 = Lignes.at(i).y1 + (2 * (Lignes.at(i).y2 - Lignes.at(i).y1) / 3);
Lignes.at(i).x2 = Lignes.at(i).x1 + ((Lignes.at(i).x2 - Lignes.at(i).x1) / 3);
Lignes.at(i).y2 = Lignes.at(i).y1 + ((Lignes.at(i).y2 - Lignes.at(i).y1) / 3);
//Le triangle
double angle = acos((Lignes.at(i).x2-Lignes.at(i).x1)/sqrt((Lignes.at(i).x2-Lignes.at(i).x1)*(Lignes.at(i).x2-Lignes.at(i).x1) + (Lignes.at(i).y2-Lignes.at(i).y1)*(Lignes.at(i).y2-Lignes.at(i).y1)));
if((Lignes.at(i).y2-Lignes.at(i).y1) < 0) angle = -angle;
Lignes.at(Lignes.size() - 2).x1 = Lignes.at(i).x2;
Lignes.at(Lignes.size() - 2).y1 = Lignes.at(i).y2;
Lignes.at(Lignes.size() - 1).x1 = ((Lignes.at(i).x2 + Lignes.at(Lignes.size() - 3).x1) / 2) + (cos(angle+pi/2)*sqrt((Lignes.at(i).x2-Lignes.at(i).x1)*(Lignes.at(i).x2-Lignes.at(i).x1)+(Lignes.at(i).y2-Lignes.at(i).y1)*(Lignes.at(i).y2-Lignes.at(i).y1)));
Lignes.at(Lignes.size() - 1).y1 = ((Lignes.at(i).y2 + Lignes.at(Lignes.size() - 3).y1) / 2) + (sin(angle+pi/2)*sqrt((Lignes.at(i).x2-Lignes.at(i).x1)*(Lignes.at(i).x2-Lignes.at(i).x1)+(Lignes.at(i).y2-Lignes.at(i).y1)*(Lignes.at(i).y2-Lignes.at(i).y1)));
Lignes.at(Lignes.size() - 2).x2 = Lignes.at(Lignes.size() - 1).x1;
Lignes.at(Lignes.size() - 2).y2 = Lignes.at(Lignes.size() - 1).y1;
Lignes.at(Lignes.size() - 1).x2 = Lignes.at(Lignes.size() - 3).x1;
Lignes.at(Lignes.size() - 1).y2 = Lignes.at(Lignes.size() - 3).y1;
}
}
int main(int argc, char *argv[])
{
LireFichier();
double Zoom = 1.0, OffsetX = 0.0, OffsetY = 0.0;
SDL_Init(SDL_INIT_VIDEO);
SDL_EnableKeyRepeat(50, 50);
SDL_WM_SetCaption("Fractale", NULL);
SDL_SetVideoMode(600, 600, 32, SDL_OPENGL | SDL_GL_DOUBLEBUFFER);
bool continuer = true, Redessine = true;
SDL_Event event;
glClearColor(1, 1, 1, 1);
glColor3ub(0, 0, 0);
glViewport(0, 0, (GLsizei) 600, (GLsizei) 600);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D((GLdouble)-300, (GLdouble)300, (GLdouble)-300, (GLdouble)300);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
while (continuer)
{
while(!Redessine)
{
while(SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_QUIT:
continuer = false;
Redessine = true;
break;
case SDL_KEYDOWN:
if(event.key.keysym.sym == SDLK_ESCAPE)
{
continuer = false;
Redessine = true;
}
if(event.key.keysym.sym == SDLK_RETURN)
{
Calcul();
Redessine = true;
char titre[100];
sprintf(titre, "Fractale - Nombre de lignes : %d", Lignes.size());
SDL_WM_SetCaption(titre, NULL);
}
if(event.key.keysym.sym == SDLK_PAGEUP)
{
Zoom *= 1.1;
Redessine = true;
}
if(event.key.keysym.sym == SDLK_PAGEDOWN)
{
Zoom *= .9;
Redessine = true;
}
if(event.key.keysym.sym == SDLK_UP)
{
OffsetY -= 10/Zoom;
Redessine = true;
}
if(event.key.keysym.sym == SDLK_DOWN)
{
OffsetY += 10/Zoom;
Redessine = true;
}
if(event.key.keysym.sym == SDLK_LEFT)
{
OffsetX -= 10/Zoom;
Redessine = true;
}
if(event.key.keysym.sym == SDLK_RIGHT)
{
OffsetX += 10/Zoom;
Redessine = true;
}
break;
case SDL_ACTIVEEVENT:
Redessine = true;
break;
}
}
if(!Redessine && continuer) SDL_Delay(50);
}
if(continuer)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3ub(0, 0, 0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glScaled(Zoom, Zoom, 1.0);
glTranslated(-OffsetX, -OffsetY, 0.0);
glBegin(GL_LINES);
for(int i = 0; i < Lignes.size(); i++)
{
if(i % 1000 == 0)
{
glFlush();
}
glVertex2d(Lignes[i].x1, Lignes[i].y1);
glVertex2d(Lignes[i].x2, Lignes[i].y2);
}
glEnd();
glFlush();
SDL_GL_SwapBuffers();
Redessine = false;
}
}
SDL_Quit();
return 0;
}

#include <SDL/SDL.h>

#include <SDL/SDL_opengl.h>

#include <GL/gl.h>

#include <GL/glu.h>



#include <stdio.h>

#include <stdlib.h>

#include <stdexcept>

#include <string>

#include <vector>

#include <math.h>

#include <fstream>



using namespace std;



const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067;



class Ligne

{

	public:

		double x1, y1, x2, y2;

};



vector<Ligne> Lignes;



int Split(vector<string>* vecteur, string chaine, char separateur)

{



    vecteur->resize(1);

    vecteur[0].empty();



    int longeur = chaine.length();



    for(int i = 0; i < longeur; ++i)

    {



        if(chaine.at(i) == separateur)

        {

            vecteur->resize(vecteur->size() + 1);

        }

        else

        {

            vecteur->at(vecteur->size() - 1).resize(vecteur->at(vecteur->size() - 1).size() + 1);

            vecteur->at(vecteur->size() - 1).at(vecteur->at(vecteur->size() - 1).size() - 1) = chaine.at(i);

        }



    }



    return vecteur->size();



}



void LireFichier()

{

	ifstream fichier("geo.frac");

	//Lecture du fichier

	string Fichier, Ligne;

	vector<string> Parties;

	char ch;

	

	while(fichier.get(ch))

      Fichier += ch;

   

   int nblignes = Split(&Parties, Fichier, '\n');

   for(int i = 0; i < nblignes; i++)

   {

		Ligne = Parties[i];

		if(Ligne[Ligne.size() - 1] == '\r') Ligne.erase(Ligne.size() - 1);

		if((Ligne[0] != '/') && (Ligne[1] != '/'))

		{

			vector<string> SousParties, SousPartiesDebut, SousPartiesFin;

			if((Split(&SousParties, Ligne, '>') == 2) && (Split(&SousPartiesDebut, SousParties[0], ',') == 2) && (Split(&SousPartiesFin, SousParties[1], ',') == 2))

			{

				Lignes.resize(Lignes.size() + 1);

				Lignes[Lignes.size() - 1].x1 = atoi(SousPartiesDebut[0].c_str());

				Lignes[Lignes.size() - 1].y1 = atoi(SousPartiesDebut[1].c_str());

				Lignes[Lignes.size() - 1].x2 = atoi(SousPartiesFin[0].c_str());

				Lignes[Lignes.size() - 1].y2 = atoi(SousPartiesFin[1].c_str());

			}

		}

	}

	

}



void Calcul()

{

	Uint32 temps = 0;

	int size = Lignes.size(); 

	

	glMatrixMode(GL_MODELVIEW);

	glLoadIdentity();

	

	for(int i = 0; i < size; i++)

	{

		if(temps + 50 < SDL_GetTicks())

		{

			temps = SDL_GetTicks();

			glBegin(GL_QUADS);

				glColor3ub(0, 0, 255);

				glVertex2d(250, 100);

				glVertex2d(-250, 100); 

				glVertex2d(-250, -100); 

				glVertex2d(250, -100); 

				

				glColor3ub(200, 55, 55);

				glVertex2d(200, 50);

				glVertex2d(-200, 50); 

				glVertex2d(-200, -50); 

				glVertex2d(200, -50); 	

				

				glColor3ub(255, 0, 0);

				glVertex2d((((400 * i) / size) - 200), 50);

				glVertex2d(-200, 50); 

				glVertex2d(-200, -50); 

				glVertex2d((((400 * i) / size) - 200), -50); 	

			glEnd();

			

			glFlush();

      	SDL_GL_SwapBuffers();

		}

		

		if(Lignes.size() >= Lignes.max_size()) return;

		Lignes.resize(Lignes.size() + 3);

		

		Lignes.at(Lignes.size() - 3).x2 = Lignes.at(i).x2;

		Lignes.at(Lignes.size() - 3).y2 = Lignes.at(i).y2;

		

		Lignes.at(Lignes.size() - 3).x1 = Lignes.at(i).x1 + (2 * (Lignes.at(i).x2 - Lignes.at(i).x1) / 3);

		Lignes.at(Lignes.size() - 3).y1 = Lignes.at(i).y1 + (2 * (Lignes.at(i).y2 - Lignes.at(i).y1) / 3);

		

		Lignes.at(i).x2 = Lignes.at(i).x1 + ((Lignes.at(i).x2 - Lignes.at(i).x1) / 3);

		Lignes.at(i).y2 = Lignes.at(i).y1 + ((Lignes.at(i).y2 - Lignes.at(i).y1) / 3);

		

		//Le triangle

		double angle = acos((Lignes.at(i).x2-Lignes.at(i).x1)/sqrt((Lignes.at(i).x2-Lignes.at(i).x1)*(Lignes.at(i).x2-Lignes.at(i).x1) + (Lignes.at(i).y2-Lignes.at(i).y1)*(Lignes.at(i).y2-Lignes.at(i).y1)));

		if((Lignes.at(i).y2-Lignes.at(i).y1) < 0) angle = -angle;

		

		Lignes.at(Lignes.size() - 2).x1 = Lignes.at(i).x2;

		Lignes.at(Lignes.size() - 2).y1 = Lignes.at(i).y2;

		

		Lignes.at(Lignes.size() - 1).x1 = ((Lignes.at(i).x2 + Lignes.at(Lignes.size() - 3).x1) / 2) + (cos(angle+pi/2)*sqrt((Lignes.at(i).x2-Lignes.at(i).x1)*(Lignes.at(i).x2-Lignes.at(i).x1)+(Lignes.at(i).y2-Lignes.at(i).y1)*(Lignes.at(i).y2-Lignes.at(i).y1)));

		Lignes.at(Lignes.size() - 1).y1 = ((Lignes.at(i).y2 + Lignes.at(Lignes.size() - 3).y1) / 2) + (sin(angle+pi/2)*sqrt((Lignes.at(i).x2-Lignes.at(i).x1)*(Lignes.at(i).x2-Lignes.at(i).x1)+(Lignes.at(i).y2-Lignes.at(i).y1)*(Lignes.at(i).y2-Lignes.at(i).y1)));

		

		Lignes.at(Lignes.size() - 2).x2 = Lignes.at(Lignes.size() - 1).x1;

		Lignes.at(Lignes.size() - 2).y2 = Lignes.at(Lignes.size() - 1).y1;

		

		Lignes.at(Lignes.size() - 1).x2 = Lignes.at(Lignes.size() - 3).x1;

		Lignes.at(Lignes.size() - 1).y2 = Lignes.at(Lignes.size() - 3).y1;

		

		

	}

	

}



int main(int argc, char *argv[])

{

	LireFichier();

	

	double Zoom = 1.0, OffsetX = 0.0, OffsetY = 0.0;

	

   SDL_Init(SDL_INIT_VIDEO);

   SDL_EnableKeyRepeat(50, 50);

   SDL_WM_SetCaption("Fractale", NULL);

   SDL_SetVideoMode(600, 600, 32, SDL_OPENGL | SDL_GL_DOUBLEBUFFER);

   bool continuer = true, Redessine = true;

   SDL_Event event;

   

   glClearColor(1, 1, 1, 1);

   glColor3ub(0, 0, 0);

    

	glViewport(0, 0, (GLsizei) 600, (GLsizei) 600);

	glMatrixMode(GL_PROJECTION);

	glLoadIdentity();

	gluOrtho2D((GLdouble)-300, (GLdouble)300, (GLdouble)-300, (GLdouble)300);

	glMatrixMode(GL_MODELVIEW);

	glLoadIdentity(); 



   while (continuer)

   {

   	while(!Redessine)

   	{

			while(SDL_PollEvent(&event))

			{

		   	switch(event.type)

		   	{

		   		case SDL_QUIT:

		         	continuer = false;

						Redessine = true;

						break;

		         	

			      case SDL_KEYDOWN:

						if(event.key.keysym.sym == SDLK_ESCAPE)

						{

							continuer = false;

							Redessine = true;

						}

						

						if(event.key.keysym.sym == SDLK_RETURN) 

						{

							Calcul();

							Redessine = true;

							char titre[100];

							sprintf(titre, "Fractale - Nombre de lignes : %d", Lignes.size());

							SDL_WM_SetCaption(titre, NULL);

							

						}

						

						if(event.key.keysym.sym == SDLK_PAGEUP)

						{

							Zoom *= 1.1;

							Redessine = true;

						}

						

						if(event.key.keysym.sym == SDLK_PAGEDOWN)

						{

							Zoom *= .9;

							Redessine = true;

						}

						

						if(event.key.keysym.sym == SDLK_UP)

						{

							OffsetY -= 10/Zoom;

							Redessine = true;

						}

						

						if(event.key.keysym.sym == SDLK_DOWN)

						{

							OffsetY += 10/Zoom;

							Redessine = true;

						}					

						

						if(event.key.keysym.sym == SDLK_LEFT)

						{

							OffsetX -= 10/Zoom;

							Redessine = true;

						}	

						

						if(event.key.keysym.sym == SDLK_RIGHT)

						{

							OffsetX += 10/Zoom;

							Redessine = true;

						}	

						

						break;

				

					case SDL_ACTIVEEVENT:

						Redessine = true;

						break;

			   }

	      }

	      if(!Redessine && continuer) SDL_Delay(50);

		}

		

		if(continuer)

		{



		   glClear(GL_COLOR_BUFFER_BIT);

		   glColor3ub(0, 0, 0);

		   

		   glMatrixMode(GL_MODELVIEW);

			glLoadIdentity();

			

			glScaled(Zoom, Zoom, 1.0);

			glTranslated(-OffsetX, -OffsetY, 0.0);



		   glBegin(GL_LINES);

		   	for(int i = 0; i < Lignes.size(); i++)

		   	{

		   		if(i % 1000 == 0)

		   		{

		   			glFlush();

		   		}	

					glVertex2d(Lignes[i].x1, Lignes[i].y1);

					glVertex2d(Lignes[i].x2, Lignes[i].y2);

				}

		   glEnd();



		   glFlush();

		   SDL_GL_SwapBuffers();

		   

		   Redessine = false;

		   

      }

   }



   SDL_Quit();



   return 0;

}

Conclusion

Voilà si vous avez des remarques, commentaires n'hésitez pas!

Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Fractale.exx1 952 334 octets
Fractales47 200 octets
geo.frac343 octets
geo.frac.2343 octets
main.cpp 7 543 octets
main.o24 763 octets
Makefile.win1 067 octets
Projet1.dev1 038 octets
Projet1.ico 766 octets
Projet1_private.h 642 octets
Projet1_private.rc 864 octets
Projet1_private.res1 876 octets
SDL.dll258 048 octets

Télécharger le zip

Historique

30 décembre 2007 14:02:39 :: Modification selon les commentaires retournés sur la source ... Modification du maximum de points! Modification de la constante de pi!
12 janvier 2008 19:12:35 :: Rajout du zoom dans la fractale... Utiliser les touches Gauche, Droite, Haut, Bas, Page Précédente et Page Suivante.

Sources du même auteur

SPLIT EN C++ AVEC LES CONTENEURS STANDARD

[TPE] MINI LOGICIEL DE MODIFICATION D'IMAGES AVEC SDL

ALGORYTHME DE CLIPPAGE D'IMAGE DANS DIRECTDRAW 7 (COMPTATIBL...

Toutes les sources de CChargy

Sources de la même categorie

AFFICHER DES COURBES DE BEZIER par shorzy

BASE/MOTEUR 3D EN QT/OPENGL (COMPLET ET FONCTIONNEL!) POUR U... par envi33

CLASSE AVEC OPENGL - OBJETS 3D ET ANIMATIONS par rasta63

LETTRES 3D AVEC OPENGL ET QT par opossum_farceur

CUBE 3D GLUT32 VC++ ET DEVC++ par bobby03

Toutes les sources de la catégorie OpenGL

Sources en rapport avec celle ci

COVERJUKE (COVERFLOW CLONE POUR WINDOWS EN OPENGL) par mik

FRACTALES DE JULIA ET MANDELBROT EN SDL par patarotalexandre

XTENGINE - MOTEUR 3D BASÉ SUR OPENGL, GLEW ET LA SDL par XT95

FPS EN RÉSEAU par D6R26H59P

FRACTALE TRES SIMPLE par Abrahamz

Commentaires et avis

Commentaire de tit_toinou le 28/12/2007 17:02:13 10/10

Salut,
très belle fractales de Koch.
En fait le principe c'est qu'on remplace toutes les ligne droite
______ par __/\__ !

Juste une petite question : pourquoi utilise-tu OpenGL ? SDL ne suffit pas pour tracer des lignes ?

10/10 programme qui fait ce qu'on lui demande.

Commentaire de CChargy le 28/12/2007 17:07:29

OpenGl c'est juste parce que je suis en train de l'apprendre et puis c'est plus rapide que SDL (vu que c'est du matériel normalement et pas du logiciel).
Dans la barre de titre figure le nombre de lignes affichés à l'écran.
C'est limité à 65000 et des brouettes (2^32)(A cause de l'index du vector qui est un int soit de - 65000 0 + 65000). Donc cela signifie que mon programme doit pouvoir afficher un peu plus de 65000 lignes, presque rien pour OpenGL (penser aux grosses scènes des jeux vidéos modernes). C'est vrai que je n'ai pas tester avec du SDL pur mais je pense qu'il doit y passer un certain temps.

Voilà
Merci du commentaire!
A+
Bonne prog ;)

Commentaire de luhtor le 28/12/2007 17:40:06

"vu que c'est du matériel normalement et pas du logiciel"
=> Manque de bol, la carte graphique ne fait que du FLOAT, donc tous tes appels "glVertex2d" sont d'abord convertis en FLOAT par le CPU ! Donc tu auras des perfs horribles avec ton programme. Des que tu vas atteindre quelques dizaines de milliers de poly, ca va commencer à ramer.

De deux, les glVertex* c'est plus a utilisé. Tout facon, ca disparait dans la nouvelle version d'opengl. Ces fonctions sont catastrophiques pour les performances. Donc en conclusion, faire du pure hardware en opengl, c'est délicat...

Autrement remarque, un short = -+ 65000. Un int, c'est en milliards...

Commentaire de tit_toinou le 28/12/2007 17:49:50

Avec SDL ca ne devrait pas être beaucoup plus long pour les premières itérations, après mieux vaut utiliser OpenGL..
Si j'ai bien compris, tu ouvre une fenetre avec SDL et tu affiche tout (tracer les lignes quoi) avec OpenGL ?

65 536 correspond à 2^16, donc une variable codée sur 2octets (un short) ! un signed int va de -2147483648 à 2147483647.
L'index est toujours positif, non ? Changes int pour unsigned int ! tu pourras aller deux fois plus loin.

Je ne sais pas pourquoi je dis ca car de toute facon au dessus de 4096 je ne vois pas la difference !

Il existe des variantes de la courbe de Koch : flocon de Koch (même règles mais on commence avec un triangle)

Pour améliorer ton programme tu pourrais enregistrer une suite de bitmap dans un dossier pour faire une mini animations :)
Sinon tu pourrais aussi afficher le nombre d'itérations dans la barre de titre (qui est facilement devinable à partir du nombre de lignes mais bon .. c'est une petite amélioration quoi)

Commentaire de CChargy le 28/12/2007 18:43:20

Luhtor =>
Le "ramage" de mon programme n'est pas très grave, c'est pas du temps réel! (C'est bon a savoir pour les jeux que je programme).
Par contre ton histoire de glVertex* plus utilisé sa m'intéresse. J'ai acheter cet été le bible d'OpenGL 2.0, dans lequel glVertex* est encore utilisé.

Tit_toinou=>
Oui et oui (à tes deux première phrases).

Là, je vais demander aux experts en quoi sont typés les index des vector de la librairies standard...

Si tu change geo.frac tu peux créer le flocon, le programme a été prévu pour sa au départ.
Toutes les infos sont sur le lien
http://colin.chargy.free.fr/Wiki/index.php?title=Fractale

Je pense effectivement fortement à créer un raccourci clavier pour sauvegarder en bmp l'image affichée à l'écran!
Il est très simple aussi d'indiquer le nombre d'itérations dans la barre de titre.

Merci encore!
Bonne prog!

Commentaire de luhtor le 28/12/2007 19:49:01

CChargy : Je parle de la dernière version d'openGL : "Opengl 3"
Mais il y aurait encore un support des fonctions à la con (ex: glVertex) pendant quelques temps je crois.

Commentaire de CChargy le 28/12/2007 20:38:42

OK! Pardon...
Mais alors c'est remplacer par quoi ?
Je m'avoue surpris!

Commentaire de luhtor le 28/12/2007 21:13:19

Remplacé par rien. A jeter ces fonctions. Pour afficher, c'est:
glDrawElements
glDrawRangeElements

et rien d'autre.

Commentaire de CChargy le 28/12/2007 22:18:54

Ok je me renseignerait!
Merci pour l'info!
Bonne nuit

Commentaire de JCDjcd le 29/12/2007 18:35:13

const double pi = 4.0*atan(1.0);

bof de chez bof !

Commentaire de CChargy le 29/12/2007 18:52:44

ah bon!
Et pourquoi?
Je croyais que c'était ce qu'il y avait de plus précis...
En tout cas mathématiquement parlant c'est juste.

Commentaire de juju12 le 29/12/2007 19:12:15

Oui mais tant de précision est inutile...tu crois vraiment avoir besoin du 45ème chiffre après la virgule? D'autant plus que la fonction atan() va elle-même te retourner un résultat d'une précision limitée alors autant mettre tout de suite :
#define PI (3.1416)

Commentaire de CChargy le 29/12/2007 20:04:13

Non j'en ai pas forcément besoin mais ça ne change rien, ni au niveau rapidité d'exécution, ni au niveau difficulté de codage. Donc j'utilise la méthode la plus précise. Et sa permet de rappeller a qui lira le code que tan(pi/4) = 1...

Commentaire de JCDjcd le 30/12/2007 12:16:51

oui mais tu depends de la fonction tan... rien te dit qu'elle te donnera toutes les decimales de juste !
et il existe beaucoup d'autre formule que celle la pour pi... alors pourquoi priviligier celle la plutot qu'une autre !
n'oublions surtout pas que c'est un double, donc on connait le nombre de decimales a collees en dur...

bref ca ne se fait pas, c'est comme ca !!!!

Commentaire de CChargy le 30/12/2007 13:41:27

Oulla je te trouve bien sévère...
Moi je dis que ça se fait et c'est plus précis que #define PI (3.1416)...
Je ne effectivement aucune raison de privilégié cette formule là par rapport au autres, si tu m'en trouve une meilleure je prends...

"n'oublions surtout pas que c'est un double, donc on connait le nombre de decimales a collees en dur..."
euh sa ne dépend pas de l'implémentation ?!?

Enfin toujours est-il que l'on chipote pour pas grand chose je trouve...

Bref, il faut que je change le nombre de lignes maximum ....

Commentaire de CChargy le 30/12/2007 14:06:44

Enfin toujours est-il que j'ai modifier mon code en conséquence de vos remarques ...
Les 100 décimales de pi sont dédicacés à JCDjcd ... Même si je suis d'accord que même 10 aurait suffis ...

Bonne prog !

Commentaire de BruNews le 30/12/2007 14:30:38 administrateur CS

Le compilo ne les garde pas alors tu peux réduire la taille du code.

Commentaire de JCDjcd le 30/12/2007 23:40:17

merci pour la dedicace ... j'en suis tres flatte !
c'est pas mechant ce que je dis (quand je le suis c'est beaucoup plus vache, et ca se sent... j'ai un sale caractere parait-il... ^^)

bon maintenant un peu de math : mantisse du double est de 52 bits (c'est dans le C standard, c'est fixe ca ne changera jamais quelque soit l'implementation), donc comme log10(2)*52=16 (arrondi superieur), il suffit de mettre seulement 16 decimales !

Commentaire de tit_toinou le 31/12/2007 00:36:28

JCDjcd : j'ai appris de "source sûre" ;) que le standard IEEE (pas le langage C !) pour le format double est de 52 bits stockés + un 1 implicite (à gauche de la virgule) qui n'est pas stocké. Il y a donc en réalité 53 bits de précision...

Commentaire de BruNews le 31/12/2007 01:27:30 administrateur CS

Non, ce sont les 52 bits de mantisse qui donnent la précision et ce sur quoi on calcule.

Commentaire de CChargy le 31/12/2007 10:02:06

De rien pour la dédicace ...
Je suis moi même très flatté car dans ce code, pour la première fois que je pose un code sur code-source, on ne remet pas en cause la totalité du code ...
C'est déjà un point positif!

Je n'ai pas compris ton histoire de math. Je suis en Term S et on vient juste de faire les log donc sa m'intéresse d'avoir un peu d'explication. Ton log10(), c'est bien log et pas ln ? Ou c'est encore autre chose? Et au juste c'est quoi que tu cherche? Le nombre de décimales qui ne seront jamais prises en compte pour le calcul ?

Voilà si tu pouvais m'aider ...

Sinon vous pourrez sûrement m'aider sur cette question : Je me suis mis à la programmation réseau (socket, client, serveur et tutti quanti). Je cherche à savoir si tout les types de variables (en C++: int, char, bool, double et les classes) sont codés de la même manière et sur le même nombre d'octets sur tous les ordinateurs (pc ou mac), (16, 32 ou 64 bits) et sur tous les systèmes d'exploitation (Windows/Linux/BeOs ....) et pour tous les compilateurs.

Voilà merci d'avance

Commentaire de JCDjcd le 31/12/2007 18:17:32

>> Tit_Toinou : tu diras boujour a ta source sure ^^ meme un gros bisou baveux si tu en as envie ! le bit implicite a gauche de la virgule est toujours 0 (sauf dans le cas 1.000), donc pour le calcul c'est bien 52 qu'il faut prendre ! (cf. une de mes sources qui a ete supprimee ( :-( ) sur l'associativite de l'operation + des flottants)

>> CChargy : ben log c'est le logarithme a base 10, mais on a la formule log10(x)=ln(x)/ln(10), ln etant le logarithme naturel
le 16=52*log10(2) correspond aus nombres de decimales stockees en machine, les suivantes sont oubliees, c'est une troncature que l'on effectue (enfin pas nous, le processeur)

Commentaire de darunia le 01/01/2008 13:45:18

Au risque de passer pour un idiot ...... a quoi ça sert les fractales ???
C'est vrai qu'on voit pas mal de source à ce sujet mais finalement je me suis jamais posé la question.

Commentaire de tit_toinou le 01/01/2008 15:23:29

Salut,
JCDjcd : la "source sûre" est complètement sure d'avoir raison ! le bit implicite est presque toujours (souligné,gras,rouge,police taille 72) à 1 !
Je laisse la parole à la "source sûre" car je suis incompétent...

double pi = 3.14159265358979323846264338327950;
Hexadecimal pour pi : 0x400921fb54442d18
Idem avec espaces (police non proportionnelle utile ici)
                 4   0    0    9   2    1    f     b    5    4    4    4    2    d    1    8
Binaire     : 0100 0000 0000 1001 0010 0001 1111 1011 0101 0100 0100 0100 0010 1101 0001 1000
Format IEEE 754 pour flottant 64 bits
1<---11----><---------------------52--------------------------->
SEEEEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
Avec S = le signe du nombre, EE l'exposant en base 2 (biasé / décalé de 1023) et MMM un nombre de 52 bits qui est la mantisse
Le nombre représenté QUAND l'exposant EE n'est pas aux deux extremes (0 ou 2047) est au signe +/- près (suivant que S vaut 0 resp. 1) la valeur positive suivante :
  (1+M*2^-52)*2^(E-1023) <= le (1+...) represente le bit implicite qui est à 1 et non pas 0
Application numérique pour Pi : S = 0 <=> +1, E = 1024, M = 0x921fb54442d18 = 2570638124657944 en décimal
D'où Pi ~= (1+0.57079632679489655799898173427209)*2^(1024-1023), CQFD
Le cas 'normal' := (0 != EE && 2047 != EE) est bien avec le bit implicite à 1, c'est le zéro qui est un nombre 'denormal' a savoir dénormalisé pour lequel l'exposant est au minimum à savoir zero, soit une puissance de 2 qui vaut (0-1023) = -1023. Pour ces nombres 'denormal' avec EE = 0, la règle est que le 1 caché disparait et M contient toute l'info i.e. (0+M*2^-52)*2^-1022; ca fatigue le co-processeur flottant car il lui faut des cycles supplémentaires pour remettre tout ca au carré, et c'est pour ça que quand on veut que ça pédale vite, on active l'option de contrôle 'flush denormal to zero' (par exemple le code SSE qui doit aller  vite, les cartes graphiques ont des multiplieurs flottants 'simplifiés' qui ont ce comportement cablé en dur etc...). Quand l'exposant EE est au max 2047, on a affaire à un nombre 'spécial', il y en a des tas (les deux infinis ont M = 0), y compris des NaN := 'Not a Number', les 'quiet' qui ne declenchent pas d'exception ont le bit de poids fort de M a 1, les 'signalling' l'ont à 0 mais M n'est pas nul pour autant.

Voilà, fin du tuto sur les nombres flottants IEEE (c'est en gros pareil pour les 'float' 32 bits avec 8 bits d'exposant et 23 bits de mantisse, ce qui donne 24 bits de précision)...

Commentaire de JCDjcd le 01/01/2008 19:30:03

mais oui, une petite erreur d'etourderie, mais bref sauf pour me contredire et me faire admettre que j'ai tord (je m'y resouds, mais c'est trez clair dans ma petite tete), le principe est la et c'est bien 52 qu'il faut prendre en compte.
Je me corrige : Le bit implicite est a 1 sauf dans le cas 0.0000 et les inifinis, NAN...

TitToinou : tu es tres cultive...

Commentaire de tit_toinou le 01/01/2008 22:42:12

Au contraire, je ne le suis pas assez pour connaître tout cela ; comme je l'ai dit, j'ai laissé la parole à qqun d'autre (qui ne souhaitait pas créér un compte mais voulait juste poster une explication)

D'ailleurs, comme tu le fais si bien remarquer : tout ceci n'a d'intérêt que dans la mesure où tu as tort, et qu'il fallait le démontrer :P !

Juste une petite chose : (d'après ce que j'ai compris..) si on ne comptait pas ce bit implicite lors de la conversion binaire-decimal d'un double, tout le calcul ne marcherait pas !
(dans le calcul Pi ~= (1+0.57079632679489655799898173427209)*2)

Enfin bon, la personne qui voulait absolument te transmettre ce message est très têtue..

Commentaire de BruNews le 01/01/2008 22:54:11 administrateur CS

0.57079632679489655799898173427209
parce que qlq'un arrivera à rentrer ça en FPU ???
Jette un oeil sur le listing asm du compilo pour voir ce qu'il en reste.

Commentaire de tit_toinou le 02/01/2008 21:43:48

Je relaisse la parole à la "source sûre".

"rentrer ça en FPU ???" : ben oui, et ca donne le résultat déjà mentionné à savoir 0x400921fb54442d18. En fait il manquait 20 chiffres décimaux : il faut hélas 52 chiffres décimaux pour représenter *exactement* en base 10 un nombre binaire à 52 bits, la version complète est en fait
+0.5707963267948965579989817342720925807952880859375000
Comme le compilateur est bien écrit (on peut l'espérer), il convertit sans erreur ce nombre exactement exprimable en format IEE-754. Certes, on peut obtenir la meme valeur avec nettement moins de chiffres, mais aussi avec nettement moins de certitudes...

Pour la petite histoire 52 versus 53 bits, le format natif 80 bits du coprocesseur X87 adopte l'autre convention, avec 64 bits de mantisse mais incluant le 1 explicitement mémorisé (pour les nombres 'normal'). Si on compare des choses comparables, les précisions disponibles sont

80 bits 'long double' 64 bits 'double' 32 bit 'float'
64/63 53/52 24/23

Il est d'usage de dire que le format 80 bits a 64 bits de précision, donc pour etre homogène, le format 64 bits a 53 bits de precision. On peut adopter l'autre convention et dire que le format 80 bits a 63 bits de precision tandis que le format 64 bits a 52 bits de précision.

Commentaire de tit_toinou le 02/01/2008 21:54:55

Salut,
là c'est moi qui parle,
pour en revenir au sujet : CChargy, tu pourrais mettre une touche pour qu'on puisse zoomer dans la fractale (une super amélioration !)

Commentaire de BruNews le 02/01/2008 22:19:35 administrateur CS

#include <windows.h>
#include <stdio.h>

double dA = 0.57079632679489655799898173427209;
double dB = 0.57079632679489655;

char szappname[] = "ACHANGER";

void Tester()
{
  char buf[24];
  sprintf(buf, "", dA);
  MessageBox(0, buf, szappname, 0);
  sprintf(buf, "", dB);
  MessageBox(0, buf, szappname, 0);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE x, PSTR y, int z)
{
  Tester();
  return 0;
}

ASM COMPILO:
_dA DQ 03fe243f6a8885a30r
_dB DQ 03fe243f6a8885a30r
etc, etc.

Toutes ces décimales sont intraduisibles, c'est indiqué dans toutes les docs Intel autant que MS. Aucune raison de s'enliser ainsi, on n'a que rarement raison contre tous, faut s'y faire.

Commentaire de SourceSure le 03/01/2008 02:11:05

Mea culpa pour l'ambiguité, voilà qui va tout éclairer. Pi, Pi-1 et (Pi-1)/2 ont quand meme quelques petites differences, mais nous autres pauvres humains ne savons pas bien decaler d'un bit en base 16 de tete :

#include <stdio.h>

double Pi     = 3.14159265358979323846264338327950;
double PiM1   = 1.57079632679489655799898173427209;
double PiM1S2 = 0.57079632679489655799898173427209;

int main(int argc,char *argv[])
{
printf(" Pi      = %.16lf, 0x%16I64X\n",Pi    ,Pi    );
printf(" Pi-1    = %.16lf, 0x%16I64X\n",PiM1  ,PiM1  );
printf("(Pi-1)/2 = %.16lf, 0x%16I64X\n",PiM1S2,PiM1S2);
printf("     0x121FB54442D18 << 1    = 0x%16I64X\n",0x121FB54442D18i64 << 1);
return  0;
} // main()
/*
Pi      = 3.1415926535897931, 0x400921FB54442D18
Pi-1    = 1.5707963267948966, 0x3FF921FB54442D18
(Pi-1)/2 = 0.5707963267948966, 0x3FE243F6A8885A30
     0x121FB54442D18 << 1    = 0x   243F6A8885A30
*/

Comparaison n'est pas raison...

Commentaire de CChargy le 03/01/2008 14:33:42

tit_toinou, je vais y réfléchior alors ... Mais zommer ou? Au centre ? Sur certaines fractales on verrait rien ... Peut-être zommer avec le curseur ? Après pourquoi pas faire de la capture vidéo (de surperbes anims en perspective) ?
Enfin bref!

Tous vos discours m'on l'air bien compliqué je trouve ...
Enfin je laisse tomber, je laisse les as de programmation discuter tranquilou ...Bonneprog (sans trop de prise de tête a tous ...) :)

Commentaire de tit_toinou le 04/01/2008 12:28:14

Salut,
alors je voulais dire par zoomer :
une touche pour zoomer (double clique gauche, touche +..)
une touche pour dézoomer (clique droite, touche -..)
et avec la souris on se déplace dans la fractale ! (on bouge le curseur en cliquant gauche)

Tu regardes dans n'importes quel programme de fractal sur ce site et tu trouves ca !

Bon je vais te donner des fonctions utiles que j'ai trouvé dans la SDL :
SDL_SaveBMP(surface, file) : ca prend une surface et ca l'enregistre dans l'ordi en bitmap !! (c'est pile ce qu'il faut, non?)
ensuite pour savoir de combien à bougée la souris tu fait une bêbête soustraction ! Mais si la souris dépasse la fenêtre ? Pour forcer la souris à rester dans la fenêtre tu peux utiliser SDL_WM_GrabInput(SDL_GrabMode mode) (tu donne SDL_GRAB_ON je pense)
(
typedef enum {
SDL_GRAB_QUERY = -1,
SDL_GRAB_OFF = 0,
SDL_GRAB_ON = 1,
SDL_GRAB_FULLSCREEN /* Used internally */
} SDL_GrabMode;
)
avec ca l'utilisateur ne peut pas sortir !
Enfin essayes tout ca voir si ca marche ;)
De toute facon j'ai trouvé tout cela dans SDL.h, SDL_video.h etc.. donc si tu veux vraiment savoir tout ce que t'apporte la SDL faut aller voir dans les fichiers h !

Commentaire de tit_toinou le 04/01/2008 13:42:08

C'est bon je viens de tester les deux fonctions..
donc SDL_WM_GrabInput(SDL_GrabMode mode) marche mais ne sert à rien en fait : tu ne peux pas sortir le curseur de la fenêtre (même pas pour la déplacer)..
Pour SDL_SaveBMP : c'est une fonction super utile !

SDL_SaveBMP(le_nom_du_pointeur_sur_ta_surface,le_nom_du_fichier) tout simplement !
Apres pour faire une animation tu fais un sprintf() pour changer le_nom_du_fichier (genre "animation 01.bmp","animation 02.bmp" etc..)
et puis voilà ca marche y'a rien à redire, la SDL a pensée à tout !

Commentaire de CChargy le 04/01/2008 14:25:07

C'est gentils de me donner des cours de SDL mais sa devrait aller merci :)
Enfin j'espère que ça servira à quelqu'un, mais je ne connaissais pas SDL_WM_GrabInput
Je connais SDL_SaveBMP merci... Juste le bmp qui me chagrine, je vais voir du côté de OpenGL si on peux pas faire quelque chose ...
Voilà je sais pas quand j'aurais le temps de faire ces modifications ...
Bonne prog !

Commentaire de tit_toinou le 06/01/2008 20:40:11

Salut,
dsl ^^
sinon tu connais SDL_image ? (jpensait que oui mais apparemment.. non)

Commentaire de CChargy le 06/01/2008 21:22:53

Sisi je connais la SDL_Image (j'ai un TPE en première donc l'année dernière sur un logiciel de modification d'image (léger). Mais on peut charger une image et non l'enregistrer. Par contre j'avais utiliser FreeImage pour l'enregistrement... Il faut que je vérifie la portabillitée Linux de FreeImage ...
Voilà
Bonne prog!
(PS.: Je verrais ça dimanche prochain si j'ai le temps, on entre dans la période où je suis très pris ...)

Commentaire de tit_toinou le 08/01/2008 17:52:31

Salut,
ouais jme suis trompé..
Non mais à quoi cela sert BMP c'est bien..
Déjà fait des mises à jour avec animation, zoom et déplacement et après tu vois si il y a utilité à continuer les maj.

Commentaire de valirie le 18/11/2009 23:21:35

*****bon code qui donne des bon résultats,merci bcp.
en fait moi je trouve des difficultés avec ocaml, et j'ai le jeux de chessboard avec 52 cartes que je doit implémenter je suis vraiment bloqué dessus, merci de m'aider.
Cordialement
VALIRIE

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

prog d'exemple openGL + SDL [ par Arnaud16022 ] Hi!je cherche une source qui montre comment créer une fenetre, détecter les touches du clavier et les mouvements de la souris ... avec la SDL, ET d'af Configurer Borland C++ pour les librairies graphiques OPENGL et SDL [ par serialkilled ] Bonjour,J'aimerais savoir comment configurer Borland C++, quels fichiers du site de SDL et OPENGL faut il prendre et ou faut il les mettre. J'ai essay Affichage de texte avec OpenGL et SDL sans SDL_ttf [ par asmanur ] Voilà je cherche à faire un code le plus portable possible e j'aimerais afficher du texte dans une fenetre SDL & OpenGL seulement voila SD_ttf ne fonc SDL semble ne pas fonctionner ? [ par neodelphi ] Bonjour tout le monde ! Voila mon problème : je suis en train d'essayer de faire de l'openGl avec la sdl sous un système linux. Après a Tutoriaux Complet SDL OpenGL C++ [ par Fireflect ] Bonjours, Je recherche des bons tutoriaux sur le mélange OpenGL SDL C++ sans glut ou quoi que ce soit d'autre avec des sources bien optimis&#233 Différence SDL - SDL avec OpenGL et OpenGl [ par Turok ] Donc voila, j'ai recemment commencé à programmer en C++ avec SDL. La question que je me pose, en sachant que je ne veux faire que de la 2d, SDL ou OpenGL ? [ par nikoland ] Bonjour,J'aimerais votre avis concernant la programmation multimedia (jeux 2D/3D). Me conseillez-vous de coder avec la librairie SDL ou avec OpenGL ?S SDL est deformation de surface [ par wil51 ] Bonjour,Je suis actuellement sur le devellopemeny d'un jeu en 2D en SDL style GTA en vue de dessusTous est en 2D sauf les batiments qui sont 3D.Actuel texte openGL et SDL [ par vangeurmasker ] Bonjour Je cherche à afficher du texte dans une fenêtre OpenGL gérée par SDL. Mon application doit être portable sur windows [SDL - OpenGL - POO] cherche collaborateurs pour jeu 2D [ par MrdJack ] salut, je projetes de faire un jeu 2D de type bomberman/dynablaster en SDL/OpenGL/POO, je cherche des programmeurs interressé ayant juste des not

Nos sponsors

Derniers Blogs

[TECHDAYS2012] OUI J'Y SERAI! par JeremyJeanson

TFS INTEGRATION TOOLS - SUIVI DES SYNCHRONISATIONS AVEC REPORTING SERVICES par vfabing

CSS CONTENT STATE SELECTORS (PERSONNAL DRAFT) par FREMYCOMPANY

MBA : POURQUOI FAIRE ET COMMENT LE CHOISIR ? par ROMELARD Fabrice

Y'A DES ERREURS QUI PEUVENT RENDRE LE DéVELOPPEUR VIOLENT par Aleks

Forum

RE : C++ GéNéRATEUR AUTOMATIQUE DE PHRASES . RéMUNéRé par sabristi75

RE : ARBRE BINAIRE par pacotheking

RE : CODE SOURCE DE PROTOCOLE LEACH par depasage

STATUT D'UNE IMPRIMANTE PARALLELE, INPOUT32.DLL par jika1303

RE : EXTRACTION D'UNE IMAGE à PARTIR D'UNE SEQUENCE VIDEO par nessros

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Referencement SEO site Wordpress
Budget : 6 000€
TRES URGENT-Developpeur PowerBuilder - Oracle
Budget : 59 800€
Developpeur expert Joomla
Budget : 1 500€

Logiciels

Academy System (17.2.1.0)
ACADEMY SYSTEM (17.2.1.0)

Logiciel de gestion des établissements. - élèves/étudiants (inscription, dossier, absence...) -...

Cliquez pour télécharger Academy System
Easy-Planning (1.0.0.1)
EASY-PLANNING (1.0.0.1)

Basé sur les mêmes principes que MyPlanning, Easy-Planning permet de créer des plannings sous la ...

Cliquez pour télécharger Easy-Planning
COLLECTOR PLUS (3.00B)
COLLECTOR PLUS (3.00B)

COLLECTOR PLUS version 3.00B est un logiciel utilisant une base de données alimentée par : - L...

Cliquez pour télécharger COLLECTOR PLUS
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)

PONAMEDIA TV DEVIENS HELLLOOO FLASH LA TV SUR VOTRE ORDINATEUR. Toute une plateforme Multi...

Cliquez pour télécharger PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO
LettresFaciles 2011 (8.0.0.1)
LETTRESFACILES 2011 (8.0.0.1)

LettresFaciles est un logiciel facilitant la création et la rédaction de lettres types. Son inte...

Cliquez pour télécharger LettresFaciles 2011