Bouuuuhhhhh le C c compliqué :( - Page 1

char cible[LCD_SIZE],source[LCD_SIZE];
int new_x,new_y,r;
unsigned int x,y;
memcpy(source,LCD_MEM,LCD_SIZE);
PortSet(cible,239,127);
*** AFFICHAGE D'UN FICHIER PIC (VOIR TIGCC) ***
PortRestore();
*** PLACE LES DIMENTIONS X & Y DU PIC DANS COMMANDES[8] & [9] ***
for(x=0;x<=commandes[8];x++)
for(y=0;y<=commandes[9];y++)
{
new_x=x-commandes[4];
new_y=y-commandes[5];
r=((new_x^2)+(new_y^2));
if(sqrt(r)!=0)
{
new_x=sqrt(r)*dcos(dacos(new_x/sqrt(r))+commandes[6]);
new_y=sqrt(r)*dsin(dasin(new_y/sqrt(r))+commandes[6]);
}
if(EXT_GETPIX(cible,x,y))
{
EXT_SETPIX(source,(commandes[2]+commandes[4]+new_x),(commandes[3]+commandes[5]+new_y));
}
else
{
EXT_CLRPIX(source,(commandes[2]+commandes[4]+new_x),(commandes[3]+commandes[5]+new_y));
}
}
LCD_restore(source);
}


Bouhhhhhh ça marchait presque en basic, même si je doit être loin de la solution la plus rapide
Pkoi ça marche pas là ???

Les variables de 'commandes' :
commandes[0] = non utilisé
commandes[1] = non utilisé
commandes[2] = position X ou doit etre affiché le sprite final
commandes[3] = position Y ou doit etre affiché le sprite final
commandes[4] = centre de rotation X
commandes[5] = centre de rotation Y
commandes[6] = angle de rotation

dcos, dsin, dacos et dasin sont des macros de Kevin qui servent à utiliser des degrés et non des radians.
[edit]Edité par Bob 64 le 10-01-2002 à 08:51:57[/edit]

C'est quoi tes erreurs? et c'est pour faire quoi?

Bah l'erreur c que ça marche pas
Et normalement c'est sencé être 1 prgm de rotation

Mais qu'est ce qui marche pas, ca compile ou pas
Ca fait quelque chose a l'écran?

d'abord un truc tour con au niveau optimisation: remplace sqrt(r)!=0 par r!=0, c'est pareil.
ou plustôt stocke le resultat de sqrt(r) dans une variable un fois pour toute. Je connais pas l'algo mais ca doit prendre un peu de temps a le recalculer a chaque fois
[edit]Edité par Uther Lightbringer le 10-01-2002 à 16:27:58[/edit]

oui, les racines carrées, c'est TRES long à calculer, par rapport au temps d'accès à une variable !!

heu bah oui mais 1 racine c'est décimal... Et en C les décimales on s'y prends comment ?
Sinon mon algo si encore il était lent, ça serait déjà pas mal... Mais il ne marche pas du tout : Un busy qui ne s'arrete jamais ou blocage total de la calc

arf...

déjà, tu peux allouer dynamiquement les deux écran : 2*LCD_SIZE = 2*3840 = bcp !!!
(surtout qd on sait que le stack est limité à environ 16ko)
=> ça t'évitera des pb par la suite

Squale92> Je me souviens au début personne ne m'a expliqué ca. nfin si juste au moment ou j'avais trouvé la solution.(et t'en a parlé dans ton tuto 2 semaines après)

Bob64> Les decimaux en C c'est Float. D'ailleur ton erreur vient peut être d'un problème de conversion. C'est le genre d'érreur chiantes a détecter. Ce soir j'essaierai de compiler ca pour voir.

non c bon y'a que ça à stocker et après ça quitte.

en fait pr l'instant il est sensé faire la rotation et l'afficher sur l'écran, mais quand ça marchera il sauvegardera directement le résultat dans une variable pic pour la réutiliser en basic...

Ça ne marche pas parce qu'il faut des floats. Et si ce que tu veux faire est une rotation, essaye le suivant:

char source[LCD_SIZE],cible[LCD_SIZE];
int x,y,sourcex,sourcey;
__complex__ float expmoinsitheta,sourcexplusiy;
memcpy(cible,LCD_MEM,LCD_SIZE);
PortSet(source,239,127);
/*** AFFICHAGE D'UN FICHIER PIC (VOIR TIGCC) ***/
PortRestore();
/*** PLACE LES DIMENTIONS X & Y DU PIC DANS COMMANDES[8] & [9] ***/
sincos(-commandes[6],1,& __imag__ expmoinsitheta,& __real__ expmoinsitheta);
for(x=0;x<=239;x++)
for(y=0;y<=127;y++)
{
sourcexplusiy=((float)(x-commandes[4])+1.0i*(float)(y-commandes[5]))*expmoinsitheta;
sourcex=__real__ sourcexplusiy;sourcey=__imag__ sourcexplusiy;
if((sourcex>=0)&&(sourcex<commandes[8])&&(sourcey>=0)&&(sourcey<commandes[8]))
{
if(EXT_GETPIX(source,sourcex,sourcey)) EXT_SETPIX(cible,x,y); else EXT_CLRPIX(cible,x,y);
}
}
LCD_restore(cible);

J'ai aussi interchangé "cible" et "source", c'est plus clair.
[edit]Edité par Kevin Kofler le 11-01-2002 à 01:26:52[/edit]

Problème: cette routine est très très lente. Mais elle fonctionne. On doit pouvoir limiter les coordonnées dans le for pour accélérer un peu. Sinon, il y a aussi la virgule fixe. (Les tables de sinus et de cosinus ne servent à rien, vu qu'il suffit de les calculer une fois au début.)

Et Thíbaut, en voilà un de programme qui utilise les nombres complexes.

Whao il va me falloir un peu de temps avant de comprendre ça, mais comme d'habitude j'imagine que ça marche
Si c'est aussi rapide que l'algo de rotation que tu m'avait corrigé, ça devrait être suffisant.

En tout cas merci

C'est probablement plus rapide que le tien: pas de racines carrées, et je ne recalcule pas un cosinus et un sinus à chaque fois. Ce qui fait ralentir, c'es que je pars de la destination pour trouver la source et que je ne limite pas l'intervalle de la destination. Mais on est bien obligés de partir de la destination si on veut avoir un résultat correct. Si on veut accélérer, il faut limiter l'intervalle.
Normalement:
int dmax,xmin,xmax,ymin,ymax;
...
dmax=commandes[8]+commandes[9]-2;
xmin=max(commandes[4]-dmax,0);
xmax=min(commandes[4]+dmax,239);
ymin=max(commandes[5]-dmax,0);
ymax=min(commandes[5]+dmax,127);
for(x=xmin;x<=xmax;x++)
for(y=ymin;y<=ymax;y++)
...
devrait suffire si le centre de rotation est à l'intérieur de l'image.

Et sinon, les coordonnées d'affichage n'étaient pas les bonnes (erreur de ma part).

Cela devrait être plus correct (ça a l'air bien avec un carré noir 8×8):

char source[LCD_SIZE],cible[LCD_SIZE];
int x,y,sourcex,sourcey,dmax,xmin,xmax,ymin,ymax,centrex,centrey;
__complex__ float expmoinsitheta,sourcexplusiy;
memcpy(cible,LCD_MEM,LCD_SIZE);
PortSet(source,239,127);
/*** AFFICHAGE D'UN FICHIER PIC (VOIR TIGCC) ***/
PortRestore();
/*** PLACE LES DIMENTIONS X & Y DU PIC DANS COMMANDES[8] & [9] ***/
sincos(-commandes[6],1,& __imag__ expmoinsitheta,& __real__ expmoinsitheta);
centrex=commandes[2]+commandes[4];
centrey=commandes[3]+commandes[5];
dmax=commandes[8]+commandes[9]-2;
xmin=max(centrex-dmax,0);
xmax=min(centrex+dmax,239);
ymin=max(centrey-dmax,0);
ymax=min(centrey+dmax,127);
for(x=xmin;x<=xmax;x++)
for(y=ymin;y<=ymax;y++)
{
sourcexplusiy=((float)(x-centrex)+1.0i*(float)(y-centrey))*expmoinsitheta;
sourcex=(int)(__real__ sourcexplusiy)+commandes[4];sourcey=(int)(__imag__ sourcexplusiy)+commandes[5];
/* Là, dans ta source, commandes[4] et commandes[5] ne seraient pas ajoutées, mais je pense que c'est une erreur. */
if((sourcex>=0)&&(sourcex<commandes[8])&&(sourcey>=0)&&(sourcey<commandes[8]))
{
if(EXT_GETPIX(source,sourcex,sourcey)) EXT_SETPIX(cible,x,y); else EXT_CLRPIX(cible,x,y);
}
}
LCD_restore(cible);
[edit]Edité par Kevin Kofler le 11-01-2002 à 15:39:31[/edit]

Et ce qu'il y a à comprendre ici, ce n'est pas du C, ce sont des mathématiques (du programme de TS).

L'image M' d'affixe* z' d'un point M d'affixe* z par la rotation de centre O d'affixe* o et d'angle a est:
e^(ia)(z-o) + o
(programme de TS spécialité Mathématiques)
Dans ceci:
addition de 2 complexes: (x+iy)+(x'+iy')=(x+x')+i(y+y')
soustraction de 2 complexes: (x+iy)-(x'+iy')=(x-x')+i(y-y')
multiplication de 2 complexes: pas besoin de comprendre celle-ci pour comprendre ma source, car je la fais faire à GCC, mais c'est: (x+iy)(x'+iy')=(xx'-yy')+i(xy'+x'y)
e^(ia) (a réel): cos(a)+i sin(a) - C'est ce que calcule ma commande sincos.
(programme de TS enseignement obligatoire de Mathématiques)

Et j'utilise -commandes[6] pour a parce que j'ai besoin de la transformation réciproque à celle qui est demandée et que la transformation réciproque à la rotation de centre O et d'angle a est la rotation de centre O et d'angle -a.

* L'affixe d'un point M(x,y) est le nombre complexe x+iy. (programme de TS enseignement obligatoire de Mathématiques)

Oué bon donc la je ne comprends plus rien du tout... C'est vrai qu'il me manque les cours pr comprendre ton algo mais par exemple "__real__" je ne savais pas que ça s'utilisait comme ça.
Donc re-merci, je teste dès que je suis chez moi.

Ça me rappelle qqun...
"Lisez la FAQ, les tutos et les readme..."

Là ce serait plutôt "les cours de TS"

J'aurais du mal...

Bon, Kevin, ta fonction marche mais il y a un léger problème... Surement une erreur de ma part mais... Enfin juge par toi-même, et soit patient le screen est long

Le résultat est excellent. Si les discontinuités dans les triangles du haut (oreilles?) te gènent, essaye:
sourcex=(int)(__real__ sourcexplusiy+.5)+commandes[4];sourcey=(int)(__imag__ sourcexplusiy+.5)+commandes[5];
au lieu de:
sourcex=(int)(__real__ sourcexplusiy)+commandes[4];sourcey=(int)(__imag__ sourcexplusiy)+commandes[5];
Ça donne un arrondi propre à la place d'une troncature, mais c'est plus lent.
Et je ne sais pas si ça améliore vraiment la qualité (qui est, je trouve, déjà très bonne pour une rotation d'une image aussi petite).
[edit]Edité par Kevin Kofler le 11-01-2002 à 19:52:20[/edit]

Je ne critique pas, les discontinuitées ne me genent absolument pas et la rotation est exellente comme tu dis pr une image de cette taille.

Mais... Heu... C'est normal qu'il mette environ 30 secondes à l'afficher ma petite image ?

Euh... oui.
Avec des calculs en virgule flottante, ce n'est pas étonnant...

Il faudrait que je réécrive ça en virgule fixe...

Non non ne te casse pas la tête et merci pr le mal que tu t'es déjà donné.
Je ferais sans rotations, c'est pas grave.

À essayer:

char source[LCD_SIZE],cible[LCD_SIZE];
short x,y,sourcex,sourcey,dmax,xmin,xmax,ymin,ymax,centrex,centrey;
__complex__ float expmoinsitheta;
__complex__ short expmoinsitheta32768;
__complex__ long sourcexplusiy32768;
memcpy(cible,LCD_MEM,LCD_SIZE);
PortSet(source,239,127);
/*** AFFICHAGE D'UN FICHIER PIC (VOIR TIGCC) ***/
PortRestore();
/*** PLACE LES DIMENTIONS X & Y DU PIC DANS COMMANDES[8] & [9] ***/
sincos(-commandes[6],1,& __imag__ expmoinsitheta,& __real__ expmoinsitheta);
expmoinsitheta32768=expmoinsitheta*32767.; /* c'est sale, mais ça évite les débordements */
centrex=commandes[2]+commandes[4];
centrey=commandes[3]+commandes[5];
dmax=max(commandes[8]+commandes[9]-2,0);
xmin=max(centrex-dmax,0);
xmax=min(centrex+dmax,239);
ymin=max(centrey-dmax,0);
ymax=min(centrey+dmax,127);
for(x=xmin;x<=xmax;x++)
for(y=ymin;y<=ymax;y++)
{
sourcexplusiy32768=((x-centrex)+1i*(y-centrey))*(__complex__ long)expmoinsitheta32768;
sourcex=((__real__ sourcexplusiy32768)>>15)+commandes[4];sourcey=((__imag__ sourcexplusiy32768)>>15)+commandes[5];
if((sourcex>=0)&&(sourcex<commandes[8])&&(sourcey>=0)&&(sourcey<commandes[8]))
{
if(EXT_GETPIX(source,sourcex,sourcey)) EXT_SETPIX(cible,x,y); else EXT_CLRPIX(cible,x,y);
}
}
LCD_restore(cible);

Je n'ai pas encore essayé ce que ça donne.


Voilà, ça marche maintenant.
[edit]Edité par Kevin Kofler le 11-01-2002 à 20:32:17[/edit]

Il faudrait incorporer le compilateur TIGCC au forum ainsi que VTI

En tout cas, c'est faux. Je vais voir ce qui ne va pas.

Mise à jour: C'est bon maintenant (cf. message 31).
[edit]Edité par Kevin Kofler le 11-01-2002 à 20:33:43[/edit]