Trouver un point d'un repère dans un autre repère

[SPH]

Une image de référence :
https://zupimages.net/up/24/04/7s08.bmp

===

Salut,

je cherche les formules mathématiques pour trouver l'emplacement du point noir dans le repère noir correspondant au point rouge dans le repère rouge !
Je suis sur une piste pour la première moitié du calcul mais ça s'arrête là...

Merci pour votre aide !
-----

[gg0]

Bonjour.

D'abord une remarque : On peut insérer directement les images dans les messages. J'ai laissé tomber le schéma proposé vu que l'hébergeur veut placer des cookies.
Ensuite la question semble mal posée, vu que "le repère noir" et "le repère rouge" sont des mots trop imprécis.
On peut trouver sur Internet les formules de changement de repère.

Cordialement.

[Deedee81]

Salut,

Ils ont une drôle de tête ces repères

Première étape : trouver la valeur des coordonnées en fonction de ces "repères" (après ça devient facile, même trivial en fait). Pour le rectangle c'est évident. Pour le quadrilatère irrégulier, on peut procéder par interpolation linéaire. C'est quand même un peu tortueux comme question. Eventuellement si ce que je viens d'expliquer n'est pas juste, donne l'énoncé complet (et gg0 a raison, toujours mettre les images en attachement, si un modo de math passe il risque de sucrer le lien).

[SPH]

En rouge, il s'agit de mon écran d'ordinateur. La résolution est de 1920*1080.
(x,y) est un point de cet écran.

Maintenant, je déforme l'écran rouge en quadrilatère irrégulier (noir) et je dois retrouver le point rouge sur ce quadrilatère.

Je pense qu'utiliser des Sin et des Cos est inutile. Mais même sans ça, je m'arrache les cheveux...

[A voir en vidéo sur Futura]

[XK150]

Salut ,

" je déforme " ??? Je déforme comment , selon quelle loi ????

[Deedee81]

" je déforme " ??? Je déforme comment , selon quelle loi ????

Très bonne question et d'ailleurs y répondre est presque la réponse à la question initiale
(et c'est forcément déformé "d'une certaine manière")

[gg0]

Si le nouveau quadrilatère est un parallélogramme, il y a un changement de coordonnées qui fait passer de O(0,0) à O'(x1,y1), de A(1920,0) à A'(x2,y2), etc. Si ce n'est pas un parallélogramme, il n'y a aucune raison que la déformation soit régulière, et XK150 a posé la question de base.

Si ce problème a une origine concrète, c'est sans doute la question concrète qu'il faut donner.

[Deedee81]

Si ce problème a une origine concrète, c'est sans doute la question concrète qu'il faut donner.

D'autant que je serais quand même surpris que SPH ait déformé l'écran comme il dit (l'image, soit, mais l'écran)

[XK150]

S'il n'y a aucune loi , c'est la loi " au Pif " qui s'applique et vous faites des mesures avec un double décimètre et quelques règles de 3 pour les anciens ,
ou produits croisés pour les nouveaux !
Vous ne pourrez jamais calculer quoi que ce soit .

[SPH]

Les points (x1,y1) (x2,y2) (x3,y3) (x4,y4) se "promènent" sur des cercles au 4 coins de mon écran. Ces points font le tour de leur cercle.
Voilà comment je déforme le quadrilatère.
--
axe1f.f+0.01
axe1x.f=Cos(axe1f.f)*200
axe1y.f=Sin(axe1f.f)*200

axe2f.f+0.081
axe2x.f=Cos(axe2f.f)*200
axe2y.f=Sin(axe2f.f)*200

axe3f.f+0.011
axe3x.f=Cos(axe3f.f)*200
axe3y.f=Sin(axe3f.f)*200

axe4f.f+0.09
axe4x.f=Cos(axe4f.f)*200
axe4y.f=Sin(axe4f.f)*200
--
J'espère que ces explications seront suffisantes.

[gg0]

Tu as expliqué (*) comment tu déformes ton quadrilatère (les 4 segments). Reste à savoir comment se déforment les points intérieurs, c'est à dire quel est le rapport entre l'écran complet et le quadrilatère avec son intérieur.

Toujours pas d'explication concrète ...

(*) enfin ... pas vraiment, tu as donné 4 triplets d'une expression et deux équations, sans signification à priori.

[Deedee81]

C'est quand même drôle comme transformation

Mais bon, ça c'est pas grave.

Bon week-end

[SPH]

Tu as expliqué (*) comment tu déformes ton quadrilatère (les 4 segments). Reste à savoir comment se déforment les points intérieurs, c'est à dire quel est le rapport entre l'écran complet et le quadrilatère avec son intérieur.

L'intérieur se déforme de façon linéaire.
Tiens, regarde un exemple moins complexe.
Voici un écran 1920*1080 avec un point aux coordonnées 100,260. Puis j'ai déformé l'écran. Le point n'est bien sûr plus aux coordonnées 100,260. Comment calculer l'endroit du nouveau point ?

[XK150]

Oui , dit simplement , il y a une infinité de tracés possibles avec les 4 coins se promenant sur leur cercle respectif , donc toujours aucun calcul possible .

[XK150]

Je comprends de moins en moins : expliciter " l'intérieur ( qui est une surface ) se déforme d'une façon linéaire " . On pourrait dire , si c'est vrai , on obtient un rectangle de plus en plus petit . Mais là ????

Comment arrivez vous à ce tracé ?

J'espère que la figure blanche est toujours un plan !!!

[gg0]

Dans une déformation linéaire, les parallèles deviennent des parallèles. Ce n'est pas le cas ici.
J'entrevois une solution possible, qui est de supposer que, dans la déformation, les droites parallèles aux côtés deviennent des droites. Donc la droite x=100 deviendrait la droite joignant les images des points (100, 0) et (1920,0) et la droite y=260 deviendrait la droite joignant les images des points (0,260) et (0,1080); l'image du point serait l'intersection des deux droites. Si SPH veut se lancer dans ce calcul, libre à lui.

[Liet Kynes]

Bonjours à mon avis il s'agit de la même déformation que pour des images 2d auxquelles on donne une vue "3d"

[gg0]

Dans ce cas il y a une règle possible si on connaît la position du rectangle et le point de vue.
Mais l'histoire des cercles semble démentir ton idée.

[jiherve]

bonsoir
j'ai fait çà, il y a longtemps, pour des déformations bien pires, mais elles étaient statiques là ce qui rend la chose indémerdable c'est le coté dynamique.
autrement chercher avec "keystone correction".
JR

[SPH]

Oubliez ces histoires de cercles aux 4 coins. Le calcul d'un seul cas me conviendrait.
Tout ce que je veux se passe sur un plan 2D. Mais l'idée de Liet Kynes de projeter une coordonnée 3D sur un plan 2D est peut etre une bonne piste a explorer.
Je vous remercie, je ferais des calculs de mon coté et je reviendrais ici pour poster mes questions.

MERCIII

[SPH]

Voilà ce que me répond GPT à ma question :

Transformer un point d'un repère en forme de quadrilatère irrégulier à un autre repère, particulièrement à un repère classique (comme un repère cartésien), est un peu plus complexe. Cette transformation implique généralement une opération appelée "transformation affine" ou "homographie", qui est une transformation linéaire suivie d'une translation. Voici les grandes étapes pour effectuer cette opération :

Définir les points de contrôle: Commencez par identifier quatre points dans chacun des repères qui correspondent entre eux. Dans le repère quadrilatère, choisissez quatre coins ou points distinctifs. Trouvez les points correspondants dans l'autre repère.

Établir les équations de la transformation affine: La transformation affine peut être représentée par une matrice 3x3 qui, lorsqu'elle est appliquée à un point (représenté en coordonnées homogènes), donne sa position dans l'autre repère. Les coordonnées homogènes d'un point (x, y) sont (x, y, 1).

Calculer la matrice de transformation: Utilisez les points de contrôle pour calculer les éléments de la matrice de transformation. Cela implique généralement de résoudre un système d'équations linéaires. Le système est basé sur la correspondance des points dans les deux repères.

Appliquer la transformation: Une fois que vous avez la matrice de transformation, vous pouvez l'utiliser pour transformer n'importe quel point du quadrilatère en son équivalent dans l'autre repère. Multipliez la matrice de transformation par le vecteur de coordonnées (en coordonnées homogènes) du point à transformer.

Conversion en coordonnées classiques: Les coordonnées résultantes seront également en coordonnées homogènes. Convertissez-les en coordonnées classiques en divisant les deux premières composantes par la troisième.

C'est un processus mathématiquement intense, souvent réalisé à l'aide de logiciels ou de calculatrices capables de gérer des matrices et des systèmes d'équations linéaires. La précision de la transformation dépendra de la précision de vos points de contrôle et des calculs effectués pour déterminer la matrice de transformation.

Cela vous éclaire t'il un peu plus ?

[pm42]

Cela vous éclaire t'il un peu plus ?

Cela ne nous éclaire pas parce qu'on sait tout ça. Ce qui n'est pas clair, c'est ce que tu veux comme genre de déformation.
Si c'est le plus simple, une interpolation linéaire comme déjà dit est facile à écrire (ou coder) et pas besoin de comprendre comment faire une transformation affine avec une matrice.

[SPH]

Ca y est, j'ai réussi sans cosinus. Je vous posterais ça demain !

[SPH]

Voilà,
J'ai trouvé la solution. J'ai codé ce truc (en espérant qu'on puisse transmettre ici des .EXE) :
http://xmas.free.fr/deformation.exe
ps : clic droit puis "enregistrer sous". Puis renommez si ce n'est pas un .EXE

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SPH(2024) --- Projection de points dans un autre plan ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

If InitSprite() = 0 Or InitKeyboard() = 0 Or InitMouse() = 0
MessageRequester("Error", "Can't open the sprite system", 0)
End
EndIf

ddw=1024
ddh=768

If OpenWindow(0, 0, 0, ddw, ddh, "SPH Déformation", #PB_Window_SystemMenu | #PB_Window_ScreenCentered)

If OpenWindowedScreen(WindowID(0) , 0, 0,ddw,ddh, 0, 0, 0)

MouseLocate(ddw/2, ddh/2)

nb=400
Dim pxv(nb)
Dim pyv(nb)
ici=0
freeze=1

Repeat
Repeat
Event = WindowEvent()
Select Event
Case #PB_Event_CloseWindow
Quit = 1
EndSelect
Until Event = 0

ExamineKeyboard()
ExamineMouse()
MouseX=MouseX()
MouseY=MouseY()
Lmb=MouseButton(#PB_MouseButto n_Left)
Rmb=MouseButton(#PB_MouseButto n_Right)

If Rmb And freeze=0
freeze=1
EndIf
If Rmb=0 And freeze=1
freeze=2
EndIf
If Rmb And freeze=2
freeze=3
EndIf
If Rmb=0 And freeze=3
freeze=0
EndIf

;;;;;;;;;;;;;;;;;
If freeze=1 Or freeze=2
axe1f.f+0.052
axe1x.f=101+Cos(axe1f.f)*101
axe1y.f=101+Sin(axe1f.f)*101
axe2f.f+0.041
axe2x.f=ddw-101+Cos(axe2f.f)*101
axe2y.f=101+Sin(axe2f.f)*101
axe3f.f+0.044
axe3x.f=ddw-101+Cos(axe3f.f)*101
axe3y.f=ddh-101+Sin(axe3f.f)*101
axe4f.f+0.038
axe4x.f=101+Cos(axe4f.f)*101
axe4y.f=ddh-101+Sin(axe4f.f)*101
EndIf
;;;;;;;;;;;;;;;;;

sph_xxx.f=MouseX
sph_yyy.f=MouseY

fx.f=sph_xxx/ddw
fy.f=sph_yyy/ddh

axe12xf.f=(axe2x-axe1x)*fx+axe1x
axe12yf.f=(axe2y-axe1y)*fx+axe1y

axe34xf.f=(axe3x-axe4x)*fx+axe4x
axe34yf.f=(axe3y-axe4y)*fx+axe4y

fx01.f=(axe34xf-axe12xf)*fy+axe12xf
fy01.f=(axe34yf-axe12yf)*fy+axe12yf

;====

; 1--------2
; | |
; 4--------3

axe14xf.f=(axe4x-axe1x)*fy+axe1x
axe14yf.f=(axe4y-axe1y)*fy+axe1y

axe23xf.f=(axe3x-axe2x)*fy+axe2x
axe23yf.f=(axe3y-axe2y)*fy+axe2y

fx02.f=(axe23xf-axe14xf)*fx+axe14xf
fy02.f=(axe23yf-axe14yf)*fx+axe14yf

ClearScreen(RGB(255, 255, 200))
;;;;;;;;;;;;;
StartDrawing(ScreenOutput())

LineXY(axe12xf-5, axe12yf-5, axe12xf+5, axe12yf+5, RGB(0,0,255))
LineXY(axe12xf-5, axe12yf+5, axe12xf+5, axe12yf-5, RGB(0,0,255))
LineXY(axe34xf-5, axe34yf-5, axe34xf+5, axe34yf+5, RGB(0,0,255))
LineXY(axe34xf-5, axe34yf+5, axe34xf+5, axe34yf-5, RGB(0,0,255))

LineXY(axe14xf-5, axe14yf-5, axe14xf+5, axe14yf+5, RGB(0,0,255))
LineXY(axe14xf-5, axe14yf+5, axe14xf+5, axe14yf-5, RGB(0,0,255))
LineXY(axe23xf-5, axe23yf-5, axe23xf+5, axe23yf+5, RGB(0,0,255))
LineXY(axe23xf-5, axe23yf+5, axe23xf+5, axe23yf-5, RGB(0,0,255))

LineXY(axe12xf, axe12yf, axe34xf, axe34yf, RGB(255, 200,180))
LineXY(axe14xf, axe14yf, axe23xf, axe23yf, RGB(255, 200,180))

LineXY(fx01, fy01-8, fx01, fy01+8, RGB(200, 90,90))
LineXY(fx01-8, fy01, fx01+8, fy01, RGB(200, 90,90))

LineXY(MouseX, MouseY,MouseX+16, MouseY+11, RGB(0,0,0))
LineXY(MouseX, MouseY,MouseX+11, MouseY+16, RGB(0,0,0))
LineXY(MouseX+16, MouseY+11,MouseX+11, MouseY+16, RGB(0,0,0))
;;;;
LineXY(axe1x, axe1y, axe2x, axe2y, RGB(255, 0,0))
LineXY(axe1x, axe1y, axe4x, axe4y, RGB(255, 0,0))
LineXY(axe3x, axe3y, axe2x, axe2y, RGB(255, 0,0))
LineXY(axe3x, axe3y, axe4x, axe4y, RGB(255, 0,0))
;;;

For i=0 To nb
Plot(pxv(i),pyv(i),RGB(0,150,0 )) ; points verts
Next
;;;

For i=0 To nb
fx.f=pxv(i)/ddw
fy.f=pyv(i)/ddh
axe12xf.f=(axe2x-axe1x)*fx+axe1x
axe12yf.f=(axe2y-axe1y)*fx+axe1y
axe34xf.f=(axe3x-axe4x)*fx+axe4x
axe34yf.f=(axe3y-axe4y)*fx+axe4y
fx01.f=(axe34xf-axe12xf)*fy+axe12xf
fy01.f=(axe34yf-axe12yf)*fy+axe12yf
Plot(fx01,fy01,RGB(240,0,0)) ; points rouges
Next

;;;;;

StopDrawing()
If Lmb
pxv(ici)=MouseX
pyv(ici)=MouseY
ici+1
ici%nb
EndIf

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;
FlipBuffers()

Until KeyboardPushed(#PB_Key_Escape)
Else
MessageRequester("Error", "Can't open windowed screen!", 0)
EndIf
EndIf