md` ## Finding Motors between elements. Apart from the elegant and simple direct constructions above (To find a transformation that keeps a line/screw axis invariant, simply exponentiate it), it is also remarkably easy to find motors that relate elements. ### Motor between points, lines, planes A motor that takes a point,line,plane ${tex`a`} to a point,line,plane ${tex`b`} is:

${tex.block` \begin{aligned} \mathbf m &= \sqrt {b a^{-1}} \end{aligned}`}

Where the elements should be of equal (not necessarily unit) norm. ### Aligning ${tex`k`} points simultaniously When aligning multiple points simultaniously, we can guarantee to always have simple motors, and repeatedly apply ${ref('mot')} and ${ref('sqrt')}. This results in the following algorithm:

${tex` \text{\bf{align}} \\ \quad\text{\bf{p}}_i \leftarrow \text {input points in frame 1} \\ \quad\text{\bf{q}}_i \leftarrow \text {input points in frame 2} \\ \quad\mathbf M \rightarrow \text {output motor between}\, \mathbf p_i\, \text{and}\, \mathbf q_i \\ \text{begin} \\ \quad\text{\bf{M}} \leftarrow 1,\, \text{\bf{P}} \leftarrow \mathbf I, \, \text{\bf{Q}} \leftarrow \mathbf I \\ \quad\text{for each}\, i \\ \quad\quad\text{\bf{P}} \leftarrow \mathbf Q \vee (\mathbf M\mathbf p_i \tilde \mathbf M) \\ \quad\quad\mathbf Q \leftarrow \mathbf Q \vee \mathbf q_i\\ \quad\quad\mathbf M \leftarrow \widehat {1 + {\hat \mathbf Q} {\hat \mathbf P}^{-1}}\, \mathbf M \\ \text{end} `}

Note that we start by initializing ${tex`P,Q`} to the pseudoscalar, which is the identity for the regressive product. This ensures that in the first iteration ${tex`P,Q`} will be equal to the first two points. The transformation between these points is constructed and stored in ${tex`M`}. In the next iteration the following two points are joined (resulting in two lines that both go through the camera position and the old and new target. The transformation between them is constructed and concatenated with ${tex`M`}. The procedure continues effectively aligning the first point, followed by the first line, followed by the first plane, etc .. For those that prefer a javascript version: \`\`\`javascript var align = (p,q)=>{ for (var i=0, M=1, P=!1, Q=!1; i>> p[i]); Q = Q & q[i]; M = (1 + Q.Normalized / P.Normalized).Normalized * M; } return M } \`\`\` This algorithm will align the first two points, then the two lines between the first two points, the plane between the first three points etc. There is no requirement for the input and output sets to be congruent, but if they are the resulting motor will be an **isometry**. #### Aligning one point By passing sets with just one point to the \`align\` function, we can trivially create the translator ${ref('tran')} between them, in any number of dimensions. \`\`\`javascript align([A],[B]); \`\`\` ${html`${ Algebra(3,0,1,()=>{ const point = (x,y)=>!(1e0 + x*1e1 + y*1e2); var A = point(-1,-0.4); var B = point(1,0.4); var align = (p,q)=>{ for (var i=0, M=1, P=!1, Q=!1; i>> p[i]); Q = Q & q[i]; M = (1 + Q.Normalized / P.Normalized).Normalized * M; } return M } var lerp = (m,t)=>((1 - t) + t * m).Normalized; var path = (m, steps, x)=>[...Array(steps)].map((e,i)=>lerp(m,i/(steps-1)) >>> x); var svg = this.graph(()=>{ var t = 0.5 + 0.5 * Math.sin(performance.now()/1000); return [ "Drag the points", 0xFF0000, ...path(align([A],[B]),10,A), 0x224488, A, "A", B, "B", ] },{ grid:1, scale:1.5, fontSize:1.5, pointRadius:2, }); svg.style.width = '600px'; svg.style.height = '400px'; svg.style.background = 'white'; return svg }) }`} #### Aligning two points Aligning two points by aligning the first point, then the first line. When the source and destination points are equally far apart, this is an isometry. Play around with the points below to understand the behavior. \`\`\`javascript align([A0,A1],[B0,B1]); \`\`\` ${html`${ Algebra(3,0,1,()=>{ const point = (x,y)=>!(1e0 + x*1e1 + y*1e2); var A1 = point(-1,-0.4), A2 = point(-1.2,-0.3); var B1 = point(1,0.4), B2 = point(1.15,0.2); var align = (p,q)=>{ for (var i=0, M=1, P=!1, Q=!1; i>> p[i]); Q = Q & q[i]; M = (1 + Q.Normalized / P.Normalized).Normalized * M; } return M } var lerp = (m,t)=>((1 - t) + t * m).Normalized; var path = (m, steps, x)=>[...Array(steps)].map((e,i)=>lerp(m,i/(steps-1)) >>> x); var svg = this.graph(()=>{ var t = 0.5 + 0.5 * Math.sin(performance.now()/1000); return [ "Drag the points", '', 0xFF0000, ...path(align([A1,A2],[B1,B2]),30,[A1,A2]), '', 0xFF0000, ...path(align([A1,A2],[B1,B2]),2,[A1,A2]), 0x224488, A1, "A1", A2, "A2", B1, "B1", B2, "B2" ] },{ grid:1, scale:1.5, fontSize:1.5, pointRadius:2, lineWidth:5, }); svg.style.width = '600px'; svg.style.height = '400px'; svg.style.background = 'white'; return svg }) }`} #### Aligning three points For three points, the same principle applies .. \`\`\`javascript align([A0,A1,A2],[B0,B1,B2]); \`\`\` ${html`${ Algebra(3,0,1,()=>{ const point = (x,y)=>!(1e0 + x*1e1 + y*1e2); var A1 = point(-1,-0.4), A2 = point(-1.2,-0.3), A3 = point(-1.1,0); var [B1,B2,B3] = Math.E ** (1.5e12 + .5e03 + 5.2e13 + .2e02 - 1e01) >>> [A1,A2,A3]; var align = (p,q)=>{ for (var i=0, M=1, P=!1, Q=!1; i>> p[i])).Normalized; Q = (Q & q[i]).Normalized; M = Q*(Q+P).Normalized * M; } return M } var lerp = (m,t)=>((1 - t) + t * m).Normalized; var path = (m, steps, x)=>[...Array(steps)].map((e,i)=>lerp(m,i/(steps-1)) >>> x); var svg = this.graph(()=>{ var t = 0.5 + 0.5 * Math.sin(performance.now()/1000); return [ "Drag the points", '', 0xFF0000, ...path(align([A1,A2,A3],[B1,B2,B3]),30,[[A1,A2],[A2,A3],[A3,A1]]).flat(), '', 0xFF0000, ...path(align([A1,A2,A3],[B1,B2,B3]),2,[[A1,A2],[A2,A3],[A3,A1]]).flat(), 0x224488, A1, "A1", A2, "A2", A3, "A3", B1, "B1", B2, "B2", B3, "B3" ] },{ grid:1, scale:1.5, fontSize:1.5, pointRadius:2, lineWidth:5, }); svg.style.width = '600px'; svg.style.height = '400px'; svg.style.background = 'white'; return svg }) }`} When you play around with this example, notice how 'b1' uniquely determines the final position of 'a1', while 'b2' only determines the orientation of the edge '12' and 'b3' only of the plane '123'. The target positions need not be congruent to the input positions, and in fact it is possible to use infinite points for 'b2' and 'b3'. #### Aligning Euclidean and infinite points. The first point passed to the align function should always be a Euclidean point. Any follow up points however may also be infinite points. \`\`\`javascript align([A0,A1,A2],[B0,!-1e3,!1e2]); \`\`\` ${html`${ Algebra(3,0,1,()=>{ const point = (x,y)=>!(1e0 + x*1e1 + y*1e2); var A1 = point(-1,-0.4), A2 = point(-1.2,-0.3), A3 = point(-1.1,0); var [B1,B2,B3] = [point(1,0.5),!-1e3,!1e2]; var align = (p,q)=>{ for (var i=0, M=1, P=!1, Q=!1; i>> p[i]); Q = Q & q[i]; M = (1 + Q.Normalized / P.Normalized).Normalized * M; } return M } var lerp = (m,t)=>((1 - t) + t * m).Normalized; var path = (m, steps, x)=>[...Array(steps)].map((e,i)=>lerp(m,i/(steps-1)) >>> x); var svg = this.graph(()=>{ var t = 0.5 + 0.5 * Math.sin(performance.now()/1000); return [ "Drag the points", '', 0xFF0000, ...path(align([A1,A2,A3],[B1,B2,B3]),30,[[A1,A2],[A2,A3],[A3,A1]]).flat(), '', 0xFF0000, ...path(align([A1,A2,A3],[B1,B2,B3]),2,[[A1,A2],[A2,A3],[A3,A1]]).flat(), 0x224488, A1, "A1", A2, "A2", A3, "A3", B1, "B1", ] },{ grid:1, scale:1.5, fontSize:1.5, pointRadius:2, lineWidth:5, }); svg.style.width = '600px'; svg.style.height = '400px'; svg.style.background = 'white'; return svg }) }`} In the example above, we have 'b2' pointing down the 'z' axis, while 'b3' is pointing up the y axis. As a result the orientation of the destination is entirely fixed, and 'b1' simply controls the position. `