Partage

Atelier Cod'Art

<< 1 2 3 4 ... 23 >>

5 juillet 2007 à 19:35:44

Voila ce que j'ai :
Image utilisateur

Et la code :

<?php

$taillecarre = 300;

$img = imagecreate($taillecarre, $taillecarre);
$noir = imagecolorallocate($img, 255, 255, 255);

$col_poly = imagecolorallocate($img, 0, 0, 0);

for ($a=0;$a<=$taillecarre/2;$a+=$taillecarre/100) {
imagepolygon($img, array (
   0+$a, 0,
   $taillecarre, 0+$a,
   $taillecarre-$a, $taillecarre,
0, $taillecarre-$a
   ),
   4,
   $col_poly);
}

header("Content-type: image/png");
imagepng($img);

?>

Et ca :

<?php

$a1 = -1.5;
$a2 = 0.6;
$b1 = -1.2;
$b2 = 1.2;

$zoom = 100;

$precision = 1/$zoom;

$img = imagecreate(($a2-$a1)*$zoom, ($b2-$b1)*$zoom);
$noir = imagecolorallocate($img, 0, 0, 0);

for ($a = $a1; $a<$a2; $a+=$precision) {

for ($b = $b1; $b<$b2; $b+=$precision) {

$x = 0;
$y = 0;
for ($i=0; $i<30; $i++) {

$tmp = $x;
$x = $x*$x - $y*$y + $a;
$y = 2*$tmp*$y + $b;

if (($x*$x+$y*$y) < 4) {
ImageSetPixel($img, ($a-$a1)*$zoom, ($b-$b1)*$zoom, $noir);
} else {
ImageSetPixel($img, ($a-$a1)*$zoom, ($b-$b1)*$zoom, imagecolorallocate($img, 255, 255, 255));
break;
}

}

}

}

header("Content-type: image/png");
imagepng($img);

?>

(Pour ce dernier j'ai un problème : j'aimerai bien pouvoir afficher les différentes couches de différentes couleurs, mais je n'y arrive pas. Une solution ?

bluestorm

5 juillet 2007 à 19:45:30

Citation : Zolix

Bonjour à tous

Vous avez tous fait des dessins supers sympas!
Mais on a parler d'atelier,
et comme déjà 2/3 ont demandé il me semble,
j'ai regardé vite fait le topic et pourtant,
je n'ai vu aucune explication ou tuto pour les personnes qui ne savent pas le faire!

Merci d'avance au(x) sauveur(s) =)

Regarde les codes des gens, comprends les, et lance toi !
Tu crois qu'on a suivi un tuto "comment faire une image rigolote dans le langage de mon choix" ?

Le but, c'est d'expérimenter

bracor

5 juillet 2007 à 19:47:16

Kados, ton deuxième code marche pas chez moi, mais tu peut peut-être essayer ma "méthode" (voir quelque post plus haut), histoire de...

delroth

5 juillet 2007 à 21:25:53

Je vous propose une autre sorte d'images, ce sont les premières que l'on voit dans le premier message de ce topic : les superformulas. J'ai codé un algorithme en OCaml pour les générer, les résultats sont assez bon. Vous pouvez tout trouver sur mon espace dédié à Cod'Art

Blackhole

5 juillet 2007 à 21:47:45

@bracor ==> Bien sur que son code marche, il faut juste changer la couleur du dessin

!

@Tix. ==> En PHP ( dévellopement plus rapide qu'en C ou qu'en C++, je trouve

)
Pour l'algo, voir mon premier message

Edit : Je vais me lancer dans des trucs genre Mandelbrot, maintenant

serial

5 juillet 2007 à 22:44:14

@blackhole -> euh son code marche pas chez moi non plus pour le madelbrot..je me suis pas plongé dedans mais avec un bete copier coller ca sort une image tte noire.

et sinon j'a ifait l'algo en php de la figure proposée au debut avec les cercle : www.e-caveavin.com/codart4.php?cote=600&largeur=500&n=3000

vous pouvez changer les parametre bien sur (cote = taile de limage, largeur = diametre du cercle, n = nombre de racine)

Blackhole

5 juillet 2007 à 22:50:06

...

Change la variable $noir pour qu'elle affiche du blanc, ou définie une autre couleur juste au dessus de la définition de $noir, tu verra bien

serial

5 juillet 2007 à 22:55:09

ben ecoute j'ai mis du gris comme ca j'ai 3 couleur, du coup j'ai une image tte noir lol

voila mon code (enfin son code modifié):

<?php

$a1 = -1.5;
$a2 = 0.6;
$b1 = -1.2;
$b2 = 1.2;

$zoom = 100;

$precision = 1/$zoom;

$img = imagecreate(($a2-$a1)*$zoom, ($b2-$b1)*$zoom);
$noir = imagecolorallocate($img, 0, 0, 0);

for ($a = $a1; $a<$a2; $a+=$precision) {

for ($b = $b1; $b<$b2; $b+=$precision) {

$x = 0;
$y = 0;
for ($i=0; $i<30; $i++) {

$tmp = $x;
$x = $x*$x - $y*$y + $a;
$y = 2*$tmp*$y + $b;

if (($x*$x+$y*$y) < 4) {
ImageSetPixel($img, ($a-$a1)*$zoom, ($b-$b1)*$zoom, imagecolorallocate($img, 100, 100, 100));
} else {
ImageSetPixel($img, ($a-$a1)*$zoom, ($b-$b1)*$zoom, imagecolorallocate($img, 255, 255, 255));
break;
}

}

}

}

header("Content-type: image/png");
imagepng($img);

?>

bluestorm

5 juillet 2007 à 22:56:15

serial > on pourrait voir le code de la version PHP ?

edit : hum, pour le cercle

serial

5 juillet 2007 à 23:00:33

pas de prob!
code php du cercle :

<?php
header("Content-type: image/png");

if(!isset($_REQUEST['cote']))
{
$cote = 500;
}
else
{
$cote=$_REQUEST['cote'];
}
if(!isset($_REQUEST['largeur']))
{
$largeur = 400;
}
else
{$largeur=$_REQUEST['largeur'];}
if(!isset($_REQUEST['n']))
{
$n = 2000;
}
else{$n=$_REQUEST['n'];}

$image = imagecreate($cote, $cote); // On crée l'image aux dimentions voulues
imageantialias( $image, 1 );
$couleur0 = imagecolorallocate($image, 255, 255, 255); // On définie la premiere couleur (blanc)
$couleur1 = imagecolorallocate($image, 0, 0, 0); // On définie la seconde couleur (noir)

ImageEllipse ($image, $cote/2, $cote/2, $largeur, $largeur, $couleur1);

//cos(2kpi/n)+isin(nkpi/n) 0<=k<n
for($i=0;$i<$n;$i++)
{
for($j=$i+1;$j<$n;$j++)
{
if(($i*$j)%$n==1)
{
$x1=$cote/2 + $largeur/2*cos((2*$i*M_PI)/$n);
$y1=$cote/2 + $largeur/2*sin((2*$i*M_PI)/$n);
$x2=$cote/2 + $largeur/2*cos((2*$j*M_PI)/$n);
$y2=$cote/2 + $largeur/2*sin((2*$j*M_PI)/$n);

ImageLine ($image, $x1, $y1, $x2, $y2, $couleur1);
}
}
}

imagepng($image);
imagedestroy( $image );

?>

pourrais tu me passer le code pour un mandelbrot qui marche stp?

Locke

5 juillet 2007 à 23:40:11

(bon je sais pas si c'est mieux ici où dans l'autre topic sur le triangle de Sierpinski et dérivés, je vous laisse juges)

En partant du triangle de Sierpinski et en représentant mes triangles comme des polygones réguliers à trois côté définis par un centre et un sommet, je me suis dit : et si on "généralisait" un peu ça avec d'autres polygones réguliers ? faire un genre de carré de Sierpinski, ou même un pentagone, etc... on peut jouer sur deux facteurs : le nombre de côtés du polygone n, et un facteur k qui est, disons, la fraction représentant la distance entre le centre d'un polygone et le centre du polygone "suivant" (en terme de profondeur dans l'algorithme, si je puis dire) sur la droite centre-sommet du polygone. Enfin, c'est peut-être pas super clair comme ça, mais faites un dessin, vous verrez.

Après expérience, on remarque qu'avec k = 0.5, et n = 3 on retombe sur le triangle de Sierpinski, un résultat que je ne m'explique pas encore, je pensais que ce k aurait eut une expression un brin moins rationnelle, mais, bon.

Dès qu'on change k et/ou n, on tombe sur des résultats assez fantastiques :

k=0.3, n=3 - L'effet de flou est du à une redimention de l'image, et il rend plutôt pas mal parce qu'il faut avouer que le rendu graphique de CamlLight est assez... déplorable, quelque part
k=0.4, n=4 - Bon, d'accord, rien de très génial mais j'trouvais ça marrant. Ca serait probablement beaucoup mieux avec des couleurs de partout, mais je ne connais vraiment pas bien la librairie graphique de Caml.
k=0.2, n=5 - Ca pourrait être plus beau si on allait plus loin dans l'alhorithme, mais d'une part ça serait long (oui il est pas du tout optimisé, comme ça je dirais une complexité en O(n^m) où m est la profondeur) et d'autre part, avec caml ça donne un rendu assez ignoble si on met trop de lignes partout
k=0.5, n=5 - Histoire de voir vraiment ce que ferait un "pentagone de Sierpinski". Mais, quand k est plus petit que 0.5, en définitive, ça fait des trucs plus beau.

Bon donc euh voilà. Mon code est le suivant (et, non, je connais pas l'OCaml, c'est du Caml normal, tant pis) :

#open "graphics";;

(* la constante pi *)
let pi = 4.*.atan(1.);;

(* deux fonctions pratiques pour tracer des trucs *)
let centre = function (a,b),(c,d) -> (a+.c)/.2.,(b+.d)/.2.;;
let similitude = function (a,b),(x,y),k,theta ->
k*.((cos theta)*.(a-.x) -. (sin theta)*.(b-.y)) +. x,
k*.((cos theta)*.(b-.y) +. (sin theta)*.(a-.x)) +. y;;

(* on décurryfie un peu les fonctions caml - en profitant pour convertir les float en int *)
let placerPoint (x,y) = moveto (int_of_float x) (int_of_float y);;
let tracerLigne (x,y) = lineto (int_of_float x) (int_of_float y);;

(* trace un polygone régulier de centre w, dont un sommet est p et de n côtés *)
let polygone = function w,p,n ->
let pas = 2.*.pi/.(float_of_int n) in
placerPoint p;
for i = 1 to n do
tracerLigne (similitude (p,w,1.,(float_of_int i)*.pas));
done;;

(* la fonction proprement dite : trace en partant d'un centre w et d'un sommet p *)
let rec polys (w,p,k,n) = function
| 0 -> ()
| m -> polygone(w,p,n);
let centres = make_vect n (0.,0.) and sommets = make_vect n (0.,0.) and pas = 2.*.pi/.(float_of_int n) in
sommets.(0) <- p;
for i = 1 to n-1 do
sommets.(i) <- similitude(p,w,1.,(float_of_int i)*.pas);
centres.(i) <- centre(sommets.(i),sommets.(i-1));
done;
centres.(0) <- centre(sommets.(n-1),p);
for i=0 to n-1 do
polys (similitude(w,sommets.(i),k,0.),centres.(i),k,n) (m-1);
done;;

(* un appel pour faire exemple - ici, k=0.3 et n=3*)
open_graph("");;
polys ((300.,300.),(500.,500.),0.3,3) 10;;

Bon voilà, c'est mignon tout ça. J'ai essayé des k supérieurs à 1 aussi mais ça rend pas vraiment génialement, enfin j'ai pas trouvé. De même, prendre des polygones à plus de 6 ou 7 côtés c'est pas très intéressant.

poxbox

6 juillet 2007 à 0:23:43

Citation : Kados

Voila ce que j'ai :

Et la code :
<?php

$taillecarre = 300;

$img = imagecreate($taillecarre, $taillecarre);
$noir = imagecolorallocate($img, 255, 255, 255);

$col_poly = imagecolorallocate($img, 0, 0, 0);

for ($a=0;$a<=$taillecarre/2;$a+=$taillecarre/100) {
imagepolygon($img, array (
0+$a, 0,
$taillecarre, 0+$a,
$taillecarre-$a, $taillecarre,
0, $taillecarre-$a
),
4,
$col_poly);
}

header("Content-type: image/png");
imagepng($img);

?>

Je me suis permis de colorer un peut le code de 1506377,

Voila ce que j'ai:

Image utilisateur

Et si on rafraichi la page, on obtient des couleures différente a chaque fois, rien de plus simple que quelques bon 'rand'

Voila le code:

<?php

$taillecarre = 600;

$img = imagecreate($taillecarre, $taillecarre);
$noir = imagecolorallocate($img, 255, 255, 255);

$rand_couleur1= mt_rand(0,255);
$rand_couleur2= mt_rand(0,255);
$rand_couleur3= mt_rand(0,255);
$rand_couleur4= mt_rand(0,255);

$rand = array($col_poly1 = imagecolorallocate($img, $rand_couleur1, $rand_couleur4, $rand_couleur2),
   $col_poly2 = imagecolorallocate($img, $rand_couleur2, $rand_couleur2, $rand_couleur1),
   $col_poly3 = imagecolorallocate($img, $rand_couleur3, $rand_couleur3, $rand_couleur3),
   $col_poly = imagecolorallocate($img, $rand_couleur4, $rand_couleur1, $rand_couleur4));

for ($a=0;$a<=$taillecarre/2;$a+=$taillecarre/600)
{
$rand2 = array_rand($rand);
imagepolygon($img, array (
0+$a, 0,
$taillecarre, 0+$a,
$taillecarre-$a, $taillecarre,
0, $taillecarre-$a
),
4,
$rand2);
}

header("Content-type: image/png");
imagepng($img);

?>

Pmol

6 juillet 2007 à 0:26:53

Comme delroth, un générateur de superformulas

.
Le code n'est pas super beau par contre.
http://the.pmol.free.fr/python/superformula/

6 juillet 2007 à 0:29:57

Mon ensemble de Mandelbrot en C :
J'ai utilisé la SDL.
Les fonctions definirPixel et obtenirPixel sont directement repompées du tuto de Piwaï Modifier une image pixel par pixel (merci à lui !!!)

La base du programme est facilement réutilisable pour d'autres dessins puisque on parcourt chaque pixel, et pour chaque pixel on peut modifier la couleur.
J'ai pas encore trouvé de fonctions qui rendaient des couleurs interessantes, celle là est la meilleure que j'ai trouvée.
Je me suis basé sur l'algorithme suivant.

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

void pause()
{
int continuer = 1;
SDL_Event event;

while (continuer)
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
continuer = 0;
}
}
}

Uint32 obtenirPixel(SDL_Surface *surface, int x, int y)
{
int nbOctetsParPixel = surface->format->BytesPerPixel;
Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

switch(nbOctetsParPixel)
{
case 1:
return *p;
case 2:
return *(Uint16 *)p;
case 3:
if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
return p[0] << 16 | p[1] << 8 | p[2];
else
return p[0] | p[1] << 8 | p[2] << 16;
case 4:
return *(Uint32 *)p;
default:
return 0;
}
}

void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
{
int nbOctetsParPixel = surface->format->BytesPerPixel;
Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

switch(nbOctetsParPixel)
{
case 1:
*p = pixel;
break;

case 2:
*(Uint16 *)p = pixel;
break;

case 3:
if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
{
p[0] = (pixel >> 16) & 0xff;
p[1] = (pixel >> 8) & 0xff;
p[2] = pixel & 0xff;
}
else
{
p[0] = pixel & 0xff;
p[1] = (pixel >> 8) & 0xff;
p[2] = (pixel >> 16) & 0xff;
}
break;

case 4:
*(Uint32 *)p = pixel;
break;
}
}

int main (int argc, char** argv) {

SDL_Surface *screen;
Uint32 pixel;
Uint8 r,g,b,a;
int j,i,n;
float k,m,x1,x,y;
int nmax = 255;

srand(time(NULL));

SDL_Init (SDL_INIT_VIDEO);

screen = SDL_SetVideoMode(800, 600, 32, SDL_SWSURFACE);
SDL_LockSurface(screen);

for (j=0; j<600; j++) {
m=(300.-j)/200.;
for (i=0; i<800; i++) {
k=(-500.+i)/200.;
x=0;
y=0;
n=0;
do {
x1=x*x-y*y+k;
y=2*x*y+m;
x=x1;
n++;
} while (((x*x+y*y) <4) && (n<nmax));
pixel = obtenirPixel(screen,i,j);
SDL_GetRGBA(pixel, screen->format, &r,&g,&b,&a);
r=rand()*n%256;
g=(255-n)*rand()%256;
b=cos(n)*(rand()%256);
pixel=SDL_MapRGBA(screen->format,r,g,b,a);
definirPixel(screen,i,j,pixel);
}
}

SDL_UnlockSurface(screen);

SDL_Flip(screen);

pause();

SDL_Quit();

return EXIT_SUCCESS;
}

MashUp

6 juillet 2007 à 0:34:20

Citation : pH

Mon ensemble de Mandelbrot en C :
J'ai utilisé la SDL.
Les fonctions definirPixel et obtenirPixel sont directement repompées du tuto de Piwaï Modifier une image pixel par pixel (merci à lui !!!)

La base du programme est facilement réutilisable pour d'autres dessins puisque on parcourt chaque pixel, et pour chaque pixel on peut modifier la couleur.
J'ai pas encore trouvé de fonctions qui rendaient des couleurs interessantes, celle là est la meilleure que j'ai trouvée.
Je me suis basé sur l'algorithme suivant.

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

void pause()
{
int continuer = 1;
SDL_Event event;

while (continuer)
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
continuer = 0;
}
}
}

Uint32 obtenirPixel(SDL_Surface *surface, int x, int y)
{
int nbOctetsParPixel = surface->format->BytesPerPixel;
Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

switch(nbOctetsParPixel)
{
case 1:
return *p;
case 2:
return *(Uint16 *)p;
case 3:
if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
return p[0] << 16 | p[1] << 8 | p[2];
else
return p[0] | p[1] << 8 | p[2] << 16;
case 4:
return *(Uint32 *)p;
default:
return 0;
}
}

void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
{
int nbOctetsParPixel = surface->format->BytesPerPixel;
Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

switch(nbOctetsParPixel)
{
case 1:
*p = pixel;
break;

case 2:
*(Uint16 *)p = pixel;
break;

case 3:
if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
{
p[0] = (pixel >> 16) & 0xff;
p[1] = (pixel >> 8) & 0xff;
p[2] = pixel & 0xff;
}
else
{
p[0] = pixel & 0xff;
p[1] = (pixel >> 8) & 0xff;
p[2] = (pixel >> 16) & 0xff;
}
break;

case 4:
*(Uint32 *)p = pixel;
break;
}
}

int main (int argc, char** argv) {

SDL_Surface *screen;
Uint32 pixel;
Uint8 r,g,b,a;
int j,i,n;
float k,m,x1,x,y;
int nmax = 255;

srand(time(NULL));

SDL_Init (SDL_INIT_VIDEO);

screen = SDL_SetVideoMode(800, 600, 32, SDL_SWSURFACE);
SDL_LockSurface(screen);

for (j=0; j<600; j++) {
m=(300.-j)/200.;
for (i=0; i<800; i++) {
k=(-500.+i)/200.;
x=0;
y=0;
n=0;
do {
x1=x*x-y*y+k;
y=2*x*y+m;
x=x1;
n++;
} while (((x*x+y*y) <4) && (n<nmax));
pixel = obtenirPixel(screen,i,j);
SDL_GetRGBA(pixel, screen->format, &r,&g,&b,&a);
r=rand()*n%256;
g=(255-n)*rand()%256;
b=cos(n)*(rand()%256);
pixel=SDL_MapRGBA(screen->format,r,g,b,a);
definirPixel(screen,i,j,pixel);
}
}

SDL_UnlockSurface(screen);

SDL_Flip(screen);

pause();

SDL_Quit();

return EXIT_SUCCESS;
}

j'ai tester ton code sur dev c++
et cela m'affichais une erreur ...

6 juillet 2007 à 0:38:54

C'est peut-être pas la peine de tout quoter, vu la taille du code

.
Je pourrais peut-être t'aider si seulement tu me disais de quelle erreur il s'agit.
Il doit sans doute s'agir d'un problème de linkage parce que chez moi ça marche.

Jules

6 juillet 2007 à 1:24:28

Salut,
J'ai codé ça depuis quelques temps, si vous avez des questions n'hésitez pas car je n'ai presque rien commenté. Les paramètres du programme sont à régler par les defines et il faut avoir la SDL.
Cette fractale s'appelle le flocon de Koch, plus d'informations par ici : http://fr.wikipedia.org/wiki/Flocon_de_Koch

Edit : Une image :
Image utilisateur

Le code :

#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <math.h>

//Qualité
#define NOMBREDEFOI 4 //itération de la fractale
//forme
#define NOMBRE_SOMMETS 3
#define CST_RAYON 400.0
//Répetition
#define NOMBRE_INTERNE 4.0 //float
#define DECREMENTATION_RAYON 120
//Couleurs
#define ROUGE_DEPART 0
#define VERT_DEPART 255
#define BLEU_DEPART 0
#define ROUGE_ARRIVE 255
#define VERT_ARRIVE 0
#define BLEU_ARRIVE 0
//Tracage
#define TAILLE_PIXEL 1
#define LARGEUR 1024
#define HAUTEUR 768
//Gestion mémoire
#define DIMTAB (pow(4,NOMBREDEFOI)+1)*2*NOMBRE_SOMMETS //Ne pas toucher

void pause();
void tracer_ligne(SDL_Surface *trait,SDL_Surface *ecran, float x1, float y1, float x2, float y2);
float absolu(float a);
void iteration(int *tableau);
void afficher(SDL_Surface *trait,SDL_Surface *ecran,int *tableau);

int main(int argc, char *argv[])
{
SDL_Init(SDL_INIT_VIDEO);

srand(time(NULL));

SDL_Surface *ecran = NULL;
SDL_Surface *trait = NULL;

SDL_Rect position;

int i,j,k;
i=DIMTAB;
int tableau[i];
float rayon;

ecran = SDL_SetVideoMode(LARGEUR, HAUTEUR, 32, SDL_HWSURFACE);
trait = SDL_CreateRGBSurface(SDL_HWSURFACE, TAILLE_PIXEL, TAILLE_PIXEL, 32, 0, 0, 0, 0);

SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
SDL_FillRect(trait, NULL, SDL_MapRGB(trait->format, 0, 0, 0));

rayon=CST_RAYON;
for (j=0;j<NOMBRE_INTERNE;j++)
{
SDL_FillRect(trait, NULL, SDL_MapRGB(trait->format, (((NOMBRE_INTERNE-j-1)/(NOMBRE_INTERNE-1))*ROUGE_DEPART+(j/(NOMBRE_INTERNE-1))*ROUGE_ARRIVE)/2,
(((NOMBRE_INTERNE-j-1)/(NOMBRE_INTERNE-1))*VERT_DEPART+(j/(NOMBRE_INTERNE-1))*VERT_ARRIVE)/2,
(((NOMBRE_INTERNE-j-1)/(NOMBRE_INTERNE-1))*BLEU_DEPART+(j/(NOMBRE_INTERNE-1))*BLEU_ARRIVE)/2));

for (i=0;i<DIMTAB;i++)
{
tableau[i]=0;
}
k=0;
for(i=0;i<NOMBRE_SOMMETS+1;i+=1)
{
tableau[k]=LARGEUR/2+rayon*cos((i*2*3.14159)/NOMBRE_SOMMETS);
tableau[k+1]=HAUTEUR/2+rayon*sin((i*2*3.14159)/NOMBRE_SOMMETS);
k+=2;
}

for (i=0;i<NOMBREDEFOI;i++)
{
iteration(tableau);
}
afficher(trait,ecran,tableau);
SDL_Flip(ecran);
rayon-=DECREMENTATION_RAYON;
}

SDL_Flip(ecran);

pause();

SDL_FreeSurface(trait);
SDL_Quit();

return 0;
}

void afficher(SDL_Surface *trait,SDL_Surface *ecran,int *tableau)
{
int i=0;
for(i=0;i+2<DIMTAB;i+=2)
{
if (tableau[i+2]!=0 && tableau[i+3]!=0)
tracer_ligne(trait,ecran, tableau[i], tableau[i+1], tableau[i+2], tableau[i+3]);
}
}

void iteration(int *tableau)
{
SDL_Rect milieu;
float x1,x2,y1,y2,a,i,HAUTEUR_TRIANGLE,milieu_x,milieu_y;
int j,k,l,m;
for (m=0;m+8<DIMTAB;m+=8)
{
if(tableau[m]==0 || tableau[m+1]==0 || tableau[m+2]==0 || tableau[m+3]==0) {break;}
x1=tableau[m];y1=tableau[m+1];
x2=tableau[m+2];y2=tableau[m+3];
HAUTEUR_TRIANGLE=(sqrt(pow(y2-y1,2)+pow(x2-x1,2)))/(sqrt(12));
a=(y2-y1)/(x2-x1);
if (absolu(a)<=1)
{
if (x1 > x2) {i=x2;x2=x1;x1=i;i=y2;y2=y1;y1=i;}
a=(y2-y1)/(x2-x1);
milieu_x=x1+(x2-x1)/2;
milieu_y=y1+a*(x2-x1)/2;
}
else
{
if (y1 > y2) {i=x2;x2=x1;x1=i;i=y2;y2=y1;y1=i;}
a=(x2-x1)/(y2-y1);
milieu_x=x1+a*(y2-y1)/2;
milieu_y=y1+(y2-y1)/2;
}

for(l=0;l<6;l++)
{
for(j=DIMTAB;j>m+2;j--)
{
tableau[j]=tableau[j-1];
}
}

tableau[m+2]=milieu_x+(HAUTEUR_TRIANGLE/sqrt(3))*(tableau[m]-milieu_x)/(sqrt(pow(tableau[m]-milieu_x,2)+pow(tableau[m+1]-milieu_y,2)));//point avant x
tableau[m+3]=milieu_y+(HAUTEUR_TRIANGLE/sqrt(3))*(tableau[m+1]-milieu_y)/(sqrt(pow(tableau[m]-milieu_x,2)+pow(tableau[m+1]-milieu_y,2)));//point avant y
tableau[m+4]=milieu_x+HAUTEUR_TRIANGLE*(milieu_y-tableau[m+1])/(sqrt(pow((milieu_y-tableau[m+1]),2)+pow((tableau[m]-milieu_x),2)));//sommet x
tableau[m+5]=milieu_y+HAUTEUR_TRIANGLE*(tableau[m]-milieu_x)/(sqrt(pow((milieu_y-tableau[m+1]),2)+pow((tableau[m]-milieu_x),2)));//sommet y
tableau[m+6]=milieu_x+(HAUTEUR_TRIANGLE/sqrt(3))*(tableau[m+8]-milieu_x)/(sqrt(pow(tableau[m+8]-milieu_x,2)+pow(tableau[m+9]-milieu_y,2)));//point apres x
tableau[m+7]=milieu_y+(HAUTEUR_TRIANGLE/sqrt(3))*(tableau[m+9]-milieu_y)/(sqrt(pow(tableau[m+8]-milieu_x,2)+pow(tableau[m+9]-milieu_y,2)));//point apres y
}
}

void pause()
{
int continuer = 1;
SDL_Event event;

while (continuer)
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
continuer = 0;
}
}
}

void tracer_ligne(SDL_Surface *trait,SDL_Surface *ecran, float x1, float y1, float x2, float y2)
{
int i;float a;
SDL_Rect position;

a=(y2-y1)/(x2-x1);

if (absolu(a)<=1)
{
if (x1 > x2) {i=x2;x2=x1;x1=i;i=y2;y2=y1;y1=i;}
a=(y2-y1)/(x2-x1);
for (i=x1;i<x2+1;i++)
{
position.x=i;
position.y=y1+a*(i-x1);
SDL_BlitSurface(trait, NULL, ecran, &position);
}
}
else
{
if (y1 > y2) {i=x2;x2=x1;x1=i;i=y2;y2=y1;y1=i;}
a=(x2-x1)/(y2-y1);
for (i=y1;i<y2+1;i++)
{
position.x=x1+a*(i-y1);
position.y=i;
SDL_BlitSurface(trait, NULL, ecran, &position);
}
}
}

float absolu(float a)
{
if (a<0) return -1*a;
else return a;
}

Knarf2

6 juillet 2007 à 1:35:02

Hop, c'est encore moi. Je poste mon chose a base de superformula :

Et le bout de code qui dessine, là il est tard donc j'ai pas le trop le temps de rendre ça plus clean, désolé pour les éventuels moches de la secte:

void
draw(void)
{

double angle;
double r1,r2;
int decal = IMG_SIZE/2;
double a = 1;
double b = 1;
double m = 1;
double n1 = 1;
double n2 = 2;
double n3 = 3;
int x1,y1,x2,y2;
int zoom=1;
int col=0;

gdImageSetThickness(img, 2);
for(zoom=1; zoom<IMG_SIZE; zoom+=5) {
for(angle = 0; angle < 2*M_PI; angle += PAS) {
r1 = pow( ( pow(abs(cos(m* angle /4.)/a),n2) + pow(abs(sin(m* angle /4.)/b),n3)), -1./n1);
r2 = pow( ( pow(abs(cos(m*(angle+PAS)/4.)/a),n2) + pow(abs(sin(m*(angle+PAS)/4.)/b),n3)), -1./n1);

x1 = (cos(angle)*r1*zoom) + decal;
y1 = (sin(angle)*r1*zoom) + decal;
x2 = (cos(angle+PAS)*r2*zoom) + decal;
y2 = (sin(angle+PAS)*r2*zoom) + decal;

line(
x1,y1,x2,y2,

255./r1,
255./r1,
255./r1

);

}
col=(col+1)%256;
if(!(col%9))m*=3,zoom+=5;
}

return;
}

PAS c'est un define de préproc, à .01 ici
Les changements entre les 2 images sont fait au niveau du if a la fin de la fonction. Et le truc audessus du if c'est moi quand j'ai la flemme de faire un autre if. jvous emmerde d'abord. Et jvais dormir.

satan666

6 juillet 2007 à 1:37:31

comment on s'incrit a se cours j'ai pas trés bien comprit qui pourai m'aidé a comprendre le sujet et comment on apprend à faire toute ces belles choces merci
satan 666

mathgl

6 juillet 2007 à 1:58:58

Voilà, je me suis inspiré du code php de Kados, je l'ai recodé pour vb.net et j'en ai profité pour ajouter un peu de couleur

Il y a même le exe, où vous pouvez voir l'animation

(Vous devez posséder le framework .net)
ICI
Image utilisateur

Voiçi le code:

Imports System.Drawing.Drawing2D
Public Class Form1

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
Me.BackColor = Color.Black
Dim taillecarre As Integer
taillecarre = 600

Dim newBitmap As Bitmap = New Bitmap(taillecarre, taillecarre)
Dim g As Graphics = Graphics.FromImage(newBitmap)
Dim x, y As Integer
Dim rand As New Random
Dim pt1, pt2 As Point
Dim pen1 As Pen

While x < Me.Width
While y < Me.Height
pen1 = New Pen(Color.FromArgb(rand.Next(0, 50), rand.Next(0, 50), rand.Next(0, 50)), 1)
pt1 = New Point(x, y)
pt2 = New Point(x + rand.Next(1, 16), y + rand.Next(1, 16))
g.DrawLine(pen1, pt1, pt2)
y = y + rand.Next(1, 4)
End While
y = 0
x = x + rand.Next(1, 4)
End While

Dim a As Double = 0
Dim point1, point2, point3, point4 As Point
Dim MyPen As New Pen(Color.Black, 1)

For a = 0 To taillecarre Step (a + taillecarre / 100)
MyPen = New Pen(Color.FromArgb(rand.Next(0, 256), rand.Next(0, 256), rand.Next(0, 256)), 1)
point1 = New Point(a, 0)
point2 = New Point(taillecarre, a)
point3 = New Point(taillecarre - a, taillecarre)
point4 = New Point(0, taillecarre - a)
Dim curvePoints As Point() = {point1, point2, point3, point4}
g.DrawPolygon(MyPen, curvePoints)
Next a
Me.BackgroundImage = newBitmap
newBitmap.Save("Image.jpg", System.Drawing.Imaging.ImageFormat.Jpeg)
End Sub
End Class

Kedare

6 juillet 2007 à 1:59:45

Citation : Locke

Dans le genre facile à faire pour les débutants, il y a des carrés imbriqués à l'infini, aussi :

(bon bien sûr c'est plus beau quand c'est plus grand et tout, enfin, bref)

le code source et l'algo m'interesse , possible de les avoir svp ?

Tixlegeek

6 juillet 2007 à 2:08:11

tien, je me suis mis un peu a tester le php

vla deux bidouilles :
Image utilisateur

Goth<mic>

6 juillet 2007 à 2:42:31

j'ai fait ensemble de Julia + Mandelbrot en couleur, C et SDL... par contre pour la mandelbrot j'ai de moches traits blanc, sauriez vous comment les enlever ? :s je pense que c'est un problème au niveau des flottants que j'arrondi pour afficher le point à des coordonnées entières, bref...

les sources, l'exe, sont présent là :
http://sites.estvideo.net/gautier-teh-gth/Julia_Fractale.rar

Pioupiou--vokda

6 juillet 2007 à 3:14:01

Vous faites tous des images superbe !!

Mais probleme pour les vraiment debutants !! Ceux qui viennent de commencer à apprendre les langages de programmation comment fait-on nous ?

Vous nous dites d'observer les codes des autres mais j'en comprend rien !

lastsseldon

6 juillet 2007 à 6:21:31

Un grand merci à tous les participants

. Pour ceux qui hésitent encore, lancez-vous ! Les images générées sont parfois complexes, mais le code source est toujours court et simple. Il n'y a donc pas de raison d'avoir peur ou de chercher un tutoriel. Il faut juste trouver une image qui vous plaît, comprendre son fonctionnement puis programmer :-°

.
La présentation a été corrigée pour prendre en compte le topic sierpinski, l'absence de code ou d'explication dans certaines participations et la résolution des bugs (d'une manière générale, essayez de ne pas poster si vous n'avez pas quelque chose à présenter

).

---

lexou > woh. Tes dessins sont mes préférés

(on n'a pas pu les mettre dans la news car ils n'ont pas été réalisé pendant l'atelier; reste qu'ils sont super beaux). Serait-il possible d'avoir la formule permettant de générer les fleurs ? :} (la deuxième image)
Sinon, il y a une typo dans le fichier OpenGlView.cpp en ligne 20 qui empêche la compilation (manque juste une maj). Si d'autres veulent essayer qbiom, il faut taper (après avoir corrigé ce détail) : "$ qmake && make", puis "$ ./app" dans votre terminal.
Voilà voilà, ça serait cool si tu pouvais réaliser d'autres oeuvres pendant cet atelier

.

J'essaierai de lire tes sources tout à l'heure. En attendant, j'ai pas pu m'empêcher de toucher un peu aux biomorphes (malheureusement, c'est loin d'être aussi séduisant que qbiom) :

(* utilisation : $ ocaml graphics.cma bio.ml *)
open Complex
open Graphics

(* determine la couleur du point *)
let rec couleur f z0 = function
| 0 -> true
| n -> let z = f z0 in
if abs_float z.re > 10.
|| abs_float z.im > 10.
|| norm z > 10.
then false
else couleur f z (n-1)

(* un exemple *)
let radiolaire z =
let c = { re = 0.5 ; im = 0. }
and trois = { re = 3. ; im = 0. }
in add (pow z trois) c

(* dessin final *)
let () = open_graph "" ;
(* constantes pour l'affichage *)
let min_x, max_x = (-1.5, 1.5)
and min_y, max_y = (-1.5, 1.5) in
let reel_to_complex x y =
let rapport_x = (max_x -. min_x) /. 500.
and rapport_y = (max_y -. min_y) /. 500.
in { re = min_x +. rapport_x *. float_of_int x ;
im = min_y +. rapport_y *. float_of_int y } in

(* boucle principale *)
for x = 0 to 500 do
for y = 0 to 500 do
let z0 = reel_to_complex x y in
if couleur radiolaire z0 7
then set_color (rgb 0 0 0)
else set_color (rgb 255 255 255) ;
plot x y
done
done ;
ignore (read_key ())

Blackhole

6 juillet 2007 à 8:19:18

Toujours le même code qu'ici, qui trace que des pixels.

En gardant toujours les mêmes constantes pour chaque image, mais en changeant l'opération j'obtiens :

Multiplication :

Soustraction :

Addition :

Division :

Modulo :

C'est marrant, on obtiens des formes très très géométriques avec la soustraction !
Vous conviendrez que le modulo donne le plus résultat, en voilà une autre preuve

MaAaD

6 juillet 2007 à 9:59:31

Waa, franchement merci d'avoir eu l'idée de cet atelier, c'est vraiment génial

(même si je pars dimanche :euh:

)!
Bon, j'ai expérimenté un peu ça sous Python, avec Tkinter. C'est pas spécialement bô (pour une fois que c'est pas de la faute à Tk, mais la miene

)et le code pourrais être un peu amelioré...
En fait je suis parti du principe simple qu'on prend un cercle, et on place 4 cerlces autour, et on refait la même chose pour ces 4 cercles, etc.
Il existe 4 variantes, qui dépendent de la position des cercles par rapport au cercle de référence, et aussi de l'affichage ou non de ce cercle de référence. On peux ensuite mélanger la position 1 et la position 2, ce qui nous donne 4 variantes de plus. Je n'ai pas mis de couleurs, c'est beaucoup plus classe en noir.

Voici le code

from Tkinter import *
from random import randrange

fen = Tk()
can = Canvas(fen, width = 750, height = 750, bg = "white")
can.pack()

reference = 0

#La fonction cercle qui trace un cercle de centre x,y et de rayon r :
def cercle(x, y, r):
can.create_oval(x-r, y-r, x+r, y+r, fill = "black")

#La premiere fonction cercle4 qui trace 4 cercles autour du cercle x,y,r, et qui renvoie le centre et le rayon des cercles traces :
def cercle4_1(x,y,r):
cercle(x+r,y,r/2)
cercle(x-r,y,r/2)
cercle(x,y+r,r/2)
cercle(x,y-r,r/2)
return (x+r,y,r/2),(x-r,y,r/2),(x,y+r,r/2),(x,y-r,r/2)

#La deuxieme fonction cercle4 qui trace 4 cercles autour du cercle x,y,r, et qui renvoie le centre et le rayon des cercles traces :
def cercle4_2(x,y,r):
cercle(x+r,y+r,r/2)
cercle(x-r,y-r,r/2)
cercle(x-r,y+r,r/2)
cercle(x+r,y-r,r/2)
return (x+r,y+r,r/2),(x-r,y-r,r/2),(x-r,y+r,r/2),(x+r,y-r,r/2)

#La troisieme fonction cercle4 qui trace 4 cercles autour du cercle x,y,r, comme la fonction 1, mais qui renvoie le centre et le rayon des cercles qui auraient ete traces par la fonction 2 :
def cercle4_3(x,y,r):
cercle(x+r,y,r/2)
cercle(x-r,y,r/2)
cercle(x,y+r,r/2)
cercle(x,y-r,r/2)
return (x+r,y+r,r/2),(x-r,y-r,r/2),(x-r,y+r,r/2),(x+r,y-r,r/2)

#La quatrieme fonction cercle4 qui trace 4 cercles autour du cercle x,y,r, comme la fonction 2, mais qui renvoie le centre et le rayon des cercles qui auraient ete traces par la fonction 1 :
def cercle4_4(x,y,r):
cercle(x+r,y+r,r/2)
cercle(x-r,y-r,r/2)
cercle(x-r,y+r,r/2)
cercle(x+r,y-r,r/2)
return (x+r,y,r/2),(x-r,y,r/2),(x,y+r,r/2),(x,y-r,r/2)

#La fonction cercleTous qui va effectuer au choix une des fonctions tant de fois, autour du cercle x,y,r :
def cercleTous(x,y,r,fois,fonction):
global reference
i = 0
fois -= 1
if fois != 0:
while i < 4 :
if reference :
cercle(x,y,r)
resultat = fonction(x,y,r)[i]
cercleTous(resultat[0],resultat[1],resultat[2],fois,fonction)
i += 1

choix = raw_input("Quel fonction voulez vous utiliser ? ")
if choix == "1" :
choix = cercle4_1
elif choix == "2" :
choix = cercle4_2
elif choix == "3" :
choix = cercle4_3
elif choix == "4" :
choix = cercle4_4
else :
print "Mauvais choix !"
input("Entree pour quitter")

fois = input("Combien de fois voulez vous l'effectuer ? ")
reference = input("Voulez-vous afficher le cercle de reference (0 ou 1) ? ")

#C'est parti !
cercleTous(375,375,175,fois,choix)
fen.mainloop()

J'ai même donné la possibilié de choisir à l'ouverture du programme quel postion on vas donner (2 fonction pour les positions normales, 2 pour mélanger), combien de fois on vas les effectuer (pas plus de 9, après ca rame et ca rend rien de plus), et aussi si on affiche ou non le cercle de référence.

Bon je vous donne les images qui rendent le mieux, si vous voulez essayer, vous n'avez besoin que de Python et amusez vous bien

Edit : Toute ces images ont étées crées en répétant 7 fois la fontcion, avec 8, on a un résultat encore meilleure mais c'est plus long, avec 9 ca rame vraiment et c'est carrément saturé, avec 10 je préfére pas essayer

Nanoc

6 juillet 2007 à 10:39:04

Bonjour tout le monde !!

Je vous propose un petit ensemble de Mandelbrot en C++ (SDL):

Ou en meilleure qualité (fichier d'origine 6400x4800 en .bmp = 80Mo, fichier .jpeg 1600x1200):

L'algorithme utilisé est celui que tout le monde utilise c'est-à-dire:

nombre d'itérations maximum := 40 (pour l'image)

POUR TOUT PIXEL x EN X
   POUR TOUT PIXEL y EN Y

       c:= x + iy    (nombre complexe)
       z:= 0 + i0    (nombre complexe)
       n:=0          (variable d'itération)

       FAIT
          z = z*z +c
          n = n + 1
       TANT QUE ( |z| < 4 ET n < nombre d'itérations maximum)

       SI (n = nombre d'itérations maximum) ALORS colorie Pixel en noir
       SINON  colorie Pixel en dégrade selon le nombre d'itérations

   FIN POUR TOUT
FIN POUR TOUT

La seule difficulté est la manipulation des nombres complexes pour ceux qui ne connaissent pas. A noté que l'image sera plus précise si le nombre d'itérations est plus grand, mais que le dégradé sera moins joli

Le code source est ici: Code source (C++ et SDL)

EDIT : Ajout de l'image en haute qualité

Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.

delroth

6 juillet 2007 à 12:05:25

Me revoilà avec maintenant un arbre de pythagore un petit particulier : au lieu d'utiliser des carrés pour le représenter, j'ai décidé d'utiliser des vecteurs. Le rendu est pas mal, voir même mieux qu'avec des carrés. De plus, j'ai rendu le nombre de vecteurs fils variables, ce qui permet pas mal de possibilités.
Tout est sur mon espace Cod'Art

MaAaD

6 juillet 2007 à 12:11:02

L'idée du vecteur est vraiment pas conne !

<< 1 2 3 4 ... 23 >>

Atelier Cod'Art

Supprimer

Modérer

Signaler le message aux modérateurs