Demande d'aide pour un programme en C

[invited308680e]

Bonjour,

Je souhaite réaliser un programme réalisant la transformation dite du photomaton (c.f : http://fr.wikipedia.org/wiki/Transfo..._du_photomaton)

Pour simplifier le problème je ne travaille pas sur des images réelles mais sur une matrice. Le programme réalisant la transformation marche bien mais j'aimerais trouver un moyen pour connaitre l'orbite de chaque composant de la matrice.

C'est à dire comment connaitre les différentes positions que va occuper un composant de la matrice (un pixel dans le cas d'une image) avant de revenir à l'étape initiale.

Mon but est de réaliser un programme affichant une matrice et qui donne la possibilité de pouvoir cliquer sur n'importe quel élément et obtenir un tracé de son orbite.

Voilà j'espère n'avoir pas été trop confus.
Merci d'avance pour votre aide.
-----

[polo974]

Bonjour,

Je souhaite réaliser un programme réalisant la transformation dite du photomaton (c.f : http://fr.wikipedia.org/wiki/Transfo..._du_photomaton)

Pour simplifier le problème je ne travaille pas sur des images réelles mais sur une matrice. Le programme réalisant la transformation marche bien mais j'aimerais trouver un moyen pour connaitre l'orbite de chaque composant de la matrice.

C'est à dire comment connaitre les différentes positions que va occuper un composant de la matrice (un pixel dans le cas d'une image) avant de revenir à l'étape initiale.
...

d'abord, ce qu'il se passe en X est indépendant de ce qu'il se passe en Y.

puis largeur et hauteur sont paires (sinon, il faut modifier l'image d'une façon ou d'une autre pour y arriver, mais ça va changer fondamentalement le résultat suivant la méthode utilisée...)

ensuite:
X[n+1] = (X[n] + (X[n] % 2) * LX) / 2;
Y[n+1] = (Y[n] + (Y[n] % 2) * LY) / 2;
avec X[0] Y[0], point initial, n itération de 1 à ...(PPCM (LX, LY) pour un retour au départ)
X[i] suite des x, et LX largeur de l'image
et Y[i] suite des y, et LY hauteur de l'image

[invited308680e]

Bonjour,

Malheureusement après plusieurs essai infructueux je n'arrive toujours pas à réaliser le tracé des orbites.

Voici ce que vous m'avez expliqué:

"d'abord, ce qu'il se passe en X est indépendant de ce qu'il se passe en Y.

puis largeur et hauteur sont paires (sinon, il faut modifier l'image d'une façon ou d'une autre pour y arriver, mais ça va changer fondamentalement le résultat suivant la méthode utilisée...)

ensuite:
X[n+1] = (X[n] + (X[n] % 2) * LX) / 2;
Y[n+1] = (Y[n] + (Y[n] % 2) * LY) / 2;
avec X[0] Y[0], point initial, n itération de 1 à ...(PPCM (LX, LY) pour un retour au départ)
X[i] suite des x, et LX largeur de l'image
et Y[i] suite des y, et LY hauteur de l'image"

Et voici comment je l'ai traduit.

void transfoPoint(int ppcm,int Li, int Co,XPoint MZ){

int i;
XPoint m;
XPoint n;
m.x=MZ.x;
m.y=MZ.y;

for(i=0;i<ppcm;i++){
n.x= (m.x + (m.x% 2) * Co) / 2;
n.y= (m.y + (m.y% 2) * Li) / 2;

drawLine(m,n);

m.x=n.x;
m.y=n.y;
}}

// avec Li le nombre de lignes et Co le nombre de colonnes et MZ le point initial.
Cependant cela ne semble pas marcher car imaginons que le point de départ soit 1,1 autrement dit un point invariant car dans un coin et bien selon l'algorythme dans une matrice (8,8) on obtient pour point X[n+1]=(1 + 1*8)/2= 3.5 différent de 1. J'en déduit que je n'ai rien compris ^^.

Je précise également que dans mon cas le coin en haut à gauche ne se trouve pas en (1,1)
mais on position (200,200) et l'intervalle entre chaque point et de 50. Le point (1,2) est donc à (200,250).
Je ne sais pas si cela change quelque chose.

Pourrais je avoir de nouvelles explications ?
Merci d'avance.

[yoda1234]

Merci d'utiliser les balises à votre disposition, et dans ce cas la balise code:

[A voir en vidéo sur Futura]

[invited308680e]

Finalement en cherchant un peu j'ai pu comprendre comment cela fonctionnais.

Mon nouveau code est celui-ci:

void transfoPoint(int ppcm,int Li, int Co,XPoint MZ){

int i;
XPoint pointm;
XPoint pointn;
XPoint pointM;
XPoint pointN;

pointm.x=(MZ.x-200)/50;
pointm.y=(MZ.y-200)/50;

for(i=0;i<ppcm +1;i++){

pointn.x= ((pointm.x + (pointm.x% 2) * Co) / 2);
pointn.y= ((pointm.y + (pointm.y% 2) * Li) / 2);

pointM.x=200+(pointm.x*50);
pointM.y=200+(pointm.y*50);
pointN.x=200+(pointn.x*50);
pointN.y=200+(pointn.y*50);

if(i%4==0)setForeground(RED);
if(i%4==1)setForeground(YELLOW);
if(i%4==2)setForeground(GREEN);
if(i%4==3)setForeground(BLACK);

drawLine(pointM,pointN);
pointm.x=pointn.x;
pointm.y=pointn.y;
}}

Je reviens à une matrice avec pour point initial (0,0) et un espace entre chaque point de seulement 1.

Puis je reconverti tout cela pour revenir à ma matrice graphique.


Simple petite question mais très importante, cela n'est pas sensé marché pour des matrices qui ne sont pas carré ???? Car des que je fais le test sur des matrice qui ne sont pas carré ça ne marche plus du tout.

Merci encore pour votre aide.

[polo974]

De retour sporadique sur les ondes....

Suite au MP en gros identique au message du 26/05/2008 13h29:
La question sur la division d'un entier semble résolu (pas de .5 qui tienne, on tronque).
Le fait que le travail parte d'une position particulière (+200) avec un pas particulier (50) n'est qu'un "vague souci" d'accès au points à traiter, une fonction ou une macro pour régler la chose et on n'en parle plus:
int X( int x){return x*pasx+deltax;}
int Y(int y){return y*pasy+deltay;}


Par contre la boucle:
for(i=0;i<ppcm +1;i++)
pour ppcm itérations c'est:
for(i = 0; i < ppcm; i++)
de plus, c'est la boucle extérieure, il faut un truc du genre

copie initiale de l'image départ vers arrivée pour le gros des pixels non traités
for(i = 0; i < ppcm; i++)
{
   for(y= 0; y< nblignes ;y++)
       for(x = 0; x < nbcolonnes; x++)
           travail sur le pixel avec une image de départ et une d'arrivée

   copie de l'arrivée vers le départ et affichage de l'étape
}

ou bien, comme le travail en x est indépendant du travail en y

copie initiale de l'image départ vers arrivée
for(i = 0; i < ppcm; i++)
{
   for(y= 0; y< nblignes ;y++)
        travail sur la ligne avec une image de départ et une d'arrivée

   for(x = 0; x < nbcolonnes; x++)
        travail sur la colonne avec une image de départ et une d'arrivée

   copie de l'arrivee vers le départ et affichage de l'étape
}

donc:

• il faut une image d'arrivée différente de celle de départ
• pour chaque niveau d'itération, il faut traiter toute l'image (ou du moins l'ensemble des pixels à traiter).

Le xsuivant de dépend que du xcourant (et pas du ycourant)
Le ysuivant de dépend que du ycourant (et pas du xcourant)
donc indépendance X,Y que le second algo proposé exploite clairement et consiste à échanger L lignes puis C colonnes (L + C itérations sur des ensembles de points) alors que le premier réalise (L * C itérations sur des points).


Pour des matrices non carrées, si le ppcm est bien calculé, le retour doit se faire.