регистрация изображений

Question

Я пытаюсь создать сопоставление для положения плитки / пикселя в одном наборе данных мозаичного изображения с положением плитки / пикселя в другом наборе данных (которые приблизительно покрывают одну и ту же область изображения).Из-за поворотов отображаемой области, оси панорамирования, сдвигов и изменений масштаба в этом отображении есть много неизвестных, которые необходимо учитывать.Эта ситуация проиллюстрирована ниже, где прямоугольники представляют отображаемую область для каждой плитки, а расположение плиток определяется соотношением между осью панорамирования (черные линии) и осью камеры:

Проблема сводится к следующей линейной системе, которая по-разному учитывает поворот оси сканирования относительно оси камеры в двух наборах данных, а также поворот, масштаб и сдвиги между отображаемыми областями.в двух наборах данных.К сожалению, я не уверен, что делать с неизвестными:

|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

Редактировать:

Я только что понял, что могу решить проблему следующим образом (я думаю?):

|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), чтобы преобразоватьотобразил координату обратно в ячейку и положение пикселя в цели .... нет?

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