Partage
  • Partager sur Facebook
  • Partager sur Twitter

Atelier Cod'Art

5 juillet 2007 à 2:39:36

Atelier Cod'art



Bonjour à tous,

De manière à occuper vos (trop ?) longues vacances d'été et vous faire découvrir un thème assez peu exploité sur le sdz (au profit des jeux-vidéos), je vous propose un atelier de programmation graphique :) .
superformula

Thème



Lorsque l'on parle de programmation graphique, on peut d'abord penser aux <acronym title="Graphical User Interface">GUIs</acronym>. Ce n'est pas le but de ce atelier : développer un logiciel, c'est rigolo pour certains, mais c'est trop long et il est rare d'en arriver à bout (et si tout le monde fait la même chose, c'est lassant). Non, le thème de cet atelier portera sur la génération de dessins informatiques (par exemple, les fractales ^^ ).

C'est un domaine très intéressant en programmation qui permet de faire des choses très jolies en très peu de lignes :) . N'ayez pas peur d'utiliser des algos très connus (par exemple, le triangle de sierpinsky) lors de vos premiers essais, vous risquez d'être surpris par leur beauté. Cet atelier est donc ouvert à tous les curieux qui veulent découvrir quelque chose de nouveau et à ceux qui s'y connaissent déjà :) .

Règles



Les règles sont très simples, la beauté du rendu final prime avant tout. Il n'y aura pas de correction, pas de classement, pas de gagnant, pas de récompense. Non, juste des images, juste la fierté d'avoir produit un résultat super sex :) .
mandelbrot

Vous êtes libre de poster plusieurs images portant sur des domaines différents. Toutefois, vos dessins devront systématiquement s'accompagner d'une explication de l'algorithme utilisé (avec des liens, si vous pensez ne pas être suffisamment clair ^^ ) et du code source (de manière à ce que les autres puissent aussi essayer et vous faire part de leurs critiques / suggestions (certains diront, pour éviter les tricheries aussi)). S'il est toujours agréable de regarder une image esthétique, c'est encore plus intéressant lorsque l'on comprends comment elle a été générée :) .

L'atelier s'étalera sur deux semaines (à partir d'aujourd'hui, pour ne pas défavoriser les gens qui arriveraient en cours de route). Il n'y a pas d'inscription, il suffit de poster ses images dans ce topic. Je réunirai l'ensemble des posts lors du dernier jour sur une page web externe de manière à pouvoir admirer vos travaux facilement :) .

Le langage et les bibliothèques sont laissées libres : vous pouvez utiliser les outils que vous préférez (par exemple, le c/c++, c#, java, ocaml, python, ruby, la sdl, l'opengl, qt, ... et même logo !). Vous pouvez faire de la 2d, de la 3d et pourquoi pas de la 4d ? (une animation :D ). Bref, le but est vraiment de s'amuser en produisant des dessins, pas de se forcer à utiliser un machin qu'on ne connaît pas (n'oubliez pas que vous n'avez que deux semaines, c'est assez court, mais c'est largement suffisant :) ).

Je répondrais aux questions concernant le principe général ici; pour les problèmes de code, n'hésitez pas à ouvrir un nouveau topic pour ne pas étouffer les participations des autres.

doc, exemples, faq



xor
  • Ça m'intéresse, mais je ne sais pas du tout quoi faire !

    C'est pas grave, il y a pleins de choses très abordables : par exemple, la recherche "fractales" sur google devrait pouvoir vous aider. Sinon, d'une manière générale, wikipedia est une très bonne source d'inspiration.

    Attention, il n'est pas du tout obligatoire de se limiter aux fractales : ce mot revient souvent dans cette présentation parce qu'il couvre un très grand nombre d'oeuvres informatiques. La visualition des données fournit elle aussi des résultats très chouettes. On citera également à titre d'exemple le perlin noise (qui permet notamment de simuler des nuages ou des textures très riches (à connaître absolument si vous travaillez sur un jeu vidéo !)), les simulations physiques ou les jeux mathématiques (crible, spirale d'ulam, ...). Toutefois, si vous ne savez vraiment pas par où commencer, les fractales seront sûrement plus abordables car bien documentées (faites attention de ne pas choisir quelque chose de trop dur non plus :p ).

    Si l'une des images présentées vous attire particulièrement, cliquez dessus pour en savoir plus (ou essayez de deviner §). Reprendre une idée existante est un bon départ pour commencer.

  • Mon résultat est moche !

    Le rendu final se joue souvent au niveau des couleurs utilisées : plusieurs thèmes de couleurs peuvent radicalement changer l'expression de votre rendu, n'hésitez pas à nous présenter toutes vos variantes ^^ .

  • Mon résultat est moche bis !

    C'est pas grave, on est là pour s'amuser :D . Parfois, l'algo utilisé est plus intéressant que le rendu final, l'absence de classement est justement là pour ne pas défavoriser ceux qui débutent vraiment : il est possible d'obtenir des choses très belles en moins de cent lignes (voir même en 15 lignes :-° ), c'est trèès abordables en deux semaines et ça vous donnera peut être envie de continuer (pour éclater les autres la prochaine fois §). De temps en temps, il arrive même qu'un bug d'implémentation de l'algo améliore sensiblement votre image ^^ .

Remarques



Attention, la participation à cet atelier implique trois points fondamentaux : les images, l'algorithme et le code source. N'oubliez pas que vos oeuvres seront exposées par la suite.

Beaucoup d'entre vous se sont plaint de ne pas savoir par où commencer et demandaient un tuto (faute d'arriver à lire le code) : il n'y en a pas. Il faut essayer par soit même pour comprendre la logique à adopter. N'hésitez pas à consulter wikipedia pour la récursivité : cette notion apparaît souvent dans les fractales. Mais la difficulté n'est qu'illusion : le plus dur, c'est de trouver une image qui vous plaît, après, ça va tout seul ;) .

Si vous avez un problème de conception ou lors de l'utilisation d'un code source des participants, merci d'ouvrir un nouveau topic (ou de contacter l'auteur par mp).

Pour les fractales de Sierpinski, allez poster dans le topic dédié, cela facilitera l'organisation


Conclusion



En espérant que cet atelier vous plaira et que vous serez nombreux à participer, je vous souhaite bonne chance et bon courage. Un dernier mot : soyez fier de vos images, car vous pourrez les montrer à vos proches, les mettre sur votre page web, en avatar, en fond d'écran ou encore les placarder aux murs de votre chambre :) .

shape of song
(merci à bluestorm pour la fractale de mandelbrot et aux gens de #sdz pour leur enthousiasme et leur relecture)

  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 3:05:32

Bon je vais poster mon code que j'ai réalisé il y a quatre jours (et oui, sur le chan IRC on est au courant et on prépare tout depuis longtemps :p ). Ce code permet de dessiner la très célèbre fractale du triangle de Sierpinsky, avec une petite originalité tout de même : le code est entièrement écrit en logo (exécutable par KTurtle pour les KDE-users).

Le résultat obtenu :
Image utilisateur


Le code : (tss, même pas de coloration pour le logo :p )

Français :

effacer

w = 300
h = 250

x = hasard 0, w
y = hasard 0, h

cacher
va 0, 0

répèter 10000 [
        n = hasard 0, 1000
        si n <= 333 [
                x = x / 2
                y = y / 2
        ]
        si (n > 333) et (n <= 666) [
                x = (x + w / 2) / 2
                y = (y + h) / 2
        ]
        si n > 666 [
                x = (x + w) / 2
                y = (y + h / 2) / 2
        ]
       
        va x, y
        avance 1
]
 


Anglais :

clear

w = 300
h = 250

x = random 0, w
y = random 0, h

hide
go 0, 0

repeat 10000 [
        n = random 0, 1000
        if n <= 333 [
                x = x / 2
                y = y / 2
        ]
        if (n > 333) and (n <= 666) [
                x = (x + w / 2) / 2
                y = (y + h) / 2
        ]
        if n > 666 [
                x = (x + w) / 2
                y = (y + h / 2) / 2
        ]
       
        go x, y
        forward 1
]
 


Voilà pour ma petite contribution à cet atelier, désolé pour le code que je n'ai pas eu le temps de commenter (débrouillez vous :D ), et je reviendrai demain pour poster ma mandelbrot en python :p .

@++ all, et n'hésitez pas, postez vos oeuvres !
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 4:47:21

C'est un sujet intéressant. J'ai eu l'occasion de traiter le sujet des biomorphes qui sont des sortes de fractales. J'ai développé plusieurs soft permettant d'en générer suivant tout un tas de paramètres dont un relativement aboutit à cette adresse :

QBiom

Le soft est réalisé avec QT en C++. Il permet entre autre de générer les biomorphes en 2D, se déplacer, zoom, et générer un rendu en 3D. L'interface n'est pas très bonne, pour avoir l'ensemble des options faites un clique droit sur la fenêtre de rendu vous pourrez par exemple sauver votre image dans tout un tas de formats.

Laissez libre court à votre imagination. Voici quelques uns de mes chef d'oeuvres ^^ :

Image utilisateur


Image utilisateur


Image utilisateur


Image utilisateur


Toutes ces images sont disponibles en grand dans la section Screenshot du site donné un peu plus haut.

Le principe permettant de représenter ces biomorphes est expliqué dans l'article de référence suivant :
Biomorphes

L'algorithme que j'ai utilisé est aménagé vous pourrez le trouver dans les sources de QBiom disponibles sur le site dans le fichier CalcuatingThread.cpp fonction CalculatingThread::calculateH(...) qui permet, étant donnés 7 paramètres, 1 position en X et 1 position en Y dans le plan de donner la hauteur du biomorphe.

Bien à vous,
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 9:41:53

waw lexou, vraiment magnifique !!!
  • Partager sur Facebook
  • Partager sur Twitter
Anonyme
5 juillet 2007 à 10:16:28

Je ne comprends pas, sur vos images on ne retrouve pas le motif d'origine, ce n'est pas le principe des fractales ?
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 10:19:38

Salut,

vraiment excellent ce truc !!! Mais question, comment fait-on ? Ai je loupé la partie qui explique les base de la création de fractales ?

J'ai trop envie d'essayer :pirate: si quelqu'un sais expliquer comment débuter, ca serait cool ^^
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 10:27:51

Bonjour à tous !

Une des images m'as attiré l'oeil et j'ai don été obligé de la faire :D

Le rendu

J'ai fais ça avec le language que je maitrise le mieux : PHP (et GD ) mais comme je ne savais pas comment faire, j'ai fais comme je pouvais, et c'est probablement pas du tout obptimisé (1min30 sur mon ordi (qui date de 2000) pour le rendu )...


<?php

/*
        Script créé par piRpav le 05/07/2007 en 1h15
        Merci beaucoup à bluestorm pour son aide à l'optimisation
*/



//      Le côté de l'image
$cote = 800;

//      Pour éviter de le calculer tout le temps
$unquartcote$cote/4;
$demicote$unquartcote*2;
$troisquartcote$unquartcote*3;

//      On crée la map pixels par pixels
$pixels = array();
for($x=0;$x<$cote;$x++) {
        $pixels[$x] = array();
        for($y=0;$y<$cote;$y++) {
                //      On met tout de suite les carrés de couleurs
                if($x>($cote/2)-1) {
                        if($y>($cote/2)) {
                                $pixels[$x][$y] = 0;
                        }else{
                                $pixels[$x][$y] = 1;
                        }
                }else{
                        if($y>($cote/2)) {
                                $pixels[$x][$y] = 1;
                        }else{
                                $pixels[$x][$y] = 0;
                        }
                }
        }
}


for($i=1;$i<5;$i++) {   // On fait 4 fois la boucle
        $rayon = $cote/(8*$i)//        Calcul du rayon
        $rayon = $rayon * $rayon;       //     On met le rayon au carée
        $centrepetit = (2*pow(2, $i)-1)*$cote/(4*pow(2, $i));   // Ce centre x ou y , petite valeur
        $centregrand = $cote - $centrepetit;    //  Ce centre x ou y , grande valeur
        for($x=$unquartcote;$x<$troisquartcote;$x++) {
                for($y=$unquartcote;$y<$troisquartcote;$y++) {
                        $equation1 = ($x-$centrepetit)*($x-$centrepetit)+($y-$demicote)*($y-$demicote)-$rayon//        Equation du cercle n°1
                        $equation2 = ($x-$demicote)*($x-$demicote)+($y-$centrepetit)*($y-$centrepetit)-$rayon//        Equation du cercle n°2
                        $equation3 = ($x-$centregrand)*($x-$centregrand)+($y-$demicote)*($y-$demicote)-$rayon//        Equation du cercle n°3
                        $equation4 = ($x-$demicote)*($x-$demicote)+($y-$centregrand)*($y-$centregrand)-$rayon//        Equation du cercle n°4
                        if ($equation1 * $equation2 * $equation3 * $equation4 < 0) {    //  Si le pixel en cours est sur un nombre impair de disques
                                $pixels[$x][$y] = 1 - $pixels[$x][$y]//        On change la couleur du pixel
                        }
                }       
        }
}


$image = imagecreate($cote, $cote);     //   On crée l'image aux dimentions voulues
$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)
for($x=0;$x<$cote;$x++) {       //     Et pour chaque pixel
        for($y=0;$y<$cote;$y++) {
                ImageSetPixel ($image, $x, $y, ${'couleur'.$pixels[$x][$y]});   // On pose le pixel à la couleur voulue
        }
}
imagepng($image, 'fract/image.png');    //  On enregistre l'image

echo 'Image générée !';

?>
 


Enjoy ! :)

Edit 1 : un bug corrigé
Edit 2 : merci bluestorm :D c'est bien trouvé :)
Edit 3 : merci bluestorm :D c'est très bien trouvé :)
Edit 4 : optimisation : pour les cercles, entre $cote/4 et 3*$cote/4, et non plus entre 0 et $cote
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 10:31:03

Dji-Bi >
Le problème, c'est que toutes les fractales sont différentes. Certaines sont simples à générer, d'autres plus compliquées.

Tu peux par exemple essayer de commencer par le triangle de Sierpinski, il est assez simple à faire, et il existe tout un tas de méthodes différentes pour le générer.
Il n'est pas forcément aussi joli que les fractales plus "aléatoires" comme Mandelbrot ou Julia, mais c'est un bon début.

Comment faire ? Regarde bien l'image, essaie de l'imaginer comme une superposition de "blocs", et regarde comment tu pourrais les dessiner, en partant du plus gros, et en dessinant les plus petits au fur et à mesure : si tu continues à l'infini, tu obtiens le triangle; pour des raisons matérielles tu risque de t'arrêter :p , et tu auras alors un triangle approché.


Et surtout, ne vous focalisez pas sur les fractales ! Il existe de nombreuses idées, parfois très simples, permettant de dessiner des images surprenantes.


pipRav >
                                if($pixels[$x][$y]==0) {
                                         $pixels[$x][$y] = 1;
                                 }else{
                                         $pixels[$x][$y] = 0;
                                 }
 

Tu peux faire plus léger :
$pixels[$x][$y] = 1 - $pixels[$x][$y];



edit :
pipRav > par ailleurs, je pense que tes quatre 'if' peuvent se ré-écrire ainsi :
if ($equation1 * $equation2 * $equation3 * $equation4 < 0)
   $pixels[$x][$y] = 1 - $pixels[$x][$y];
  • Partager sur Facebook
  • Partager sur Twitter
Anonyme
5 juillet 2007 à 10:59:21

Bonne chance, c'est une très bonne idée !
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 11:00:09

Voici une deuxième fractale, encore en PHP
(venez pas croire que j'aime le PHP, mais c'est un langage que plein de zéros connaissent, alors s'ils sont timides ça les poussera peut-être à participer !)


C'est une méthode particulière pour produire le triangle de Sierpinski, qui se base sur le triangle de Pascal.
N'ayez pas peur, c'est tout simple !

La propriété utilisée c'est que si l'on regarde la parité (le fait qu'ils soient pairs ou impairs) des nombres du triangle de pascal, on obtient le triangle de sierpinksy (en gros).
Ce n'est pas la plus simple manière de générer un triangle de Sierpinsky, mais j'avais envie d'essayer :p

Voilà le rendu :
Image utilisateur

Et voilà le code :
<?php

function construire($taille)
{
        $pascal = array();
       
        for ($i = 0; $i < $taille; ++$i) {
                $ligne = array();
                $ligne[0] = 1;
                for ($j = 1; $j < $i; ++$j)
                        $ligne[$j] = $pascal[$i - 1][$j - 1]$pascal[$i - 1][$j];
       
                $pascal[$i] = $ligne;
        }
       
        return $pascal;
}

function dessiner($triangle)
{
        $len = count($triangle);
        $max_side = 400;
        $side = $max_side / $len;       

        $img = imagecreate($max_side, $max_side);
        $noir = imagecolorallocate($img, 0, 0, 0);
        $blanc = imagecolorallocate($img, 255, 255, 255);

        foreach ($triangle as $i => $ligne)
                foreach ($ligne as $j => $case) {
                        $x = $i * $side;
                        $y = (($len - $i) / 2 + $j) * $side;
                        imagefilledrectangle($img, $y, $x, $y + $side, $x + $side, $case % 2 == 0 ? $noir : $blanc);
                }

        return $img;
}

$taille = 100;
$triangle = construire($taille);
$image = dessiner($triangle);

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

?>


Il faut savoir qu'en modifiant un seul paramètre, le "% 2" au moment du dessin, on peut obtenir d'autres triangles assez différents. Un exemple :
Image utilisateur

Mystère !
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 11:03:48

Je me suis permis de transformer le code de delroth qui est en language C en PHP.

Tout d'abord voici le résultat que j'obtiens en php:
Image utilisateur

Et maintenant le code que j'ai transformé en php:

<?php

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


$w = '300';     //   Taille en pixel de la largeur de l'image
$h = '250';     //   Taille en pixel de la hauteur de l'image

$image = imagecreate($w, $h);     //   On crée l'image aux dimentions voulues
$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)



$x = rand(0, $w);       //     On défini un chiffre aléatoirement entre 0 et ce que vaut $w
$y = rand(0, $h);       //     On défini un chiffre aléatoirement entre 0 et ce que vaut $h

$i=0;
while($i < 10000) {
        $n = rand(0, 1000); // A chaque boucle on défini un chiffre aléatoirement entre 0 et 1000
        if($n <= '333') {
                $x /= 2;
                $y /= 2;
        }
        elseif($n > '333' && $n <= '666') {
                $x = ($x + $w / 2) / 2;
                $y = ($y + $h) / 2;
        }
        else {
                $x = ($x + $w) / 2;
                $y = ($y + $h / 2) / 2;
        }
       
        ImageSetPixel ($image, $x, $y, $couleur1);      //    On écrit le pixel au coordonnée obtenue
        $i++;
}

imagepng($image);    //  On affiche l'image

?>
 
  • Partager sur Facebook
  • Partager sur Twitter
Anonyme
5 juillet 2007 à 11:07:07

Je viens de faire un triangle de sierpinski basique en ocaml :D :
Graphics.open_graph " 400x400";;
let rec sierpinski (a1, a2) (b1, b2) (c1, c2) =
  let draw_triangle (a1, a2) (b1, b2) (c1, c2) =
    Graphics.moveto a1 a2;
    Graphics.lineto b1 b2;
    Graphics.lineto c1 c2;
    Graphics.lineto a1 a2;
  in
    function
      | 0 -> ()
      | iter -> (
          draw_triangle (a1, a2) (b1, b2) (c1, c2);
          sierpinski (a1, a2) ((a1+b1)/2, (a2+b2)/2) ((a1+c1)/2, (a2+c2)/2) (iter-1);
          sierpinski (b1, b2) ((b1+a1)/2, (b2+a2)/2) ((b1+c1)/2, (b2+c2)/2) (iter-1);
          sierpinski (c1, c2) ((c1+a1)/2, (c2+a2)/2) ((b1+c1)/2, (b2+c2)/2) (iter-1);
        )
;;
sierpinski (0,0) (200,400) (400,0) 5;;
 

Voici le rendu:
Image utilisateur
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 11:09:32

Bon c'est ma première faite avec C et SDL

Image utilisateur

Je sais pas trop si c'est ce que vous attendez mais un fractale c'est simplement une image généré par ordinateur ou alors elle doit suivre un modèle du genre les triangles de Sierpinski ?

Edit : A la demande de bluestorm le code :

C'est une simple reprise des cours de M@téo21 sur SDL->Degradés mais ce qui fait la différence c'est les paramètres que l'on va mettre à i

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


int main(int argc, char *argv[])
{
    SDL_Surface *ecran = NULL, *lignes[151] = {NULL};
    SDL_Rect position;   
    SDL_Event event;
    int i = 0
    int continuer = 1;

    SDL_Init(SDL_INIT_VIDEO);

    ecran = SDL_SetVideoMode(300, 130, 32, SDL_HWSURFACE);

    for (i = 0 ; i <= 150 ; i++)
    {
    lignes[i] = SDL_CreateRGBSurface(SDL_HWSURFACE, 640, 1, 32, 0, 0, 0, 0);
    }


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

    for (i = 0 ; i <= 150 ; i++)
    {
        position.x = 0;
        position.y = i;
        SDL_FillRect(lignes[i], NULL, SDL_MapRGB(ecran->format, (i*2), (i/2), (i*i))); // Paramètre qui font la différence
        SDL_BlitSurface(lignes[i], NULL, ecran, &position);
    }

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


    for (i = 0 ; i <= 255 ; i++)
        SDL_FreeSurface(lignes[i]);

    SDL_Quit();

    return EXIT_SUCCESS;
}
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 11:10:36

Ma foi c'est un très bon sujet, je vais m'y mettre de ce pas, j'ai enfin trouvé une motivation à apprendre le Python cet été ! :D
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 11:12:38

Bon, par contre, si l'atelier continue à marcher aussi bien (ce qui n'est pas gagné), on risque d'avoir un problème d'encombrement du topic.

Organisation du topic


Je propose que vous postiez ici les réalisations complètement terminées, et que si vous voulez améliorer la création de quelqu'un, ou poser des questions dessus, ou que vous essayez de faire la même chose dans un autre langage, etc..., vous créiez un nouveau topic sur le forum, en pensant bien à rajouter "[Cod'Art]" au début du titre.


Master Linktim > toutes les images générées informatiquement, du moment que tu les trouves jolies, sont acceptées. Par ailleurs, si tu pouvais donner ton code, ou un lien vers ton code, ce serait parfait :p
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 11:14:40

Citation : Master Linktim

Bon c'est ma première faite avec C et SDL

Image utilisateur

Je sais pas trop si c'est ce que vous attendez mais un fractale c'est simplement une image généré par ordinateur ou alors elle doit suivre un modèle du genre les triangles de Sierpinski ?



C'est déjà pas mal =)
Si tu as besoin d'infos sur les fractales tu as wikipedia: Fractales
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 12:07:17

Pour changer des fractales, je vous propose maintenant une réalisation un peu différente.

Vous connaissez l'opérateur "modulo", en informatique ? Il s'écrit '%' en C ou PHP.
a modulo b, c'est le reste de la division (euclidienne) de a par b. Par exemple, 9 modulo 6 = 3, et 4 modulo 2 = 0.

L'idée de mon nouveau dessin est la suivante : pour un nombre N donné, on représente sur un cercle les nombres de 0 à N-1. À chaque fois qu'on prend deux nombres x et y sur le cercle, on peut les multiplier et regarder si le résultat vaut 1, modulo N (si (x * y) modulo N = 1). Si c'est le cas, on trace un trait entre les deux nombres.

Vous comprendrez peut-être plus facilement sur dessin :
Image utilisateur

L'idée de base est très simple, mais je n'avais aucune idée de ce que ça allait donner sur de grands nombres ! Ce qui est amusant, c'est essayer, explorer. Vous jugerez par vous-même, mais je trouve pour ma part que le résultat est satisfaisant.

Au départ, les résultats obtenus sont très simples :
Image utilisateur

Cependant, très vite, on voit des choses surprenantes apparaître :
Image utilisateur

Image utilisateur

On obtient finalement des choses assez jolies :
Image utilisateur
Image utilisateur



Vous pouvez lire le code source ici : http://bluestorm.info/mathdraw/mathdraw.ml.html
Il contient environ 60 lignes de code, en OCaml, et utilise la librairie de rendu cairo (j'avais envie d'essayer).
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 12:12:38

Hop, moi j'ai fait le Tapis_de_Sierpiński

Petit aperçu : ici

Et le code, en OCaml :

open Graphics;;
open_graph " 10000x1000";;

let s = 200;;
let color n = let coef = ((-n+s)*200/s) in rgb coef coef coef;;


let square x y size =
  set_color (color size);
  fill_rect (x-size/2) (y-size/2) size size;;

let rec tapis x y size n =
  let call x y = tapis x y (size/3) (n-1) in
  let rec next (a,b) = call (x+a*size) (y+b*size);
    match (a,b) with
      (-1, 0) -> next (-1, 1)
    | (-1, 1) -> next (0, 1)
    | (0 , 1) -> next (1, 1)
    | (1, 1) -> next (1,0)
    | (1, 0) -> next (1,-1)
    | (1, -1) -> next (0, -1)
    | (0, -1) -> next (-1, -1)
    | (-1, -1) -> () in
  match n with
    0 -> ()
  | n -> square x y size; next (-1, 0);;

tapis 500 500 s 8
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 12:12:51

Voici ma fractale que j ai faite avec Qbiom:Image utilisateur

voici la formule F(z)=z^1+1+e^z
C' est une formule très simple qui donne un beau resultat.
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 12:51:08

Je vous propose une image qui diffère des fractales, la spirale d'Ulam (bon c'est vrai c'est moins impressionnant...)

La spirale de Ulam

(On voit pas grand chose sur la miniature)

L'algorithme est tout simple, je génère un tableau de nombre premiers ordonnés en spirale puis, je colorie les pixels correspondant aux nombres premiers avec une couleur proportionnelle la distance au centre.

Le code source est là (C++): Spirale de Ulam

J'utilise la SDL uniquement.
  • Partager sur Facebook
  • Partager sur Twitter
Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.
5 juillet 2007 à 12:57:21

Pourquoi ne pas utiliser un Crible d'Ératosthène pour trouver les nombres premiers ? C'est beaucoup plus adapté dans ce cas.
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 13:01:03

C'est bien ce que je fais. Je construis le crible, puis je colorie.
  • Partager sur Facebook
  • Partager sur Twitter
Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.
5 juillet 2007 à 13:10:01

bool estPremier(unsigned int n)
{
   if (n % 2 == 0) //Si le nombre est pair
   {       
        if (n != 2)
            return false;
   } else {       //Sinon
        const double borneMax(sqrt((double) n));
        for (int i(3); i <= borneMax; i += 2)
        {
            if (n % i == 0)
                return false;
        }
    }
    return true;
}


Fake :-°
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 13:22:20

Ben oui, il faut bien tester quelque part si les nombres sont premiers

EDIT: ah non, je viens de comprendre. En effet je n'utilise pas le crible, cela me semblait trop compliqué de parcourir un tableau en spirale.
  • Partager sur Facebook
  • Partager sur Twitter
Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.
5 juillet 2007 à 13:28:24

Et hop, mandlebrot en une demie heure §

Le code est plus long cette fois ci, donc je ne le mettrais pas (c'est toujours de l'OCaml). Juste une screenshot et une autre
edit:
Le code suite à une pression de bluestorm :-°
ici
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 14:03:20

Haha ! voilà un post qui va me plaire ^^

voila mes réalisations (OpenGL) :

Image utilisateurImage utilisateurImage utilisateur

et, on peu tres certainement le faire avec une multitude d'autre couleurs ...

oops ^^ voilà mon code :

/*******************************************************************************
Titre :         Effet graphique en C avec OpenGL
Sous titre :             BitMAP Logique

By Tix.                                                     tixlegeek@gamil.com
http://www.tixlegeek.sup.fr                               (c) TRANSISTERIX 2007
*******************************************************************************/

#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
#define pi 3.14159265358979323846
#include <math.h>


typedef struct COLOR {
    GLbyte r;
    GLbyte v;
    GLbyte b;
} COLOR ;

/*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
/*::  This function converts decimal degrees to radians             :*/
/*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
double deg2rad(double deg) {
  return (deg * pi / 180);
}

/*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
/*::  This function converts radians to decimal degrees             :*/
/*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
double rad2deg(double rad) {
  return (rad * 180 / pi);
}

void assign(COLOR *variable, GLbyte r, GLbyte v, GLbyte b)
{
    variable->r = r;
    variable->v = v;
    variable->b = b;
}

int main(int argc, char *argv[])
{
    SDL_Init(SDL_INIT_VIDEO);
    SDL_WM_SetCaption("Fractal ?",NULL);
    SDL_SetVideoMode(255, 255, 32, SDL_OPENGL);
    // Definitions de l'environnement //
    gluOrtho2D(255,0,255,0);
    glPointSize(2);
    //********************************//
    bool continuer = true;
    SDL_Event event;
   
    COLOR pixelcolor;
    int x,y;
   
        glClear(GL_COLOR_BUFFER_BIT);
        glBegin(GL_POINTS);

            for(x=0; x<=255; x++)
            {
                for(y=0; y<=255; y++)
                {
                    assign(&pixelcolor, x&y, x&y, x&y);
                    glColor3ub(pixelcolor.r , pixelcolor.v, pixelcolor.b);
                    glVertex2d(x,y);
                }
            }
        glEnd();
        glFlush();
        SDL_GL_SwapBuffers();

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

    }

    SDL_Quit();

    return 0;
}
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 14:05:11

Pensez à donner votre code en même temps !


S'il fait moins de 30-40 lignes, vous pouvez le poster directement ici. Sinon, trouvez une bonne âme qui puisse l'héberger, et mettez un lien.
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 14:08:12

Sinon dans un tout autre style on peut s'amuser à dessiner des symboles ici j'ai réalisé une flèche, mais on pourrait imaginer réaliser des chiffres comme sur le cadran des scores dans un match de foot ou de basket.
Voici ma réalisation:
Image utilisateur

Et la voici le code source (C++) commenté pour réaliser cette image:

// TP BOUCLE
//exercice: on veut représenter une flèche d'étoile
#include <cstdlib>
#include <iostream>

using namespace std;

int main(void)
{
    //déclaration des variables
long etoile, espace, etoilemax=1,espaceMAJ,ligne;

//1ere étape du programme une grande boucke pour afficher le cône , la tête de la flèche
espaceMAJ=10;// cette variable correspond aux nombres  d'espace par ligne mis a jour à chaque répétition de la boucle
for(ligne=0;ligne<10;ligne++)
{
                espaceMAJ--;
                for(espace=espaceMAJ;espace!=0;espace--)
                {
                                 cout<<" ";
                }
                for(etoile=0;etoile<etoilemax;etoile++)
                {
                                 cout<<"*";
                }
                //on met à jour le nombre d'étoile total à afficher par ligne
     etoilemax+=2;
      cout<<endl;
 }
 
 
 //2ème étape du programme on affiche le corps de la flèche :
         //un rectangle de 5 étoile de longueurs sur 10 étoiles de largeurs(ligne)
         //avec une répétition de 7 espaces en début de chaque ligne pour le centrer.
         for(ligne=0;ligne<10;ligne++)
         {
    for( espace=7;espace!=0;espace--)
    {
         cout<<" ";
    }
        for(long etoile=0;etoile<5;etoile++)
        {
                 cout<<"*";   
        }
     cout<<endl;
         
    }
    system("PAUSE");
    return EXIT_SUCCESS;
}



 

  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 14:09:28

À mon tour.
C'est du ruby, avec rmagick (ImageMagick).
Le code, avec tout les fichiers.
Ça utilise beaucoup de nombres aléatoires :)

Image utilisateur
  • Partager sur Facebook
  • Partager sur Twitter
5 juillet 2007 à 14:21:50

Alors moi j'ai tatonné pas mal, pour finalement arriver a un truc relativement simple, qui peut rendre pas mal et qui (je pense) est assez original (je sais pas ça a un nom, si quelqu'un l'as déjà "trouvé" , etc).

Voici le résultat "de base" :

Image utilisateur



Ici la fonction qui dessine :

void
draw(void)
{
    int x,y;
    int nb = 0;
    int mult;

    /* les arguments de pixel() sont les coordonnés
     * puis la quantité de rouge/vert/bleu
     */



    for(y=0; y<IMG_SIZE; y++) {
        for(x=0; x<IMG_SIZE; x++) {
            mult = x*y%256;
            pixel(x, y, mult, mult, mult);
            nb = (nb+2)*(nb+2)%256;
        }
    }

    return;
}   
 


En coloriant (en faisant varier/ajouter des facteurs) on peut obtenir de joli chose (cliquez pour plus grand) :

Image utilisateur


Je vais mettre des variantes de 256*256. Chaque image est cliquable pour une version plus grande (768*768 en mosaique).

Image utilisateurImage utilisateur
Image utilisateurImage utilisateur

wala :]




  • Partager sur Facebook
  • Partager sur Twitter