calibration multi point

Bonjour,

Pour la calibration d'une dalle tactile , j'ai besoin de recupérer des points a l'écran.
donc jai des coordonnées théoriques (les croix affichées a l'écran) , et des coordonnées réelles (celles retourné par la dalle tactile )

J'ai déja réalisé une calibration classique en 2 ou 3 points mais la je cherche a amélioré la précision en découpant la surface de la dalle .
Le probleme, c'est que par exemple si je decoupe la dalle en 9 parties , quand je passe d'une partie a une autre de la dalle , ca fait des cassures dans le rendu a l'écran .

je suis parti sur un tableau de 289 points . ( 17 X 17 )
Pour la calibration je demande a l'utilisateur d'appuyer sur des points a l'écran mais je veux laisser le choix du nombre de points ( car 289 ca fait beaucoup )
par contre pour eviter les cassures , meme si l utilisateur ne fait que 9 points , je calcules les valeurs intermédiares en faisant la moyenne des points adjacents pour arrivé aux 289 points.

Donc au minimun j'ai 4 points (le 0,16,272,288) ( les coins )
Apres je passe a 9 points ( les memes + 8,136,144,152,280)
Apres je passe a 25 ... etc ..

donc exemple , si il ny a que 4 points , avec le 0 et 16 , jai le 8 en faisant la moyenne . ensuite avec le 0 et le 8 , jai le 4 etc ....

donc mon probleme est le suivant , j'ai du mal a élaborer un algo pour retrouver tous les points manquants , suivant le nombre de points que l'utilisateur a rentrés .

Si qq'un a compris (j'avoue c'est pas super clair) et a une idée qui pourrait m'aider ou meme une autre orientation qui semblerait meilleur je suis preneur :p

Pas Compris 8O

oui , je viens de relire mon message et j'avoue c'est imcompréhensible :(
et je sais pas trop comment expliquer ...

je vais essayer de simplifier sans donner d'explication sur la finalité de la chose .

jai un tableau de 289 points disposé de la sorte (17x17)

. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .

si je les numérote de 0 a 288 , en partant en haut a gauche.
par exemple théoriquement le 8 est la moyenne de coordonnées du 0 et du 16.
donc si jai la valeur d'au moins les 4 Coins , je peut retrouver les valeurs de tous les autres .

je sais pas si c'est plus clair la ... :roll:

Citation:

---

Envoyé par Platypus

donc si jai la valeur d'au moins les 4 Coins , je peut retrouver les valeurs de tous les autres .

je sais pas si c'est plus clair la ... :roll:

---

C'est un peu mieux.

pour ce que je viens de citer, oui ton raisonnement est juste.

pourquoi ne pas numéroter tes points classiquement, sous la forme (x,y) ou 1>=x,y<=17 ?

Après, réexplique une derniere fois, je pense que tu veux faire des moyennes d'une certaines façon?

donc a partir des 4 coins , je trouve les points numéro 8 / 136 / 144 / 152 / 180.( les milieux des bords et le centre )
a partir desquels je retrouve 16 autres points etc...

donc l'algo que je cherche c'est justement de retrouver tous les points en fonctions des 4 premiers points.

tout en sachant que je peux avoir plus de points donnés des le debut . genre par exemple les 4 premiers plus les 5 que l'on trouve avec , c'est a dire 9 points.

en gros si l'utilisateur rentre les 289 points jai rien a faire . mais si il en met moins je dois retrouver le reste .

Alors evidemment je peux faire une ligne de code pour chaque points mais bon je me disais qu'il devait y avoir une astuce pour en faire une boucle :)

et que fais-tu si en plus de (le 0,16,272,288) je te donne le 3 et le 285 ?

nan mais en fait les points c'est moi qui les demande a l'utilisateur .
en gros je lui demande combien il veut en rentrer , en l'occurence :
4 / 9 / 25 / 81 ou 289 .

et ensuite je choisi judicieusement les points qu'il doit renseigner .

Bonjour,

Une fois le calibrage fait, on a un quadrillage avec 4,9, 25 ou plus de carrés,
avec pour chaque point, la correspondance entre coordonnées théoriques et coordonnées réelles.

On peut donc constituer, par une extrapolation simple sur les "grands" carrés qui ont pour sommets les coordonnées théoriques, un quadrillage "trés" détaillé associant à chaque coordonnée théorique les coordonnées réelles virtuellement calibrées.

Lorsqu'on "clique" sur l'écran, il suffit de rechercher, dans la table de correspondance précédement obtenue par extrapolation, le point dont les coordonnées réelles sont les plus proches des coordonnées réelles du point où on a cliqué. On en déduit la coordonée théorique recherchée.

En fait c'est pas rellement la calibration qui me pose soucis .

En realité il me faut une entrée pour les 289 points mais si l'utilisateur en met que 4 / 9 / 25 ou 81 , je voulais calculer des valeurs moyennes pour les points manquants .

Ensuite quand j'ai mes 289 points ( avec certains calculés ) Alors je fais ma calibration avec ces valeurs et les valeurs reelles de coordonnées des points affichés a l'écran .

Bon en tout cas , rien que le fait d'avoir essayé d'expliquer tout ca c'est devenu plus clair pour moi aussi :mouarf:

Bonjour,

avec les quatres coins, tu peut extrapoler la position des autres.
La différence entre deux points est : (p1+p2)/nbPoints.

oups erreur
(p2-p1)/nbPoints

Comme la conseillé Nemerle , jai numéroté les points en (x,y) et c'est vrai qu'on y voit plus clair .

du coups pour demander les bon points a l'utilisateur j'ai un code dans ce gout la :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// mon tableau de points POINT cpt[17][17];   // nombres de points de calibration // (16 pour 4 , 8 pour 9 , 4 pour 25 , 2 pour 81 , 1 pour les 289 points ) int nc = 16;   int i,j=0;   for(j=0;j<17;j+=nc) { for(i=0;i<17;i+=nc) { result=WaitForUserToTouchScreen(event); switch(result){ case WAIT_OBJECT_0: cpt[i][j].x=event->x; cpt[i][j].y=event->y; break; case WAIT_TIMEOUT: i=j=18; break; } } }

---

donc avec nc=16 , il va y avoir 4 points demandé seulement .
maintenant j'ai besoin d'exactement le contraire pour parcourir tous les points qui ont pas été demandé .
Et surtout trouver un moyen de les calculé en fonction des points qui ont été rentrés .
Alors j'ai pensé a reparcourir le tableau en divisant par 2 a chaque fois "nc" et si la valeur du point est null alors je dois trouver sa valeur avec les points du niveau d'avant mais la j'avoue je seche .

Bonjour,

Voici comment traiter le cas avec nxn points de calibrage réel et mxm points de calibrage virtuel (exemple: 17x17) à déduire du calibrage réel.

Déclarons :

Code:

---

1 2	POINT TheoriqueN[n][n];POINT TheoriqueM[m][m]; POINT ReelN[n][n];POINT ReelM[m][m];

---

Calibrons les nxn points : pour i de 0 à n-1 et j de 0 à n-1

Code:

---

1 2 3 4 5

X=i*largeur /(n-1) ; TheoriqueN[i][j].x=X ; Y=j*hauteur /(n-1); TheoriqueN[i][j].y=Y ; ... ReelN[i][j].x=event->x; Reel[i][j].y=event->y;

---

Initialisons le Calibrage virtuel de mxm points (17x17)
pour i de 0 à m-1 et j de 0 à m-1

Code:

---

1 2	XX=i*largeur /(m-1) ; TheoriqueM[i][j].x=XX ; YY=j*hauteur /(m-1); TheoriqueM[i][j].y=YY ;

---

Calculons la valeur extrapolée en identifiant le carré du quadrillage réel dans lequel est contenu le point théorique, c.a.d minX,maxX,minY,MaxY tels que :

Code:

---

1 2	TheoriqueN[minX][minY].x<XX<TheoriqueN[maxX][minY].x TheoriqueN[minX][maxY].y<YY<TheoriqueN[minX][maxY].y

---

on obtient alors ReelM[i][j] par (double)extrapolation sur les sommets du carré

Code:

---

1 2 3 4 5 6 7 8

if minY=maxY then Yratio:=0 else Yratio:=(Y-minY)/(maxY-minY) ; if minX=maxX then Xratio:=0 else Xratio:=(XX-minX)/(maxX-minX) ; VNx:=ReelN[minY,minX].x*(1-Xratio)+ReelN[minY,maxX].x*Xratio ; VNy:=ReelN[minY,minX].y*(1-Yratio)+ReelN[minY,maxX].y*Yratio ; VSx:=ReelN[maxY,minX].x*(1-Xratio)+ReelN[maxY,maxX].x*Xratio ; VSy:=ReelN[maxY,minX].y*(1-Yratio)+ReelN[maxY,maxX].y*Yratio ; ReelM[i,j].x:=VNx*(1-latratio)+VSx*latratio ; ReelM[i,j].y:=VNy*(1-latratio)+VSy*latratio ;

---

Vn/Vs pour Valeurs au Nord/Sud

Ensuite, lorsqu'on a des event su la dalle, on recherche dans ReelN la case i,j tel que la distance entre ReelN[i,j] et le point cliqué soit la plus petite eton en déduit les coordonnées théoriques via TheoriqueM[i,j].

Merci a tous.