wie Transformation i zwischen einem statischen und einem dynamischen Koordinatensystem

Question

ich habe ein Setup wie folgt aus:

2 Koordinatensysteme. (x, y) ist das Hauptkoordinatensystem und (x ', y') ist ein Koordinatensystem, das innerhalb (x, y) lebt. Das System (x ', y') wird durch die Punkte x1 oder x2 definiert, und wenn ich diese 2 Punkte umherbewege, bewegt sich (x ', y') entsprechend. Der Ursprung von (x ', y') ist definiert als die Mitte des Vektors, der von x1 nach x2 geht, und die y'-Achse ist der normale Vektor auf x1-> x2, der durch den Ursprung geht. Wenn ich einen Punkt x3 in (x ', y') definiert habe und ich entweder x1 oder x2 verschiebe, um den Ursprungsverschiebungsort zu erstellen, wie verschiebe ich dann x3 entsprechend, so dass es seine Position im neuen (x ') behält, y ')? Und wie mache ich eine Transformation, die immer einen Punkt in (x, y) in einen Punkt in (x ', y') umwandelt, wie x1 und x2 gesetzt wurden?

Ich dachte, dass, wenn ich mehr Punkte hatte, als nur die, die ich (x1 oder x2) bewege i i Theta zu schätzen erraten könnte versuchen, tx, ty der Transformation

[x2'] [cos(theta) , sin(theta), tx][x2] 
[y2'] = [-sin(theta), cos(theta), ty][y2] 
[ 1 ]  [ 0  ,  0 , 1 ][1 ] 

und gelten nur diese geschätzte Transformation zu x3 und ich wäre gut ... mmm, aber ich denke, ich würde 3 Punkte brauchen, um Theta, Tx und Ty richtig zu schätzen? Ich meine, ich könnte schätzen, einige der kleinsten Quadrate Ansatz verwenden ... aber 3 Unbekannte erfordert 3 Koordinatensätze richtig?

Ich habe versucht, dies zu implementieren und ein Beispiel zu berechnen. Ich hoffe du verstehst die Syntax. Es ist nicht wirklich mir geben, was ich erwarte:

import math 
import numpy as np 

x1=[ 0,10] 
x2=[10,20] 

rx = x2[0] - x1[0] 
ry = x2[1] - x1[1] 
rlen = math.sqrt(rx*rx+ry*ry) 
c = rx/rlen 
s = ry/rlen 


dx = - (x1[0] + x2[0])/2 # changing the sign to be negative seems to 
dy = - (x1[1] + x2[1])/2 # rectify translation. Rotation still is wrong 

M = np.array([[c, -s, 0],[s, c, 0],[dx, dy, 1]]) 
print(np.dot(x2 + [1],M)) 
# Yields -> [ 15.92031022 -8.63603897 1.  ] and should yield [5,0,1] 

Da ich versuche, die x2-Koordinate zu verwandeln, sollte das Ergebnis dann nicht den Wert 0, da seine in der x-Achse in der y-Komponente hat?

Ok, ich habe versucht, die Implementierung für x3 von Dynamic1 zu Dynamic2, die die Prüfung ist, dass X3 sollte mit der gleichen Koordinate in beiden d1 und d2 enden. Ich habe das gemacht, wie Sie vorgeschlagen haben, aber ich bekomme nicht die gleiche Koordinate in d1 und d2. Habe ich etwas falsch verstanden?

import math 
import numpy as np 

x1=[ 1,1] 
x2=[ 7,9] 

x3=[4,3] 

rx = (x2[0] - x1[0]) 
ry = (x2[1] - x1[1]) 
rlen = math.sqrt(rx*rx + ry*ry) 
c = rx/rlen 
s = ry/rlen 


dx = (x1[0] + x2[0])/2 
dy = (x1[1] + x2[1])/2 

M = np.array([[c, -s, 0],[s, c, 0],[-dx*c-dy*s, dx*s-dy*c, 1]]) 
Minv = np.array([[c, s, 0],[-s, c, 0],[dx, dy, 1]]) 


x1new=[ 1,1] 
x2new=[ 17,4] 

rxnew = (x2new[0] - x1new[0]) 
rynew = (x2new[1] - x1new[1]) 
rlennew = math.sqrt(rxnew*rxnew + rynew*rynew) 
cnew = rxnew/rlennew 
snew = rynew/rlennew 


dxnew = (x1new[0] + x2new[0])/2 
dynew = (x1new[1] + x2new[1])/2 

Mnew = np.array([[cnew, -snew, 0],[snew, cnew, 0],[-dxnew*cnew-dynew*snew, dxnew*snew-dynew*cnew, 1]]) 
Mnewinv = np.array([[cnew, snew, 0],[-snew, cnew, 0],[dxnew, dynew, 1]]) 

M_dyn1_to_dyn2 = np.dot(Minv,Mnew) 

print(np.dot(x3 + [1], M)) 
print(np.dot(x3 + [1], M_dyn1_to_dyn2)) 
#yields these 2 outputs which should be the same: 
[-1.6 -1.2 1. ] 
[-3.53219692 8.29298408 1.  ] 

Answer 1

Bearbeiten. Matrixkorrektur

Um Koordinaten aus dem statischen System in (x1,x2) definiert zu übersetzen, müssen Sie eine affine Transformation anwenden. Matrix dieser Transformation M besteht aus Shift-Matrix S und Rotation über Herkunft R.

M Matrix ist eine Kombination aus S und R:

 c   -s   0 
M = s    c   0 
     -dx*c-dy*s dx*s-dy*c 1 

Hier c und s sind Cosinus- und Sinus des Drehwinkels, sind ihre Werte jeweils x- und y- Komponenten der Einheit (normalisiert) Vektor x1x2.

rx = x2.x - x1.x 
ry = x2.y - x1.y 
len = Sqrt(rx*rx+ry*ry) 
c = rx/Len 
s = ry/Len 

Und verschieben Komponenten:

dx = (x1.x + x2.x)/2 
dy = (x1.y + x2.y)/2 

zu übersetzen (xx, yy) Koordinaten von statischen System ein zu drehen, haben wir

xx' = xx*c+yy*s-dx*c-dy*s = c*(xx-dx) + s*(yy-dy) 
yy' = -xx*s+yy*c+dx*s-dy*c = -s*(xx-dx) + c*(yy-dy) 

Quick-Check zu finden:

X1 = (1,1) 
X2 = (7,9) 
dx = 4 
dy = 5 
rx = 6 
ry = 8 
Len = 10 
c = 0.6 
s = 0.8 

for point (4,5): 
xx-dx = 0 
yy-dy = 0 
xx',yy' = (0, 0) - right 

for point X2 =(7,9): 
xx-dx = 3 
yy-dy = 4 
xx' = 0.6*3 + 0.8*4 = 5 -right 
yy' = -0.8*3 + 0.6*4 = 0 -right 

PS Man beachte, dass Matrix dyn.coordinates statisch diejenigen zu transformieren, ist die inverse M und es ist einfacher:

 c s 0 
M' = -s c 0 
     dx dy 1 

P.P.S. Sie benötigen drei Paare entsprechender Punkte, um allgemeine affine Transformationen zu definieren. Es scheint hier die Sie nicht benötigen und die schiere Skalierung, so dass Sie benötigen bestimmen kann mit x1, x2 Punkten verwandeln

Answer 2

Ich glaube, Sie doppelte Dimension Array benötigt Wert in diesen

die Struktur würde zu speichern und setzen sein wie diese

=============|========|========| 
    index number |x  |y  | 
    =============|========|========| 
    first point | [0][0] | [0][1] |  
    second point | [1][0] | [1][1] |        
    third point | [2][0] | [2][1] |        
    =============|========|========| 

ich Java in meiner Antwort

//declare the double dimension array 
    double matrix[][] = new double[3][2]; 

    //setting location first point, x 
    matrix[0][0] = 1; 
    //setting location first point, y 
    matrix[0][1] = 1; 

    //fill with your formula, i only give example 
    //fill second point with first point and plus 1 
    //setting location second point, x 
    matrix[1][0] = matrix[0][0] + 1; 
    //setting location second point, y 
    matrix[1][1] = matrix[0][1] + 1; 

    //fill with your formula, i only give example 
    //fill third point with second point and plus 1 
    //setting location third point, x 
    matrix[2][0] = matrix[1][0] + 1; 
    //setting location third point, y 
    matrix[2][1] = matrix[1][1] + 1;