bonjour , cela fait un moment que j’essaye de faire un programme pour obtenir l'éponge de sierpinski

mais je ne vois pas comment l'obtenir directement, j'ai d'abord fais un cube en 3D avec des faces et leurs couleurs respectives pour les reconnaitre puis je penses que je dois faire des sous-éponges dans des éponges etc... pour avoir le dessin en 3D

si vous savez comment le faire en ocaml/caml
merci d'avance

En Ocaml c'est très simple puisque tu peux faire des fonctions récursives très facilement.
Tu dois juste faire une fonction qui fait la première itération :

Partir d'un cube plein
Faire les trous
Délimiter les 20 petits cubes ainsi créés.
Rappeler ta fonction récursivement sur chacun d'eux.

Attention, il faut le faire une nombre fini de fois quand même, sinon ta fonction va boucler. Ajoute un argument "nombre d'itérations" que tu décrémentes lors de chaque appel récursif.

La clé va être d'avoir des structures de données assez générales pour stocker ton cube, afin de te permettre de faire l'appel récursif sur les sous-cubes C'est pas forcément évident je pense.

oui mais c'est surtout l'approche du : par où commencer et quoi modifier à chaque itération qui posait problème,
pour l'instant j'ai juste un cube 3D avec 3 faces visibles donc si je suis bien ton truc , je devrais commencer à faire les trous

je vous en dirais plus quand j'aurais fais un peu plus

Quelle structure de données tu utilises pour stocker ton cube ?

je n'ai pas mon programme actuellement avec moi, m

je n'ai pas mon programme actuellement avec moi, mais je l'aurais dans pas longtemps :
sinon pour la structure:

on part d'abord des coordonnées homogènes donc pour cela on utilise le module Array

- ensuite une fonction produit m1 m2 qui fait le produit matriciel de m1 par m2 et qui renvoie la matrice résultat

- puis, une fonction produit3d x y z qui renvoie la matrice colonne donnant les coordonnées homogènes du point (x,y,z) afin de pouvoir utiliser le produit matriciel que l'on vient de définir

- puis une fonction t3d tx ty tz qui renvoie la matrice de la translation de vecteur (tx,ty,tz) en coordonnées homogènes.

- puis, une fonction rot3d thetax thetay thetaz qui renvoie la matrice de la transformation qui effectue les rotations d'angles des theta autour de leurs axes respectifs.

-puis, une fonctio invRot3d thetax thetay thetaz qui renvoie la matrice de la transformation inverse de la précédente.

- puis, il faut définir la matrice projParallele3dz de la projection parallèle orthographique sur le plan (oxy).

- puis écrire la fonction projPerspective3dz x y d de la projection perspective dont le centre se situe en (x,y,d).

après cela, il faut alors faire les projections:

- pour que ce soit plus précis, il faut définir la fonction round x qui arrondit à l'entier le plus proche le réel x.

- puis, qu'il s'agisse d'une proj parallèle orthographique ou d'une proj perspective, le plan de projection (l'écran) aura pour équation z=0. et une fois la projection faite, seules les coordonnées en x et en y nous sont utiles.
il faut donc ensuite écrire la fonction line3d p1 p2 qui trace le segment d'extrémité avec les points p1 et p2.

- puis, écrire la fonction cube3dfdfParallèle x y z c a1 a2 a3 qui trace un cube de centre (x,y,z) de coté c sur lequel on a fait agir rot3d a1 a2 a3. tous les paramètres de cube3dfdfParallèle sont de type float.

et à partir de cela, on obtient un dessin avec des segments parallèles formant le cube en 3d.

- ensuite, il faut écrire la fonction rad_of_deg qui convertit des degrés (de type int) en radians (de type float). puis définir la fonction cube3d x y z c a1 a2 a3 dont les paramètres sont entiers et qui appelle cube3dfdfParallèle en les convertissant.

- et puis, faire de même avec une proj perspective

après ceci, on peut maintenant voir de plus près comment avoir l'éponge de sierpinski. on met les programmes suivants à la suite des précédents.

- d'abord, écrire une fonction face poly couleur qui dessine en couleur le polygone poly en utilisant la fonction fill_poly. Cette fonction servira à dessiner les faces du cube.

- le cube est un cube ABCDEFGH. il faut donc associer les couleurs blue, yellow, red , cyan , magenta , green à chacune des faces. ( il y en a 6)
dans une projection orthographique du cube, on ne pourra voir au plus que trois faces. ces trois faces ont un unique sommet en commun et il faut donc parcourir les sommets du cube pour savoir lequel se trouve le plus proche du plan de projection (soit plus grand que z) pour dessiner les trois faces correspondantes.

- donc, ensuite écrire le fonction cube3dParallèle cx cy cz c a1 a2 a3 qui dessine les trois faces les plus proches du cube de centre (cx,cy,cz) et de coté c sur lequel on a fait agir rot3d a1 a2 a3. les paramètres de cette fonction sont tous réels

- puis, écrire une fonction cub3d x y z c a1 a2 a3 qui a tous ses paramètres entiers et qui appelle cub3dParallèle après conversion.

on obtient alors un cube en 3d avec 3 faces colorées.

et maintenant, l'éponge de sierpinski, voici la partie où je ne vois pas vraiment comment faire :

- le principe de l'éponge de sierpinski est : une éponge de sierpinski d'ordre n est 20 éponges de sierpinski d'ordre n-1

- donc, il faut écrire la fonction appels (cx,cy,cz) (x,y,z) c a1 a2 a3 dans laquelle (cx,cy,cz) est le centre de l'éponge finale et (x,y,z) le centre de la sous-éponge de coté c que l'on va elle même décomposer 20 sous-sous-éponges en sachant que l'éponge subie la transformation rot3d a1 a2 a3. cette fonction appels va générer la liste des 20 centres des éponges issues des appels récursifs.

- ensuite, il faut dessiner les sous-éponges en commençant par la plus éloignée (le z le plus petit) pour finir par la plus proche (le z le plus grand).
et donc, écrire pour cela une fonction qui trie une liste de triplets (les coordonnées des centres) par ordre croissant de z.

- et pour finir, écrire la fonction éponge cx cy cz ordre a1 a2 a3 dont les paramètres sont des entiers et qui affiche via une proj orthographique une éponge de centre (cx,cy,cz) de coté c d'ordre ordre et tournée par rot3d a1 a2 a3.

tu vois un peu à quoi ca ressemble ? je te montrerais le programme bientôt , sinon est ce que c'était de ça que tu me parlais ?

personne d'autre ne verrais comment faire ?

C'est vraiment pas très joli tout ça, tu mélanges totalement toutes les parties de ton programme. Tu m'as décrit la partie affichage, qui m'a l'air correcte. Mais maintenant, tu dois générer un modèle 3D correspondant à ton éponge, que tu devras par la suite afficher. Mais mélanger ces deux étapes n'est pas du tout une bonne idée, ça va engendrer des bugs et produire du code sale.

Ce qu'il te faut, c'est une structure de données abstraite te permettant de stocker en mémoire un modèle 3D. Puis tu vas travailler sur ce modèle, et ce n'est qu'à la fin que tu feras appel à une fonction d'affichage.
Par exemple, tu peux simplement prendre une liste de toutes les faces du modèle 3D. Pour la manipuler aisément, tu peux associer à chaque face ses côtés et ses sommets. C'est la méthode "naïve", il y a sans doute mieux à faire.

Ensuite, tu travailleras sur cette structure abstraite, sans te soucier de l'affichage. Tu pars d'un cube, et puis tu as deux solutions :
Soit, tu fais des trous dedans et tu rappelles ta fonction récursivement pour faire des trous sur les sous-cubes (tu itères sur des cubes de plus en plus petits).
Soit, tu la dupliques 20 fois et tu assembles les bouts pour faire l'itération suivante, qui sera alors plus grosse.

Dans tous les cas, tu n'as jamais à parler des "sous-sous-éponges"

Bonjour,

Comme le dit CavalierAnal, sépare bien tes fonctions (c'est la base de la programmation en fait de découpé un GROS problème et petits problèmes .

1) Essais de créer un cube, et affiche le, puis revient nous voir :p

bonjour, alors voilà le programme fonctionne , il y a le cube en parallèle puis en perspective et le cub3D qui affiche donc le cube avec 3 faces différentes
http://pastebin.com/X7eWSghJ

mais c'est à partir de la fonction appels que je ne vois pas comment faire ensuite
merci d'avance pour l'aide

Comme j'ai dit, tout ce que tu fais c'est de l'affichage. Tu n'as pas ton cube en mémoire quelque part, tu ne fais que l'afficher à l'écran. Du coup, tu ne peux pas faire de calculs dessus... Il faut abstraire tes structures de données et non pas tout hardcoder dans la même fonction

et on doit vraiment le faire pour obtenir l'éponge de sierpinski qu'il soit stocké quelque part ou non ?

Tu ne dois pas *vraiment* le faire, dans le sens où, tu pourrais très bien par exemple ne pas faire faire un seul calcul à l'ordinateur, dessiner ton éponge de sierpinski à la main sur du papier, mesurer les distances à la règle, et entrer les coordonnées de tous les points du dessin dans ton ordinateur pour les afficher à l'écran.

Mais faire ça, ça n'a pas grand intérêt. Le but de la programmation est de faire faire les choses. La différence entre travailler sur des structures de données abstraites et travailler sur l'affichage à l'écran de ton cube, c'est un peu le même. Ce que tu fais n'est trop dans l'esprit de ce qu'on fait normalement en programmation. Si tu apprends à abstraire tes données, ton code sera bien plus facile à écrire, et bien plus clair.

oui je vois ce que tu veux dire, mais d'abord faire l'affichage en entrant les coordonnées pour voir si ça fonctionne et ensuite faire un autre programme avec des calculs pour l'affichage c'est aussi une manière de faire

Bonjour,

En général il vaut mieux avoir en mémoire la forme a afficher.

En plus là tu doit partir d'un cube et récursivement le "découper" donc le résultat doit lui aussi être stocker quelque part non??

La règle en programmation c'est qu'une fonction ne fait qu'une chose et une seule. Donc tu a une fonction d'affichage et une autre pour calculer tes formes. Si tu a pas en mémoire la résultat du calcul, l'affichage ne sais pas quoi afficher.