Registration of graphic fragments

Question

I am trying to create a mapping for tile / pixel positions in one dataset with a tiled image for a tile / pixel position in another dataset (which roughly covers the same area of ​​the image). Due to rotations of the displayed area, pan axis, shifts, and zooming, there are many unknowns in this comparison. This situation is illustrated below, where the rectangles represent the displayed area for each tile, and the location of the tiles is determined by the ratio between the pan axis (black lines) and the camera axis:

, , - , , . , , :

|tx ty|X|a b|+|px py|X|e f|+|i j|=|tx* ty*|X|k l|+|px* py*|  
        |c d|         |g h|                 |m n|

(a, b, c, d, e, f, g, h, i, j, k, l, m, n) 1 (tx, ty, px, py) 2 (tx *, ty *, px *, py *). 14 ( ) , , - , 1 2, . , , 1 2 !

! -Craig

Edit:

, ( ?):

|tx ty px py 1|X|a b|=|tx* ty* px* py* 1|X|k l|  
                |c d|                     |m n|
                |e f|                     |1 0|
                |g h|                     |0 1|
                |i j|                     |1 1|

, , , , , , ( , , ( k, l, m, n), ... no?

Edit2: Edit3: , !

Answer 1

, , .

|tx ty px py 1|X|a b|=|tx* ty* px* py* 1|X|k l|  
                |c d|                     |m n|
                |e f|                     |1 0|
                |g h|                     |0 1|
                |i j|                     |1 1|

:

|tx ty px py| X A X B + T = |tx* ty* px* py*| X C

A C | x y | , "B + T" - | x y | → | x * y * |

:

|tx ty px py 1 tx* ty*| X |A*| = |px* py*|
                          |B |
                          |T |
                          |C*|

,

|B| == |e f|
|T|    |g h|
       |i j|

A* X inv(B) = |a b|
              |c d|

-C* = |k l|
      |m n|

:

1 tp1 = [[tilex, tiley, pixelx, pixely],      ...,]

2 tp2 =

def findABC(tp1,tp2):
   dp1 = np.hstack([tp1,np.ones([len(tp1),1]),tp2[:,0:2]])
   dp2 = tp2[:,2:4]
   E,_,rank,_ = np.linalg.lstsq(dp1,dp2)
   if rank == 7:
      B = E[2:5]
      A = np.dot(E[0:2,0:2],np.linalg.inv(E[2:4,0:2]))
      C = -E[5:7]
      return A,B,C

 def SlideToGlobal(X,tp):
     return np.dot(tp,X)

 def GlobalToSlide(X,p):
    tptp = np.dot(p,n.linalg.inv(X[0:2,0:2]))
    tpoints = np.floor(tptp)
    ppoints = tptp-np.dot(tpoints,X[0:2,0:2])
    tp = np.hstack([tpoints,ppoints])
    return tp