I have some control points from a local grid to a known grid (a national grid system). What I am trying to do is come up with the appropriate parameters to define a local prj for the input data. This involves finding the origin (or rotation point), the amount of rotation, and any shifts or scaling in X & Y. So, I have been messing with this code found here : how-to-perform-coordinates-affine-transformation-using-python-part-2 So, what I have got is (almost the same as the referenced post 😞 import sys , os import numpy as np localData = [ [ "AJP1" , 5671.666 , 19466.156 ] , [ "GCP CR" , 9634.659 , 13064.567 ] , \ [ "MHP2" , 10325.093 , 7797.802 ] , [ "MILE 8" , 6508.217 , 7511.953 ] ] refData = [ [ "AJP1" , 157171.409 , 75402.914 ] , [ "GCP CR" , 158414.820 , 67978.050 ] , \ [ "MHP2" , 157059.513 , 62842.546 ] , [ "MILE 8" , 153418.976 , 64023.272 ] ] inArr = np . array ( [ [ l [ 1 ] , l [ 2 ] , 0.0 ] for l in localData ] ) refArr = np . array ( [ [ l [ 1 ] , l [ 2 ] , 0.0 ] for l in refData ] ) n = inArr . shape [ 0 ] pad = lambda x : np . hstack ( [ x , np . ones ( ( x . shape [ 0 ] , 1 ) ) ] ) unpad = lambda x : x [ : , : - 1 ] X = pad ( inArr ) Y = pad ( refArr ) # Solve the least squares problem X * A = Y # to find our transformation matrix A A , res , rank , s = np . linalg . lstsq ( X , Y ) transform = lambda x : unpad ( np . dot ( pad ( x ) , A ) ) print "Target:" print refArr print "Result:" print transform ( inArr ) print "Max error:" , np . abs ( refArr - transform ( inArr ) ) . max ( ) which give me this : >> > Target : [ [ 157171.409 75402.914 0 . ] [ 158414.82 67978.05 0 . ] [ 157059.513 62842.546 0 . ] [ 153418.976 64023.272 0 . ] ] Result : [ [ 157171.39578228 75402.91459879 0 . ] [ 158414.84986487 67978.04864706 0 . ] [ 157059.48564043 62842.54723945 0 . ] [ 153418.98671243 64023.2715147 0 . ] ] Max error : 0.0298648653843 So, I can see the fit is quite good. But how do I use the solution from np.linalg.lstsq to derive the parameters I need for the projection definition of the localData? In particular, the origin point 0,0 in the target coordinates, and the shifts and rotations that are going on here?? Tagging out very own numpy expert and all around math wiz Dan Patterson here. Or is this not even possible with this approach. My matrix math is extremely rusty to non-existent. But I am willing to try any methods offered Thanks in advance. Neil

me too. but the quickest is to loo at the code itself in the matplotlib folder transforms.py to get help etc >>> from matplotlib import transforms as tr >>> dir(tr) ['Affine2D', 'Affine2DBase', 'AffineBase', 'Bbox', 'BboxBase', 'BboxTransform', 'BboxTransformFrom', 'BboxTransformTo', 'BboxTransformToMaxOnly', 'BlendedAffine2D', 'BlendedGenericTransform', 'CompositeAffine2D', 'CompositeGenericTransform', 'DEBUG', 'IdentityTransform', 'MaskedArray', 'Path', 'ScaledTranslation', 'Transform', 'TransformNode', 'TransformWrapper', 'TransformedBbox', 'TransformedPath', 'WeakValueDictionary', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'absolute_import', 'affine_transform', 'blended_transform_factory', 'composite_transform_factory', 'count_bboxes_overlapping_bbox', 'division', 'interval_contains', 'interval_contains_open', 'inv', 'ma', 'nonsingular', 'np', 'offset_copy', 'print_function', 'six', 'unicode_literals', 'update_path_extents', 'warnings'] >>> help(tr.affine_transform) Help on built-in function affine_transform:

Dan, sorry, been a bit busy. Just looked into matplotlib, but where do i find this Affine2D class? Thanks,

An affine transformation is a combination of a translation , scaling and rotation transformations , which can be expressed as : [ 1 0 tx ] [ Sx 0 0 ] [ cos ( a ) - sin ( a ) 0 ] [ a b c ] A = [ 0 1 ty ] . [ 0 Sy 0 ] . [ sin ( a ) cos ( a ) 0 ] = [ d e f ] [ 0 0 1 ] [ 0 0 1 ] [ 0 0 1 ] [ 0 0 1 ] the extra 0 is for use with homogenous coordinates. There are several ways of accomplishing the same thing >> > a array ( [ [ 1.00000000 , 1.00000000 ] , [ 2.00000000 , 2.00000000 ] , [ 3.00000000 , 3.00000000 ] , [ 4.00000000 , 4.00000000 ] , [ 5.00000000 , 5.00000000 ] ] ) >> > b = affine ( a , angle = - 45 ) [ 0 ] >> > c = affine ( a , 45 ) [ 0 ] >> > b array ( [ [ 0.17157288 , 3.00000000 ] , [ 1.58578644 , 3.00000000 ] , [ 3.00000000 , 3.00000000 ] , [ 4.41421356 , 3.00000000 ] , [ 5.82842712 , 3.00000000 ] ] ) >> > c array ( [ [ 3.00000000 , 0.17157288 ] , [ 3.00000000 , 1.58578644 ] , [ 3.00000000 , 3.00000000 ] , [ 3.00000000 , 4.41421356 ] , [ 3.00000000 , 5.82842712 ] ] ) Where the simplied version drops the last row and right-most column as was done in the above example 'a' is the points at a 45 degree angle at a 45 degree (circles). 'b' is rotated -45 (parallel to x) and 'c' parallel to y. All are centered about the point (3,3) which is the center of input points. All points are translated (moved to the origin, then rotated, then translated back to their original center. # array 'a' is pnts in the examples below # rotation is the angle in degrees # #translate.... p_trans = pnts - cent_pnt ( pnts ) a_c = np . average ( a , axis = 0 ) . squeeze ( ) # cent_pnt is basically this # #rotation matrix.... rad = np . deg2rad ( rotation ) c = np . cos ( rad ) s = np . sin ( rad ) rot_mat = np . array ( [ [ c , - s ] , [ s , c ] ] ) # #rotate the translated points, get the dot product, take its translation and move back p_rot = np . dot ( rot_mat , p_trans . T ) . T + to_pnt A rigid 2d Affine essentially. >> > a # input array array ( [ [ 1.00000000 , 1.00000000 ] , [ 2.00000000 , 2.00000000 ] , [ 3.00000000 , 3.00000000 ] , [ 4.00000000 , 4.00000000 ] , [ 5.00000000 , 5.00000000 ] ] ) >> > a . T # translated .... from column to row for x, y values array ( [ [ 1.00000000 , 2.00000000 , 3.00000000 , 4.00000000 , 5.00000000 ] , [ 1.00000000 , 2.00000000 , 3.00000000 , 4.00000000 , 5.00000000 ] ] ) >> > a_c # the center of 'a' array ( [ 3.00000000 , 3.00000000 ] ) >> > a_h # the coordinates translated to the center array ( [ [ - 2.00000000 , - 2.00000000 ] , [ - 1.00000000 , - 1.00000000 ] , [ 0.00000000 , 0.00000000 ] , [ 1.00000000 , 1.00000000 ] , [ 2.00000000 , 2.00000000 ] ] ) >> > a_h . T # translate those to rows so that you can use the dot product array ( [ [ - 2.00000000 , - 1.00000000 , 0.00000000 , 1.00000000 , 2.00000000 ] , [ - 2.00000000 , - 1.00000000 , 0.00000000 , 1.00000000 , 2.00000000 ] ] ) >> > >> > rm # a rotation matrix for a 45 degree rotation array ( [ [ 0.70710678 , 0.70710678 ] , [ - 0.70710678 , 0.70710678 ] ] ) >> > >> > np . dot ( rm , a_h . T ) . T # from the calc. class we all skipped array ( [ [ - 2.82842712 , - 0.00000000 ] , [ - 1.41421356 , - 0.00000000 ] , [ 0.00000000 , 0.00000000 ] , [ 1.41421356 , 0.00000000 ] , [ 2.82842712 , 0.00000000 ] ] ) >> > >> > # as above, but with a translation back to the original center >> > np . dot ( rm , a_h . T ) . T + a_c array ( [ [ 0.17157288 , 3.00000000 ] , [ 1.58578644 , 3.00000000 ] , [ 3.00000000 , 3.00000000 ] , [ 4.41421356 , 3.00000000 ] , [ 5.82842712 , 3.00000000 ] ] ) You noticed that I skipped the fancy homogenous coordinate option since I am only doing a simple affine. If I was going to do not only translation and rotation, but include scaling and shear, then I would have gone the extra step of making the coordinates homogenous to facilitate the array multiplication since the final array in the first example would be used once the coefficients of the affine array were determined. MatPlotLib has a good example in their code in the Affine2D class which you can look at since it is installed with Arc*. Anyway.... this might keep you entertained for a bit. So in short... if you are required to put an 'extra' number in the coordinates chances are they are using homogenous coordinates. If you just want to work with plain old regular coordinates, you simply do it piece-wise as I have shown... I will finish... but I have to get ready for classes

nav[aria-label="Primary Navigation"] { padding: 0; & ul { list-style: none; width: 100%; display: flex; flex-direction: row; justify-content: start; align-items: start; gap: 30px; padding: 0; & li { margin: 0; } & ul li { list-style: none; } } }

numpy linalg.lstsq - coordinate translations

NeilAyres

I have some control points from a local grid to a known grid (a national grid system).

What I am trying to do is come up with the appropriate parameters to define a local prj for the input data.

This involves finding the origin (or rotation point), the amount of rotation, and any shifts or scaling in X & Y.

So, I have been messing with this code found here :

how-to-perform-coordinates-affine-transformation-using-python-part-2

So, what I have got is (almost the same as the referenced post 😞

<SPAN class="keyword token">import</SPAN> sys<SPAN class="punctuation token">,</SPAN> os
<SPAN class="keyword token">import</SPAN> numpy <SPAN class="keyword token">as</SPAN> np
localData <SPAN class="operator token">=</SPAN> <SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="string token">"AJP1"</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">5671.666</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">19466.156</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="punctuation token">[</SPAN><SPAN class="string token">"GCP CR"</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">9634.659</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">13064.567</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> \
 <SPAN class="punctuation token">[</SPAN><SPAN class="string token">"MHP2"</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">10325.093</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">7797.802</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="punctuation token">[</SPAN><SPAN class="string token">"MILE 8"</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">6508.217</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">7511.953</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
refData <SPAN class="operator token">=</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="string token">"AJP1"</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">157171.409</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">75402.914</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="punctuation token">[</SPAN><SPAN class="string token">"GCP CR"</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">158414.820</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">67978.050</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> \
 <SPAN class="punctuation token">[</SPAN><SPAN class="string token">"MHP2"</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">157059.513</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">62842.546</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="punctuation token">[</SPAN><SPAN class="string token">"MILE 8"</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">153418.976</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">64023.272</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>

inArr <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>array<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN>l<SPAN class="punctuation token">[</SPAN><SPAN class="number token">1</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> l<SPAN class="punctuation token">[</SPAN><SPAN class="number token">2</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">0.0</SPAN><SPAN class="punctuation token">]</SPAN> <SPAN class="keyword token">for</SPAN> l <SPAN class="keyword token">in</SPAN> localData<SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">)</SPAN>
refArr <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>array<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN>l<SPAN class="punctuation token">[</SPAN><SPAN class="number token">1</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> l<SPAN class="punctuation token">[</SPAN><SPAN class="number token">2</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">0.0</SPAN><SPAN class="punctuation token">]</SPAN> <SPAN class="keyword token">for</SPAN> l <SPAN class="keyword token">in</SPAN> refData<SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">)</SPAN>
n <SPAN class="operator token">=</SPAN> inArr<SPAN class="punctuation token">.</SPAN>shape<SPAN class="punctuation token">[</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">]</SPAN>
pad <SPAN class="operator token">=</SPAN> <SPAN class="keyword token">lambda</SPAN> x<SPAN class="punctuation token">:</SPAN> np<SPAN class="punctuation token">.</SPAN>hstack<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">[</SPAN>x<SPAN class="punctuation token">,</SPAN> np<SPAN class="punctuation token">.</SPAN>ones<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">(</SPAN>x<SPAN class="punctuation token">.</SPAN>shape<SPAN class="punctuation token">[</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">1</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">)</SPAN>
unpad <SPAN class="operator token">=</SPAN> <SPAN class="keyword token">lambda</SPAN> x<SPAN class="punctuation token">:</SPAN> x<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">:</SPAN><SPAN class="punctuation token">,</SPAN><SPAN class="punctuation token">:</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">1</SPAN><SPAN class="punctuation token">]</SPAN>
X <SPAN class="operator token">=</SPAN> pad<SPAN class="punctuation token">(</SPAN>inArr<SPAN class="punctuation token">)</SPAN>
Y <SPAN class="operator token">=</SPAN> pad<SPAN class="punctuation token">(</SPAN>refArr<SPAN class="punctuation token">)</SPAN>
<SPAN class="comment token"># Solve the least squares problem X * A = Y</SPAN>
<SPAN class="comment token"># to find our transformation matrix A</SPAN>
A<SPAN class="punctuation token">,</SPAN> res<SPAN class="punctuation token">,</SPAN> rank<SPAN class="punctuation token">,</SPAN> s <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>linalg<SPAN class="punctuation token">.</SPAN>lstsq<SPAN class="punctuation token">(</SPAN>X<SPAN class="punctuation token">,</SPAN> Y<SPAN class="punctuation token">)</SPAN>
transform <SPAN class="operator token">=</SPAN> <SPAN class="keyword token">lambda</SPAN> x<SPAN class="punctuation token">:</SPAN> unpad<SPAN class="punctuation token">(</SPAN>np<SPAN class="punctuation token">.</SPAN>dot<SPAN class="punctuation token">(</SPAN>pad<SPAN class="punctuation token">(</SPAN>x<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">,</SPAN> A<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">)</SPAN>
<SPAN class="keyword token">print</SPAN> <SPAN class="string token">"Target:"</SPAN>
<SPAN class="keyword token">print</SPAN> refArr
<SPAN class="keyword token">print</SPAN> <SPAN class="string token">"Result:"</SPAN>
<SPAN class="keyword token">print</SPAN> transform<SPAN class="punctuation token">(</SPAN>inArr<SPAN class="punctuation token">)</SPAN>
<SPAN class="keyword token">print</SPAN> <SPAN class="string token">"Max error:"</SPAN><SPAN class="punctuation token">,</SPAN> np<SPAN class="punctuation token">.</SPAN>abs<SPAN class="punctuation token">(</SPAN>refArr <SPAN class="operator token">-</SPAN> transform<SPAN class="punctuation token">(</SPAN>inArr<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">.</SPAN>max<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="line-numbers-rows"><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN></SPAN>

which give me this :

<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> 
Target<SPAN class="punctuation token">:</SPAN>
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">157171.409</SPAN> <SPAN class="number token">75402.914</SPAN> <SPAN class="number token">0</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">158414.82</SPAN> <SPAN class="number token">67978.05</SPAN> <SPAN class="number token">0</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">157059.513</SPAN> <SPAN class="number token">62842.546</SPAN> <SPAN class="number token">0</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">153418.976</SPAN> <SPAN class="number token">64023.272</SPAN> <SPAN class="number token">0</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
Result<SPAN class="punctuation token">:</SPAN>
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">157171.39578228</SPAN> <SPAN class="number token">75402.91459879</SPAN> <SPAN class="number token">0</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">158414.84986487</SPAN> <SPAN class="number token">67978.04864706</SPAN> <SPAN class="number token">0</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">157059.48564043</SPAN> <SPAN class="number token">62842.54723945</SPAN> <SPAN class="number token">0</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">153418.98671243</SPAN> <SPAN class="number token">64023.2715147</SPAN> <SPAN class="number token">0</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
Max error<SPAN class="punctuation token">:</SPAN> <SPAN class="number token">0.0298648653843</SPAN><SPAN class="line-numbers-rows"><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN></SPAN>

So, I can see the fit is quite good.

But how do I use the solution from np.linalg.lstsq to derive the parameters I need for the projection definition of the localData?

In particular, the origin point 0,0 in the target coordinates, and the shifts and rotations that are going on here??

Tagging out very own numpy expert and all around math wiz Dan Patterson here.

Or is this not even possible with this approach.

My matrix math is extremely rusty to non-existent. But I am willing to try any methods offered

Thanks in advance.

Neil

Finde mehr Beiträge mit dem Tag

Accepted answers

All comments

DanPatterson_Retired

from a cursory look you are trying to solve the matrix, using homogenous coordinates to pick up the rotation terms. I can't deal with it right now, but I will do so at a later time. When WH helped me through some of this some years ago, a translation about the origin was made by subracting the mean X, and Y from the data set. This centers the point cloud about the origin. Solving for the least squares, essentially gives you the correlation coefficient of the points which is related to the axis of rotation of the points from which one gets the angle of rotation. Think of a perfectly straight line of points parallel to the x axis. Translated to the origin would center the points on the x axis with points to the left of the y-axis and some to the right. The deviation in the y direction would be zero, the correlation coefficient would be zero and therefore the axis of rotation would be zero.

I will leave the above paragraph for you to mull over while I attend to business then dig up my complete affine transformation code.

Others may wade in so Neil doesn't have to wait

here some bits

<SPAN class="keyword token">import</SPAN> numpy <SPAN class="keyword token">as</SPAN> np

<SPAN class="keyword token">def</SPAN> <SPAN class="token function">cent_pnt</SPAN><SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">:</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="string token">"""Return the centre of a point array"""</SPAN>
&nbsp;&nbsp;&nbsp; pnts <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>asarray<SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="keyword token">return</SPAN> np<SPAN class="punctuation token">.</SPAN>average<SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">,</SPAN> axis<SPAN class="operator token">=</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">.</SPAN>squeeze<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">)</SPAN>


<SPAN class="keyword token">def</SPAN> <SPAN class="token function">translate</SPAN><SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">,</SPAN> cent<SPAN class="operator token">=</SPAN>None<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">:</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="string token">"""Translate the points about the origin
&nbsp;&nbsp;&nbsp; :Requires:
&nbsp;&nbsp;&nbsp; :--------
&nbsp;&nbsp;&nbsp; :&nbsp; pnts - 2D sequence of point coordinates (N, 2)
&nbsp;&nbsp;&nbsp; :&nbsp; cent - a list, tuple, ndarray of xc, yc
&nbsp;&nbsp;&nbsp; :
&nbsp;&nbsp;&nbsp; :Returns:
&nbsp;&nbsp;&nbsp; :-------
&nbsp;&nbsp;&nbsp; :&nbsp; p_trans - input points translated about the origin
&nbsp;&nbsp;&nbsp; :
&nbsp;&nbsp;&nbsp; :-------
&nbsp;&nbsp;&nbsp; """</SPAN>
&nbsp;&nbsp;&nbsp; pnts <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>asarray<SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="keyword token">if</SPAN> cent <SPAN class="keyword token">is</SPAN> None<SPAN class="punctuation token">:</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; p_trans <SPAN class="operator token">=</SPAN> pnts <SPAN class="operator token">-</SPAN> cent_pnt<SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="keyword token">else</SPAN><SPAN class="punctuation token">:</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; p_trans <SPAN class="operator token">=</SPAN> pnts <SPAN class="operator token">-</SPAN> np<SPAN class="punctuation token">.</SPAN>asarray<SPAN class="punctuation token">(</SPAN>cent<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="keyword token">return</SPAN> p_trans&nbsp;&nbsp;&nbsp; 
<SPAN class="line-numbers-rows"><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN></SPAN>

DanPatterson_Retired

Still busy, but this will delay you some more

Consider the following points:

<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> a <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>array<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="number token">1</SPAN><SPAN class="punctuation token">,</SPAN><SPAN class="number token">1</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="punctuation token">[</SPAN><SPAN class="number token">2</SPAN><SPAN class="punctuation token">,</SPAN><SPAN class="number token">2</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="punctuation token">[</SPAN><SPAN class="number token">3</SPAN><SPAN class="punctuation token">,</SPAN><SPAN class="number token">3</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="punctuation token">[</SPAN><SPAN class="number token">4</SPAN><SPAN class="punctuation token">,</SPAN><SPAN class="number token">4</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> dtype<SPAN class="operator token">=</SPAN><SPAN class="string token">'float64'</SPAN><SPAN class="punctuation token">)</SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> b <SPAN class="operator token">=</SPAN> affine<SPAN class="punctuation token">(</SPAN>a<SPAN class="punctuation token">,</SPAN> angle<SPAN class="operator token">=</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">22.5</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">]</SPAN>&nbsp; <SPAN class="comment token"># rotate to half-way to the x-axis</SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> c <SPAN class="operator token">=</SPAN> b <SPAN class="operator token">+</SPAN> <SPAN class="punctuation token">[</SPAN><SPAN class="number token">10</SPAN><SPAN class="punctuation token">,</SPAN><SPAN class="number token">10</SPAN><SPAN class="punctuation token">]</SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> a
array<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1.00000000</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">1.00000000</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">2.00000000</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">2.00000000</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">3.00000000</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">3.00000000</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">4.00000000</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">4.00000000</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">)</SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> b
array<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">1.95984445</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="operator token">-</SPAN><SPAN class="number token">0.81179415</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">0.65328148</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="operator token">-</SPAN><SPAN class="number token">0.27059805</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">0.65328148</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">0.27059805</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1.95984445</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">0.81179415</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">)</SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> c
array<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">8.04015555</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">9.18820585</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">9.34671852</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">9.72940195</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">10.65328148</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">10.27059805</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">11.95984445</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">10.81179415</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">)</SPAN>‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍<SPAN class="line-numbers-rows"><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN></SPAN>

This function (although only lightly tested) should translate and rotate the points from one form to another.

<SPAN class="keyword token">def</SPAN> <SPAN class="token function">warp</SPAN><SPAN class="punctuation token">(</SPAN>src<SPAN class="operator token">=</SPAN>None<SPAN class="punctuation token">,</SPAN> dest<SPAN class="operator token">=</SPAN>None<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">:</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="string token">""" move the src points based on the dest pnt affine parameters
&nbsp;&nbsp;&nbsp; """</SPAN>
&nbsp;&nbsp;&nbsp; a_slope<SPAN class="punctuation token">,</SPAN> a_inter<SPAN class="punctuation token">,</SPAN> a_cent <SPAN class="operator token">=</SPAN> reg_params<SPAN class="punctuation token">(</SPAN>src<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; b_slope<SPAN class="punctuation token">,</SPAN> b_inter<SPAN class="punctuation token">,</SPAN> b_cent <SPAN class="operator token">=</SPAN> reg_params<SPAN class="punctuation token">(</SPAN>dest<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; d_slope <SPAN class="operator token">=</SPAN> b_slope <SPAN class="operator token">-</SPAN> a_slope
&nbsp;&nbsp;&nbsp; results <SPAN class="operator token">=</SPAN> affine<SPAN class="punctuation token">(</SPAN>src<SPAN class="punctuation token">,</SPAN> d_slope<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; new_pnts <SPAN class="operator token">=</SPAN> results<SPAN class="punctuation token">[</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">]</SPAN> <SPAN class="operator token">+</SPAN> b_cent
&nbsp;&nbsp;&nbsp; <SPAN class="keyword token">return</SPAN> new_pnts<SPAN class="punctuation token">,</SPAN> results‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍<SPAN class="line-numbers-rows"><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN></SPAN>

<SPAN class="keyword token">def</SPAN> <SPAN class="token function">reg_params</SPAN><SPAN class="punctuation token">(</SPAN>src<SPAN class="operator token">=</SPAN>None<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">:</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="string token">""" determine the correlation properties of a point set
&nbsp;&nbsp;&nbsp; """</SPAN>
&nbsp;&nbsp;&nbsp; a_cent <SPAN class="operator token">=</SPAN> cent_pnt<SPAN class="punctuation token">(</SPAN>src<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; a_t <SPAN class="operator token">=</SPAN> translate<SPAN class="punctuation token">(</SPAN>src<SPAN class="punctuation token">,</SPAN> a_cent<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; xt <SPAN class="operator token">=</SPAN> a_t<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">:</SPAN><SPAN class="punctuation token">,</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">]</SPAN>
&nbsp;&nbsp;&nbsp; yt <SPAN class="operator token">=</SPAN> a_t<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">:</SPAN><SPAN class="punctuation token">,</SPAN><SPAN class="number token">1</SPAN><SPAN class="punctuation token">]</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="comment token">#co_var = np.cov(m=src.T, y=None, rowvar=1, bias=0, ddof=None)</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="comment token">#sigmX, sigmY = np.var(a, axis=0, dtype=None, out=None, ddof=0, keepdims=False)</SPAN>
&nbsp;&nbsp;&nbsp; rho <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>corrcoef<SPAN class="punctuation token">(</SPAN>x<SPAN class="operator token">=</SPAN>xt<SPAN class="punctuation token">,</SPAN> y<SPAN class="operator token">=</SPAN>yt<SPAN class="punctuation token">,</SPAN> rowvar<SPAN class="operator token">=</SPAN><SPAN class="number token">1</SPAN><SPAN class="punctuation token">,</SPAN> bias<SPAN class="operator token">=</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">,</SPAN> ddof<SPAN class="operator token">=</SPAN>None<SPAN class="punctuation token">)</SPAN>&nbsp; 
&nbsp;&nbsp;&nbsp; arr <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>vstack<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">[</SPAN>xt<SPAN class="punctuation token">,</SPAN> np<SPAN class="punctuation token">.</SPAN>ones<SPAN class="punctuation token">(</SPAN>len<SPAN class="punctuation token">(</SPAN>xt<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">.</SPAN>T
&nbsp;&nbsp;&nbsp; <SPAN class="comment token">#arr = xt.reshape(len(xt), 1)</SPAN>
&nbsp;&nbsp;&nbsp; slope<SPAN class="punctuation token">,</SPAN> inter <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>linalg<SPAN class="punctuation token">.</SPAN>lstsq<SPAN class="punctuation token">(</SPAN>arr<SPAN class="punctuation token">,</SPAN> yt<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">]</SPAN>
&nbsp;&nbsp;&nbsp; deg_slope <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>degrees<SPAN class="punctuation token">(</SPAN>np<SPAN class="punctuation token">.</SPAN>arctan2<SPAN class="punctuation token">(</SPAN>slope<SPAN class="punctuation token">,</SPAN><SPAN class="number token">1.0</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="keyword token">return</SPAN> deg_slope<SPAN class="punctuation token">,</SPAN> inter<SPAN class="punctuation token">,</SPAN> a_cent <SPAN class="comment token">#, rho‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍</SPAN><SPAN class="line-numbers-rows"><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN></SPAN>

I left in 3 commented lines for examining outputs of the covariance and x, y variance calculations if one wants to examine them. The other line, just shows an alternate method of producing the arr variable.

So if we put this together (with reg_params duplicated), then we have

<SPAN class="keyword token">def</SPAN> <SPAN class="token function">cent_pnt</SPAN><SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">:</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="string token">"""Return the centre of a point array"""</SPAN>
&nbsp;&nbsp;&nbsp; pnts <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>asarray<SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="keyword token">return</SPAN> np<SPAN class="punctuation token">.</SPAN>average<SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">,</SPAN> axis<SPAN class="operator token">=</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">.</SPAN>squeeze<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">)</SPAN>


<SPAN class="keyword token">def</SPAN> <SPAN class="token function">translate</SPAN><SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">,</SPAN> cent<SPAN class="operator token">=</SPAN>None<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">:</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="string token">"""Translate the points about the origin
&nbsp;&nbsp;&nbsp; :Requires:
&nbsp;&nbsp;&nbsp; :--------
&nbsp;&nbsp;&nbsp; :&nbsp; pnts - 2D sequence of point coordinates (N, 2)
&nbsp;&nbsp;&nbsp; :&nbsp; cent - a list, tuple, ndarray of xc, yc
&nbsp;&nbsp;&nbsp; :
&nbsp;&nbsp;&nbsp; :Returns:
&nbsp;&nbsp;&nbsp; :-------
&nbsp;&nbsp;&nbsp; :&nbsp; p_trans - input points translated about the origin
&nbsp;&nbsp;&nbsp; :
&nbsp;&nbsp;&nbsp; :-------
&nbsp;&nbsp;&nbsp; """</SPAN>
&nbsp;&nbsp;&nbsp; pnts <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>asarray<SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="keyword token">if</SPAN> cent <SPAN class="keyword token">is</SPAN> None<SPAN class="punctuation token">:</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; p_trans <SPAN class="operator token">=</SPAN> pnts <SPAN class="operator token">-</SPAN> cent_pnt<SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="keyword token">else</SPAN><SPAN class="punctuation token">:</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; p_trans <SPAN class="operator token">=</SPAN> pnts <SPAN class="operator token">-</SPAN> np<SPAN class="punctuation token">.</SPAN>asarray<SPAN class="punctuation token">(</SPAN>cent<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="keyword token">return</SPAN> p_trans&nbsp;&nbsp;&nbsp; 


<SPAN class="keyword token">def</SPAN> <SPAN class="token function">rot_matrix</SPAN><SPAN class="punctuation token">(</SPAN>rotation<SPAN class="operator token">=</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">:</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="string token">"""Return the rotation matrix given points and rotation angle
&nbsp;&nbsp;&nbsp; :Requires:
&nbsp;&nbsp;&nbsp; :--------
&nbsp;&nbsp;&nbsp; :&nbsp; pnts - 2D sequence of point coordinates (N, 2)
&nbsp;&nbsp;&nbsp; :&nbsp; rotation - angle in degrees
&nbsp;&nbsp;&nbsp; :
&nbsp;&nbsp;&nbsp; :Returns:
&nbsp;&nbsp;&nbsp; :-------
&nbsp;&nbsp;&nbsp; :&nbsp; rot_mat - rotation matrix for 2D transform
&nbsp;&nbsp;&nbsp; :
&nbsp;&nbsp;&nbsp; :Notes:
&nbsp;&nbsp;&nbsp; :-----
&nbsp;&nbsp;&nbsp; :&nbsp; for homogenous coordinates use
&nbsp;&nbsp;&nbsp; :&nbsp;&nbsp;&nbsp; rot_mat = np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]])
&nbsp;&nbsp;&nbsp; :--------
&nbsp;&nbsp;&nbsp; """</SPAN>
&nbsp;&nbsp;&nbsp; rad <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>deg2rad<SPAN class="punctuation token">(</SPAN>rotation<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; c <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>cos<SPAN class="punctuation token">(</SPAN>rad<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; s <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>sin<SPAN class="punctuation token">(</SPAN>rad<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; rot_mat <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>array<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN>c<SPAN class="punctuation token">,</SPAN> <SPAN class="operator token">-</SPAN>s<SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="punctuation token">[</SPAN>s<SPAN class="punctuation token">,</SPAN> c<SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="keyword token">return</SPAN> rot_mat

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 
<SPAN class="keyword token">def</SPAN> <SPAN class="token function">affine</SPAN><SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">,</SPAN> angle<SPAN class="operator token">=</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">,</SPAN> cent<SPAN class="operator token">=</SPAN>None<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">:</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="string token">"""Produce an affine transformation of a point set, given an angle of
&nbsp;&nbsp;&nbsp; :&nbsp; rotation and a point to rotate about.
&nbsp;&nbsp;&nbsp; :Requires:
&nbsp;&nbsp;&nbsp; :--------
&nbsp;&nbsp;&nbsp; :&nbsp; pnts - a series of 2D points a list or ndarray (N,2)
&nbsp;&nbsp;&nbsp; :&nbsp; angle - rotation angle, in degrees, relative to the x-axis.
&nbsp;&nbsp;&nbsp; :&nbsp; cent - center of rotation, either provided or determined from the
&nbsp;&nbsp;&nbsp; :&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; center of the point cloud. [x,y], np.array([x,y])
&nbsp;&nbsp;&nbsp; :
&nbsp;&nbsp;&nbsp; :Returns:
&nbsp;&nbsp;&nbsp; :&nbsp; p_rot - the rotated points.
&nbsp;&nbsp;&nbsp; :
&nbsp;&nbsp;&nbsp; :Notes:
&nbsp;&nbsp;&nbsp; :-----
&nbsp;&nbsp;&nbsp; :&nbsp; The functions that are used are: cent_pnt, translate, rot_matrix.
&nbsp;&nbsp;&nbsp; :&nbsp; Once the points are translated, and the rotation matrix is obtained,
&nbsp;&nbsp;&nbsp; :&nbsp; the points are transposed to facilite broadcasting, the dot product 
&nbsp;&nbsp;&nbsp; :&nbsp; determined and the resultant transposed back to the input shape.
&nbsp;&nbsp;&nbsp; :
&nbsp;&nbsp;&nbsp; """</SPAN>
&nbsp;&nbsp;&nbsp; p <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>asarray<SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; <SPAN class="keyword token">if</SPAN> cent <SPAN class="keyword token">is</SPAN> None<SPAN class="punctuation token">:</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; cent <SPAN class="operator token">=</SPAN> cent_pnt<SPAN class="punctuation token">(</SPAN>pnts<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; p_trans <SPAN class="operator token">=</SPAN> translate<SPAN class="punctuation token">(</SPAN>p<SPAN class="punctuation token">,</SPAN> cent<SPAN class="operator token">=</SPAN>None<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; rot_mat <SPAN class="operator token">=</SPAN> rot_matrix<SPAN class="punctuation token">(</SPAN>rotation<SPAN class="operator token">=</SPAN>angle<SPAN class="punctuation token">)</SPAN>
&nbsp;&nbsp;&nbsp; p_rot <SPAN class="operator token">=</SPAN> np<SPAN class="punctuation token">.</SPAN>dot<SPAN class="punctuation token">(</SPAN>rot_mat<SPAN class="punctuation token">,</SPAN> p_trans<SPAN class="punctuation token">.</SPAN>T<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">.</SPAN>T
&nbsp;&nbsp;&nbsp; <SPAN class="keyword token">return</SPAN> p_rot<SPAN class="punctuation token">,</SPAN> cent<SPAN class="punctuation token">,</SPAN> rot_mat‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍<SPAN class="line-numbers-rows"><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN></SPAN>

Notice I did a slice on the warp in this example, because I didn't need the rest of the returned values from the warp. Looks pretty good when you compare the from-to results with the inputs.

<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> warp<SPAN class="punctuation token">(</SPAN>a<SPAN class="punctuation token">,</SPAN> b<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">]</SPAN>
array<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">1.95984445</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="operator token">-</SPAN><SPAN class="number token">0.81179415</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">0.65328148</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="operator token">-</SPAN><SPAN class="number token">0.27059805</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">0.65328148</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">0.27059805</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1.95984445</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">0.81179415</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">)</SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> warp<SPAN class="punctuation token">(</SPAN>a<SPAN class="punctuation token">,</SPAN> c<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">]</SPAN>
array<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">8.04015555</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">9.18820585</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">9.34671852</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">9.72940195</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">10.65328148</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">10.27059805</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">11.95984445</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">10.81179415</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">)</SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> <SPAN class="comment token"># some more ...</SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> warp<SPAN class="punctuation token">(</SPAN>b<SPAN class="punctuation token">,</SPAN> c<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">]</SPAN>
array<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">8.04015555</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">9.18820585</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">9.34671852</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">9.72940195</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">10.65328148</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">10.27059805</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">11.95984445</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">10.81179415</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">)</SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> warp<SPAN class="punctuation token">(</SPAN>c<SPAN class="punctuation token">,</SPAN> a<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="number token">0</SPAN><SPAN class="punctuation token">]</SPAN>
array<SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1.00000000</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">1.00000000</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">2.00000000</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">2.00000000</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">3.00000000</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">3.00000000</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">,</SPAN>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">4.00000000</SPAN><SPAN class="punctuation token">,</SPAN>&nbsp; <SPAN class="number token">4.00000000</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">)</SPAN>
‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍<SPAN class="line-numbers-rows"><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN></SPAN>

I hope this gets the idea across Neil. This is somewhat simplified and I will still look for the fuller code but the basics entail determining the nature of the parameters of the input points (center, slope etc), then translating, rotating and translating to new center.

NeilAyres

That's fantastic Dan. Plenty to chew over here, but once i have digested this and hopefully understand what's going on, I will attempt to push this through my problem data.

Will get back to you.

I presume the complicated stuff from WH is in your archive somewhere.

But, this has, I hope, wider application with the broader community here. At least anyone who is faced with the problem of trying to define an ArcGIS style local projection from a set of measured points.

DanPatterson_Retired

do note, that the approach that was used by the other script uses the transformation matrices of both point clouds since their correlations are not perfect. The examples that I gave have perfect correlations so the full transformation is not needed. My examples were illustrative of how the process works and not a full 'warp'... until I get a chance to get to my files.

NeilAyres

Thanks Dan.

Looking forward to your digging into your files.

Will have a play with these codes blocks in the next few days.

NeilAyres

Okay Dan,

Been messing with that code you posted.

It seems that it goes a bit pear shaped if the rotation angle is > 45deg.

Just added a few prints etc... (inside def warp to display the angles and b_cent)

Test 1 :

<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> 
Using Rotation <SPAN class="number token">44.5</SPAN><SPAN class="punctuation token">,</SPAN> Shift <SPAN class="punctuation token">[</SPAN><SPAN class="number token">1000</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">2000</SPAN><SPAN class="punctuation token">]</SPAN>
Array A 
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="number token">1</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">2</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="number token">2</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">3</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="number token">3</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">4</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="number token">4</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
Array B 
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">0.01851178</SPAN> <SPAN class="operator token">-</SPAN><SPAN class="number token">2.12123957</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">0.00617059</SPAN> <SPAN class="operator token">-</SPAN><SPAN class="number token">0.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">0.00617059</SPAN> <SPAN class="number token">0.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">0.01851178</SPAN> <SPAN class="number token">2.12123957</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
Array C 
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">999.98148822</SPAN> <SPAN class="number token">1997.87876043</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">999.99382941</SPAN> <SPAN class="number token">1999.29292014</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000.00617059</SPAN> <SPAN class="number token">2000.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000.01851178</SPAN> <SPAN class="number token">2002.12123957</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
inWarp <SPAN class="operator token">-</SPAN> Slope A <SPAN class="number token">45.0</SPAN><SPAN class="punctuation token">,</SPAN> B <SPAN class="number token">89.5</SPAN><SPAN class="punctuation token">,</SPAN> D <SPAN class="number token">44.5</SPAN>
Shifts <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">0</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="number token">0</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
Warp A <SPAN class="operator token">-</SPAN><SPAN class="operator token">></SPAN> B
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">0.01851178</SPAN> <SPAN class="operator token">-</SPAN><SPAN class="number token">2.12123957</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">0.00617059</SPAN> <SPAN class="operator token">-</SPAN><SPAN class="number token">0.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">0.00617059</SPAN> <SPAN class="number token">0.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">0.01851178</SPAN> <SPAN class="number token">2.12123957</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
inWarp <SPAN class="operator token">-</SPAN> Slope A <SPAN class="number token">45.0</SPAN><SPAN class="punctuation token">,</SPAN> B <SPAN class="number token">89.5</SPAN><SPAN class="punctuation token">,</SPAN> D <SPAN class="number token">44.5</SPAN>
Shifts <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="number token">2000</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
Warp A <SPAN class="operator token">-</SPAN><SPAN class="operator token">></SPAN> C
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">999.98148822</SPAN> <SPAN class="number token">1997.87876043</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">999.99382941</SPAN> <SPAN class="number token">1999.29292014</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000.00617059</SPAN> <SPAN class="number token">2000.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000.01851178</SPAN> <SPAN class="number token">2002.12123957</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
inWarp <SPAN class="operator token">-</SPAN> Slope A <SPAN class="number token">89.5</SPAN><SPAN class="punctuation token">,</SPAN> B <SPAN class="number token">89.5</SPAN><SPAN class="punctuation token">,</SPAN> D <SPAN class="number token">1.67688085639e-12</SPAN>
Shifts <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="number token">2000</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
Warp B <SPAN class="operator token">-</SPAN><SPAN class="operator token">></SPAN> C
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">999.98148822</SPAN> <SPAN class="number token">1997.87876043</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">999.99382941</SPAN> <SPAN class="number token">1999.29292014</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000.00617059</SPAN> <SPAN class="number token">2000.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000.01851178</SPAN> <SPAN class="number token">2002.12123957</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
inWarp <SPAN class="operator token">-</SPAN> Slope A <SPAN class="number token">89.5</SPAN><SPAN class="punctuation token">,</SPAN> B <SPAN class="number token">45.0</SPAN><SPAN class="punctuation token">,</SPAN> D <SPAN class="operator token">-</SPAN><SPAN class="number token">44.5</SPAN>
Shifts <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">2.5</SPAN> <SPAN class="number token">2.5</SPAN><SPAN class="punctuation token">]</SPAN>
Warp C <SPAN class="operator token">-</SPAN><SPAN class="operator token">></SPAN> A
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="number token">1</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">2</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="number token">2</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">3</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="number token">3</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">4</SPAN><SPAN class="punctuation token">.</SPAN> <SPAN class="number token">4</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN><SPAN class="line-numbers-rows"><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN></SPAN>

Test 2 :

<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> 
Using Rotation <SPAN class="number token">45.5</SPAN><SPAN class="punctuation token">,</SPAN> Shift <SPAN class="punctuation token">[</SPAN><SPAN class="number token">1000</SPAN><SPAN class="punctuation token">,</SPAN> <SPAN class="number token">2000</SPAN><SPAN class="punctuation token">]</SPAN>
Array A 
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1</SPAN><SPAN class="punctuation token">.</SPAN>&nbsp; <SPAN class="number token">1</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">2</SPAN><SPAN class="punctuation token">.</SPAN>&nbsp; <SPAN class="number token">2</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">3</SPAN><SPAN class="punctuation token">.</SPAN>&nbsp; <SPAN class="number token">3</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">4</SPAN><SPAN class="punctuation token">.</SPAN>&nbsp; <SPAN class="number token">4</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
Array B 
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">0.01851178</SPAN> <SPAN class="operator token">-</SPAN><SPAN class="number token">2.12123957</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">0.00617059</SPAN> <SPAN class="operator token">-</SPAN><SPAN class="number token">0.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">0.00617059</SPAN>&nbsp; <SPAN class="number token">0.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">0.01851178</SPAN>&nbsp; <SPAN class="number token">2.12123957</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
Array C 
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000.01851178</SPAN>&nbsp; <SPAN class="number token">1997.87876043</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000.00617059</SPAN>&nbsp; <SPAN class="number token">1999.29292014</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN>&nbsp; <SPAN class="number token">999.99382941</SPAN>&nbsp; <SPAN class="number token">2000.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN>&nbsp; <SPAN class="number token">999.98148822</SPAN>&nbsp; <SPAN class="number token">2002.12123957</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
inWarp <SPAN class="operator token">-</SPAN> Slope A <SPAN class="number token">45.0</SPAN><SPAN class="punctuation token">,</SPAN> B <SPAN class="operator token">-</SPAN><SPAN class="number token">89.5</SPAN><SPAN class="punctuation token">,</SPAN> D <SPAN class="operator token">-</SPAN><SPAN class="number token">134.5</SPAN>
Shifts <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">0</SPAN><SPAN class="punctuation token">.</SPAN>&nbsp; <SPAN class="number token">0</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
Warp A <SPAN class="operator token">-</SPAN><SPAN class="operator token">></SPAN> B
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">0.01851178</SPAN>&nbsp; <SPAN class="number token">2.12123957</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN><SPAN class="operator token">-</SPAN><SPAN class="number token">0.00617059</SPAN>&nbsp; <SPAN class="number token">0.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">0.00617059</SPAN> <SPAN class="operator token">-</SPAN><SPAN class="number token">0.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">0.01851178</SPAN> <SPAN class="operator token">-</SPAN><SPAN class="number token">2.12123957</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
inWarp <SPAN class="operator token">-</SPAN> Slope A <SPAN class="number token">45.0</SPAN><SPAN class="punctuation token">,</SPAN> B <SPAN class="operator token">-</SPAN><SPAN class="number token">89.5</SPAN><SPAN class="punctuation token">,</SPAN> D <SPAN class="operator token">-</SPAN><SPAN class="number token">134.5</SPAN>
Shifts <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000</SPAN><SPAN class="punctuation token">.</SPAN>&nbsp; <SPAN class="number token">2000</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
Warp A <SPAN class="operator token">-</SPAN><SPAN class="operator token">></SPAN> C
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN>&nbsp; <SPAN class="number token">999.98148822</SPAN>&nbsp; <SPAN class="number token">2002.12123957</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN>&nbsp; <SPAN class="number token">999.99382941</SPAN>&nbsp; <SPAN class="number token">2000.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000.00617059</SPAN>&nbsp; <SPAN class="number token">1999.29292014</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000.01851178</SPAN>&nbsp; <SPAN class="number token">1997.87876043</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
inWarp <SPAN class="operator token">-</SPAN> Slope A <SPAN class="operator token">-</SPAN><SPAN class="number token">89.5</SPAN><SPAN class="punctuation token">,</SPAN> B <SPAN class="operator token">-</SPAN><SPAN class="number token">89.5</SPAN><SPAN class="punctuation token">,</SPAN> D <SPAN class="operator token">-</SPAN><SPAN class="number token">1.67688085639e-12</SPAN>
Shifts <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000</SPAN><SPAN class="punctuation token">.</SPAN>&nbsp; <SPAN class="number token">2000</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
Warp B <SPAN class="operator token">-</SPAN><SPAN class="operator token">></SPAN> C
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000.01851178</SPAN>&nbsp; <SPAN class="number token">1997.87876043</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1000.00617059</SPAN>&nbsp; <SPAN class="number token">1999.29292014</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN>&nbsp; <SPAN class="number token">999.99382941</SPAN>&nbsp; <SPAN class="number token">2000.70707986</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN>&nbsp; <SPAN class="number token">999.98148822</SPAN>&nbsp; <SPAN class="number token">2002.12123957</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
inWarp <SPAN class="operator token">-</SPAN> Slope A <SPAN class="operator token">-</SPAN><SPAN class="number token">89.5</SPAN><SPAN class="punctuation token">,</SPAN> B <SPAN class="number token">45.0</SPAN><SPAN class="punctuation token">,</SPAN> D <SPAN class="number token">134.5</SPAN>
Shifts <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">2.5</SPAN>&nbsp; <SPAN class="number token">2.5</SPAN><SPAN class="punctuation token">]</SPAN>
Warp C <SPAN class="operator token">-</SPAN><SPAN class="operator token">></SPAN> A
<SPAN class="punctuation token">[</SPAN><SPAN class="punctuation token">[</SPAN> <SPAN class="number token">4</SPAN><SPAN class="punctuation token">.</SPAN>&nbsp; <SPAN class="number token">4</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">3</SPAN><SPAN class="punctuation token">.</SPAN>&nbsp; <SPAN class="number token">3</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">2</SPAN><SPAN class="punctuation token">.</SPAN>&nbsp; <SPAN class="number token">2</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN>
 <SPAN class="punctuation token">[</SPAN> <SPAN class="number token">1</SPAN><SPAN class="punctuation token">.</SPAN>&nbsp; <SPAN class="number token">1</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="punctuation token">]</SPAN><SPAN class="punctuation token">]</SPAN>
<SPAN class="operator token">>></SPAN><SPAN class="operator token">></SPAN> <SPAN class="line-numbers-rows"><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN></SPAN>

You see everything gets neatly reversed. And the shifts from C -> A don't look right.

B -> C always works, because that's just a shift and no rotation.

Thanks for your cooperation and work on this so far.

Neil

Nimm an der Diskussion teil

Angemeldete Mitglieder können Beiträge verfassen, Updates folgen und mehr. Neu hier? Registriere ein kostenloses Konto.

Schnellzugriffe

Community Help
Find useful guides, FAQs, and documents to help you navigate and make the most of Esri Community.