modules/module2/Frame and Transformation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "from notebook.services.config import ConfigManager\n",
    "cm = ConfigManager()\n",
    "cm.update('livereveal', {'scroll': True,})\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import os\n",
    "import sys\n",
    "sys.path.append(os.path.abspath(\".\"))\n",
    "\n",
    "from viewer import ThreeJsViewer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Frame and Transformation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"https://gramaziokohler.github.io/compas_fab/latest/_images/02_coordinate_frames.jpg\"  />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Frame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "A frame is defined by a base point and two orthonormal base vectors (xaxis, yaxis), which specify the normal (zaxis). \n",
    "It describes location and orientation in a (right-handed) cartesian coordinate system.\n",
    "\n",
    "<div align=\"middle\"><img src='images/frame.svg' style='height:350px' /></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frame(Point(1.000, 0.000, 0.000), Vector(-0.818, 0.182, 0.545), Vector(0.575, 0.259, 0.776))\n"
     ]
    }
   ],
   "source": [
    "\"\"\"There are several ways to construct a `Frame`.\n",
    "\"\"\"\n",
    "from compas.geometry import Point\n",
    "from compas.geometry import Vector\n",
    "from compas.geometry import Frame\n",
    "from compas.geometry import Plane\n",
    "\n",
    "# Frame autocorrects axes to be orthonormal\n",
    "F = Frame(Point(1, 0, 0), Vector(-0.45, 0.1, 0.3), Vector(1, 0, 0))\n",
    "\n",
    "print(F)\n",
    "\n",
    "F = Frame([1, 0, 0], [-0.45, 0.1, 0.3], [1, 0, 0])\n",
    "\n",
    "F = Frame.from_points([1, 1, 1], [2, 3, 6], [6, 3, 0])\n",
    "F = Frame.from_plane(Plane([0, 0, 0], [0.5, 0.2, 0.1]))\n",
    "F = Frame.from_euler_angles([0.5, 1., 0.2])\n",
    "F = Frame.worldXY()\n",
    "\n",
    "#print(F)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Frame as a cartesian coordinate system"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<img src='images/point_in_frame.svg' style='height:350px' />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point(190.314, 164.389, 200.285)\n",
      "Point(35.000, 35.000, 35.000)\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Example: 'point in frame'\n",
    "\"\"\"\n",
    "point = Point(146.00, 150.00, 161.50)\n",
    "xaxis = Vector(0.9767, 0.0010, -0.214)\n",
    "yaxis = Vector(0.1002, 0.8818, 0.4609)\n",
    "\n",
    "# coordinate system F\n",
    "F = Frame(point, xaxis, yaxis)\n",
    "\n",
    "# point in F (local coordinates)\n",
    "P = Point(35., 35., 35.)\n",
    "\n",
    "# point in global (world) coordinates\n",
    "pw = F.to_world_coords(P)\n",
    "print(pw)\n",
    "# check\n",
    "\n",
    "pl = F.to_local_coords(pw)\n",
    "print(pl)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "The simple example above shows how to use a frame as a coordinate system: Starting from a point `P` in the local (user-defined, relative) coordinate system of frame `F`, i.e. its position is relative to the origin and orientation of `F`, we want to get the position `P_` of `P` in the global (world, absolute) coordinate system."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Frame in frame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<img src='images/frame_in_frame_point.svg' style='height:450px' />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frame(Point(190.314, 164.389, 200.285), Vector(0.760, 0.063, 0.647), Vector(-0.526, 0.645, 0.554))\n",
      "Frame(Point(35.000, 35.000, 35.000), Vector(0.604, 0.430, 0.671), Vector(-0.631, 0.772, 0.074))\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Example: 'frame in frame'\n",
    "# TODO update graphic!\n",
    "\"\"\"\n",
    "from compas.geometry import * \n",
    "\n",
    "# coordinate system F0\n",
    "point = Point(146.00, 150.00, 161.50)\n",
    "xaxis = Vector(0.9767, 0.0010, -0.214)\n",
    "yaxis = Vector(0.1002, 0.8818, 0.4609)\n",
    "F0 = Frame(point, xaxis, yaxis)\n",
    "\n",
    "# frame F in F0 (local coordinates)\n",
    "point = Point(35., 35., 35.)\n",
    "xaxis = Vector(0.604, 0.430, 0.671)\n",
    "yaxis = Vector(-0.631, 0.772, 0.074)\n",
    "F = Frame(point, xaxis, yaxis)\n",
    "\n",
    "# frame in global (world) coordinate system\n",
    "F_wcf = F0.to_world_coords(F)\n",
    "print(F_wcf)\n",
    "\n",
    "# check\n",
    "F2 = F0.to_local_coords(F_wcf)\n",
    "print(F2)\n",
    "print(F == F2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Example\n",
    "\n",
    "Bring a box from the world coordinate system into another coordinate system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Box frame transformed: Frame(Point(2.978, 2.010, 1.790), Vector(-0.680, -0.105, 0.726), Vector(0.733, -0.132, 0.668))\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Example: Bring a box from the world coordinate system into another coordinate system.\n",
    "\"\"\"\n",
    "from compas.geometry import Frame\n",
    "from compas.geometry import Box\n",
    "\n",
    "# Box in the world coordinate system\n",
    "frame = Frame([1, 0, 0], [-0.45, 0.1, 0.3], [1, 0, 0])\n",
    "width, length, height = 1, 1, 1\n",
    "box = Box(frame, width, length, height)\n",
    "\n",
    "# Frame F representing a coordinate system\n",
    "F = Frame([2, 2, 2], [0.978, 0.010, -0.210], [0.090, 0.882, 0.463])\n",
    "\n",
    "# Represent box frame in frame F and construct new box\n",
    "box_frame_transformed = F.to_world_coords(box.frame)\n",
    "box_transformed = Box(box_frame_transformed, width, length, height)\n",
    "print(\"Box frame transformed:\", box_transformed.frame)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "73b9db79a815434190689b512286288c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Renderer(camera=PerspectiveCamera(aspect=1.5, children=(DirectionalLight(intensity=0.5, position=(0.0, 0.0, 1.…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from viewer import ThreeJsViewer\n",
    "viewer = ThreeJsViewer()\n",
    "viewer.draw_frame(Frame.worldXY(), line_width=2)\n",
    "viewer.draw_box(box)\n",
    "viewer.draw_frame(F, line_width=2)\n",
    "viewer.draw_box(box_transformed, color='#3FB59D')\n",
    "camera_position=[5.0, -5.0, 2.0]\n",
    "viewer.show(camera_position)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "### Further information\n",
    "\n",
    "* https://en.wikipedia.org/wiki/Frame_of_reference\n",
    "* https://en.wikipedia.org/wiki/Cartesian_coordinate_system"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Transformation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Transformations refer to operations such as moving, rotating, and scaling objects. They are stored using 4x4 transformation matrices. \n",
    "\n",
    "Most transformations preserve the parallel relationship among the parts of the geometry. For example collinear points \n",
    "remain collinear after the transformation. Also points on one plane stay coplanar after transformation. This type of\n",
    "transformation is called an *affine transformation* and concerns transformations such as `Rotation`, `Translation`, \n",
    "`Scale`, `Reflection`, `Shear` and orthogonal and parallel `Projection`. Only perspective `Projection` is not *affine*.\n",
    "\n",
    "<img src='images/transformations2D.svg' style='width:800px' />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A transformation matrix looks like this:\n",
    "\n",
    "\\begin{equation*}\n",
    "\\mathbf{T} = \\begin{bmatrix}\n",
    "a_{11} & a_{12} & a_{13} & a_{14}\\\\\n",
    "a_{21} & a_{22} & a_{23} & a_{24}\\\\\n",
    "a_{31} & a_{32} & a_{33} & a_{34}\\\\\n",
    "a_{41} & a_{42} & a_{43} & a_{44}\\\\\n",
    "\\end{bmatrix}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "But for different transformations, different coefficients are used:\n",
    "\n",
    "The `Rotation` just uses the upper left 3x3 coefficients,\n",
    "\n",
    "\\begin{equation*}\n",
    "\\mathbf{T} = \\begin{bmatrix}\n",
    "a_{11} & a_{12} & a_{13} & 0\\\\\n",
    "a_{21} & a_{22} & a_{23} & 0\\\\\n",
    "a_{31} & a_{32} & a_{33} & 0\\\\\n",
    "0 & 0 & 0 & 1\\\\\n",
    "\\end{bmatrix}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "the `Translation` just uses the first 3 coefficients of the 4th column,\n",
    "\n",
    "\\begin{equation*}\n",
    "\\mathbf{T} = \\begin{bmatrix}\n",
    "1 & 0 & 0 & a_{14}\\\\\n",
    "0 & 1 & 0 & a_{24}\\\\\n",
    "0 & 0 & 1 & a_{34}\\\\\n",
    "0 & 0 & 0 & 1\\\\\n",
    "\\end{bmatrix}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "and `Scale` uses only the first 3 values of the diagonal.\n",
    "\n",
    "\\begin{equation*}\n",
    "\\mathbf{T} = \\begin{bmatrix}\n",
    "a_{11} & 0 & 0 & 0\\\\\n",
    "0 & a_{22} & 0 & 0\\\\\n",
    "0 & 0 & a_{33} & 0\\\\\n",
    "0 & 0 & 0 & 1\\\\\n",
    "\\end{bmatrix}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rotation:\n",
      " [[    0.9638,   -0.0475,    0.2622,    0.0000],\n",
      " [    0.0815,    0.9894,   -0.1205,    0.0000],\n",
      " [   -0.2537,    0.1375,    0.9575,    0.0000],\n",
      " [    0.0000,    0.0000,    0.0000,    1.0000]]\n",
      "\n",
      "Translation:\n",
      " [[    1.0000,    0.0000,    0.0000,    5.0000],\n",
      " [    0.0000,    1.0000,    0.0000,    3.0000],\n",
      " [    0.0000,    0.0000,    1.0000,    1.0000],\n",
      " [    0.0000,    0.0000,    0.0000,    1.0000]]\n",
      "\n",
      "Scale:\n",
      " [[    0.1000,    0.0000,    0.0000,    0.0000],\n",
      " [    0.0000,    0.3000,    0.0000,    0.0000],\n",
      " [    0.0000,    0.0000,    0.4000,    0.0000],\n",
      " [    0.0000,    0.0000,    0.0000,    1.0000]]\n",
      "\n",
      "Reflection:\n",
      " [[    0.8364,   -0.0545,   -0.5455,    0.6055],\n",
      " [   -0.0545,    0.9818,   -0.1818,    0.2018],\n",
      " [   -0.5455,   -0.1818,   -0.8182,    2.0182],\n",
      " [    0.0000,    0.0000,    0.0000,    1.0000]]\n",
      "\n",
      "Perspective projection:\n",
      " [[    0.8364,   -0.0545,   -0.5455,    0.6055],\n",
      " [   -0.0545,    0.9818,   -0.1818,    0.2018],\n",
      " [   -0.5455,   -0.1818,   -0.8182,    2.0182],\n",
      " [    0.0000,    0.0000,    0.0000,    1.0000]]\n",
      "\n",
      "Shear:\n",
      " [[    0.9920,    0.0225,   -0.0123,   -0.0232],\n",
      " [   -0.0159,    1.0449,   -0.0246,   -0.0463],\n",
      " [   -0.0239,    0.0674,    0.9631,   -0.0695],\n",
      " [    0.0000,    0.0000,    0.0000,    1.0000]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from compas.geometry import *\n",
    "\n",
    "axis, angle = [0.2, 0.4, 0.1], 0.3\n",
    "R = Rotation.from_axis_and_angle(axis, angle)\n",
    "print(\"Rotation:\\n\", R)\n",
    "\n",
    "translation_vector = [5, 3, 1]\n",
    "T = Translation(translation_vector)\n",
    "print(\"Translation:\\n\", T)\n",
    "\n",
    "scale_factors = [0.1, 0.3, 0.4]\n",
    "S = Scale(scale_factors)\n",
    "print(\"Scale:\\n\", S)\n",
    "\n",
    "point, normal = [0.3, 0.2, 1], [0.3, 0.1, 1]\n",
    "R = Reflection(point, normal) # TODO: should take a plane!!\n",
    "print(\"Reflection:\\n\", R)\n",
    "\n",
    "point, normal = [0, 0, 0], [0, 0, 1]\n",
    "perspective = [1, 1, 0]\n",
    "P = Projection.perspective(point, normal, perspective)\n",
    "print(\"Perspective projection:\\n\", R)\n",
    "\n",
    "angle, direction = 0.1, [0.1, 0.2, 0.3]\n",
    "point, normal = [4, 3, 1], [-0.11, 0.31, -0.17]\n",
    "S = Shear(angle, direction, point, normal)\n",
    "print(\"Shear:\\n\", S)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Inverse transformation\n",
    "\n",
    "The inverse transformation $T^{-1}$ is calculated through inverting the transformation matrix $T$. \n",
    "\n",
    "$T \\times T^{-1} = I$, with $I$ as identity matrix. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point(3.701, 3.184, 5.115)\n",
      "Point(3.000, 4.000, 5.000)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[    1.0000,    0.0000,    0.0000,    0.0000],\n",
       " [    0.0000,    1.0000,    0.0000,    0.0000],\n",
       " [    0.0000,    0.0000,    1.0000,    0.0000],\n",
       " [    0.0000,    0.0000,    0.0000,    1.0000]]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Example: Transform a point and invert the transformation\n",
    "\"\"\"\n",
    "from compas.geometry import *\n",
    "from math import pi\n",
    "\n",
    "p = Point(3, 4, 5)\n",
    "T = Rotation.from_axis_and_angle([2, 2, 2], pi/4)\n",
    "\n",
    "# transform Point p with T\n",
    "p.transform(T)\n",
    "print(p)\n",
    "\n",
    "# create inverse Transformation to T\n",
    "Tinv = T.inverse()\n",
    "\n",
    "# transform Point p with inverse Transformation \n",
    "p.transform(Tinv)\n",
    "\n",
    "# check if p has the same values as in the beginning\n",
    "print(p) # == (3, 4, 5)\n",
    "\n",
    "# what is the result of multiplying T with Tinv?\n",
    "T * Tinv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Concatenation\n",
    "\n",
    "The concatenation of several `Transformations` are simple matrix multiplications.\n",
    "But matrices are not commutative ($\\mathbf{A}\\times\\mathbf{B} \\neq \\mathbf{B}\\times\\mathbf{A}$), \n",
    "so it is important to consider the order of multiplication.\n",
    "\n",
    "There are 2 ways to concatenate transformation matrices:\n",
    "\n",
    "<table style=\"font-size:100%\">\n",
    "<tr style=\"background: none;\">\n",
    "<td style=\"text-align: right\">\n",
    "Pre-multiplication:<br/>\n",
    "Post-multiplication:<br/>\n",
    "</td>\n",
    "<td style=\"text-align: left\">\n",
    "$\\mathbf{C}=\\mathbf{B}\\times\\mathbf{A}$<br/>\n",
    "$\\mathbf{C}=\\mathbf{A}\\times\\mathbf{B}$<br/>\n",
    "</td>\n",
    "<td style=\"text-align: left\">\n",
    "(apply $\\mathbf{B}$ to the left of $\\mathbf{A}$)<br/>\n",
    "(apply $\\mathbf{B}$ to the right of $\\mathbf{A}$)<br/>\n",
    "</td>\n",
    "</tr>\n",
    "</table>\n",
    "\n",
    "Which one you choose depends on what you want to do..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Pre-multiplication \n",
    "\n",
    "Think of transformations with respect to the global (world) coordinate system.\n",
    "\n",
    "<div align=\"center\"><img src=\"images/pre-multiplication.svg\" width=\"800\" /></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Pre-multiplication\n",
    "\n",
    "If you transform an object first with transformation $\\mathbf{A}$, then with transformation $\\mathbf{B}$, \n",
    "followed by transformation $\\mathbf{C}$, you get the same result as transforming the object with only \n",
    "one transformation $\\mathbf{M}$ which is calculated by $\\mathbf{M}=\\mathbf{C}\\times\\mathbf{B}\\times\\mathbf{A}$.\n",
    "(Transformations applied from right to left.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point(-0.308, 0.722, -1.483)\n",
      "Point(-0.308, 0.722, -1.483)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Example: Pre-multiply transformations\n",
    "\"\"\"\n",
    "from compas.geometry import *\n",
    "\n",
    "p = Point(1, 1, 1)\n",
    "\n",
    "translation = [1, 2, 3]\n",
    "A = Translation(translation) # create Translation\n",
    "axis, angle = [-0.8, 0.35, 0.5], 2.2\n",
    "B = Rotation.from_axis_and_angle(axis, angle) # create Rotation\n",
    "scale_factors = [0.1, 0.3, 0.4]\n",
    "C = Scale(scale_factors) # create Scale\n",
    "\n",
    "# Transform p1 one by one\n",
    "p1 = p.transformed(A)\n",
    "p1.transform(B)\n",
    "p1.transform(C)\n",
    "\n",
    "# Transform with only one concatenated matrix\n",
    "p2 = p.transformed(C * B * A)\n",
    "\n",
    "print(p1)\n",
    "print(p2)\n",
    "allclose(p1, p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Post-multiplication \n",
    "\n",
    "Think of transformations as transforming the local coordinate frame.\n",
    "\n",
    "<div align=\"center\"><img src=\"images/post-multiplication.svg\" width=\"800\" /></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[    0.4330,   -0.2500,    0.0000,    1.0000],\n",
       " [    0.2500,    0.4330,    0.0000,    0.0000],\n",
       " [    0.0000,    0.0000,    0.5000,    0.0000],\n",
       " [    0.0000,    0.0000,    0.0000,    1.0000]]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Example: pre-multiplication\"\"\"\n",
    "import math\n",
    "R = Rotation.from_axis_and_angle([0, 0, 1], math.radians(30))\n",
    "T = Translation([2, 0, 0])\n",
    "S = Scale([0.5] * 3)\n",
    "C = S * T * R\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[    0.4330,   -0.2500,    0.0000,    1.7321],\n",
       " [    0.2500,    0.4330,    0.0000,    1.0000],\n",
       " [    0.0000,    0.0000,    0.5000,    0.0000],\n",
       " [    0.0000,    0.0000,    0.0000,    1.0000]]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Example: post-multiplication\"\"\"\n",
    "import math\n",
    "R = Rotation.from_axis_and_angle([0, 0, 1], math.radians(30))\n",
    "T = Translation([2, 0, 0])\n",
    "S = Scale([0.5] * 3)\n",
    "C = R * T * S\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Example: Decompose transformations\n",
    "\"\"\"\n",
    "from compas.geometry import *\n",
    "\n",
    "scale_factors = [0.1, 0.3, 0.4]\n",
    "A = Scale(scale_factors) # create Scale\n",
    "axis, angle = [-0.8, 0.35, 0.5], 2.2\n",
    "B = Rotation.from_axis_and_angle(axis, angle) # create Rotation\n",
    "translation = [1, 2, 3]\n",
    "C = Translation(translation) # create Translation\n",
    "\n",
    "# Concatenate transformations\n",
    "M = C * B * A\n",
    "\n",
    "# A matrix can also be decomposed into it's components of Scale, \n",
    "# Shear, Rotation, Translation and Perspective\n",
    "Sc, Sh, R, T, P = M.decomposed()\n",
    "# Check\n",
    "print(A == Sc)\n",
    "print(B == R)\n",
    "print(C == T)\n",
    "print(P * T * R * Sh * Sc == M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Question\n",
    "\n",
    "To transform a point, you simply multiply the point with the transformation matrix. But a transformation matrix is 4x4 \n",
    "and vectors and points are 3x1, so how can they be multiplied?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Matrix multiplication\n",
    "\n",
    "If $\\mathbf{A}$ is an $m \\times n$ matrix and $\\mathbf{B}$ is an $n \\times p$ matrix, the matrix product $\\mathbf{C} = \\mathbf{A}\\mathbf{B}$ is defined to be a $m \\times p$ matrix."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "<table style=\"font-size: 100%;\">\n",
    "<tr style=\"background: none;\">\n",
    "<td style=\"text-align: left;\">\n",
    "\\begin{equation*}\n",
    "{\\overset {4\\times 2{\\text{ matrix}}}{\\begin{bmatrix}a_{11}&a_{12}\\\\a_{21}&a_{22}\\\\a_{31}&a_{32}\\\\a_{41}&a_{42}\\\\\\end{bmatrix}}}\n",
    "{\\overset {2\\times 3{\\text{ matrix}}}{\\begin{bmatrix}b_{11}&b_{12}&b_{13}\\\\b_{21}&b_{22}&b_{23}\\\\\\end{bmatrix}}}=\n",
    "{\\overset {4\\times 3{\\text{ matrix}}}{\\begin{bmatrix}x_{11}&x_{12}&x_{13}\\\\x_{21}&x_{22}&x_{23}\\\\x_{31}&x_{32}&x_{33}\\\\x_{41}&x_{42}&x_{43}\\\\\\end{bmatrix}}} \n",
    "\\end{equation*}\n",
    "<br />\n",
    "<br />\n",
    "$x_{12}=a_{11}b_{12}+a_{12}b_{22}\\\\\n",
    "x_{33}=a_{31}b_{13}+a_{32}b_{23}$\n",
    "</td>\n",
    "<td>\n",
    "<img width=\"300\" src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/e/eb/Matrix_multiplication_diagram_2.svg/470px-Matrix_multiplication_diagram_2.svg.png\" />\n",
    "</td>\n",
    "</tr>\n",
    "</table>\n",
    "\n",
    "https://en.wikipedia.org/wiki/Matrix_multiplication"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Homogenisation\n",
    "\n",
    "To transform points and vectors, i.e. multiply them with the transformation matrix, we need to homogenize them first.\n",
    "This means representing a 3-vector (x, y, z) as a 4-vector (x, y, z, 1) for points, or (x, y, z, 0) for vectors.\n",
    "\n",
    "Points:\n",
    "\\begin{equation*}\n",
    "\\begin{bmatrix}x'\\\\y'\\\\z'\\\\1\\end{bmatrix} = \n",
    "\\begin{bmatrix}\n",
    "a_{11} & a_{12} & a_{13} & a_{14}\\\\\n",
    "a_{21} & a_{22} & a_{23} & a_{24}\\\\\n",
    "a_{31} & a_{32} & a_{33} & a_{34}\\\\\n",
    "a_{41} & a_{42} & a_{43} & a_{44}\\\\\n",
    "\\end{bmatrix}\n",
    "\\times\n",
    "\\begin{bmatrix}x\\\\y\\\\z\\\\1\\end{bmatrix}\n",
    "\\end{equation*}\n",
    "\n",
    "Vectors:\n",
    "\\begin{equation*}\n",
    "\\begin{bmatrix}x'\\\\y'\\\\z'\\\\0\\end{bmatrix} = \n",
    "\\begin{bmatrix}\n",
    "a_{11} & a_{12} & a_{13} & a_{14}\\\\\n",
    "a_{21} & a_{22} & a_{23} & a_{24}\\\\\n",
    "a_{31} & a_{32} & a_{33} & a_{34}\\\\\n",
    "a_{41} & a_{42} & a_{43} & a_{44}\\\\\n",
    "\\end{bmatrix}\n",
    "\\times\n",
    "\\begin{bmatrix}x\\\\y\\\\z\\\\0\\end{bmatrix}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "**NOTE**:\n",
    "<p style=\"background-color: yellow;\">\n",
    "That is one of the reasons for distinguishing between points and vectors!\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point(2.000, 3.000, 4.000)\n",
      "Vector(1.000, 1.000, 1.000)\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Example: transform point and vector\n",
    "\"\"\"\n",
    "# create Transformation\n",
    "R = Rotation.from_axis_and_angle([-0.248, -0.786, -0.566], 2.78, point=[1.0, 0.0, 0.0])\n",
    "\n",
    "# apply Transformation to Point\n",
    "p = Point(1, 1, 1)\n",
    "p.transform(T)\n",
    "\n",
    "# apply Transformation to Vector\n",
    "v = Vector(1, 1, 1)\n",
    "v.transform(T)\n",
    "\n",
    "# print them both\n",
    "print(p)\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Transformation of multiple points\n",
    "\n",
    "If you need to transform multiple points it is better to do this with the methods `transform_points` or `transform_points_numpy`\n",
    "than applying the transformation on each point. (likewise `transform_vectors` or `transform_vectors_numpy`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The mesh has 35947 vertices.\n",
      "transfrom_points takes 0.2590 seconds.\n",
      "transfrom_points_numpy takes 0.0340 seconds.\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import compas\n",
    "from compas.datastructures import Mesh\n",
    "from compas.geometry import transform_points\n",
    "from compas.geometry import transform_points_numpy\n",
    "\n",
    "# load mesh\n",
    "mesh = Mesh.from_ply(compas.get('bunny.ply'))\n",
    "v, f = mesh.to_vertices_and_faces()\n",
    "print(\"The mesh has {} vertices.\".format(len(v)))\n",
    "\n",
    "# create Transformation\n",
    "T = Rotation.from_axis_and_angle([-0.248, -0.786, -0.566], 2.78, point=[1.0, 0.0, 0.0])\n",
    "\n",
    "# transform points with transform_points\n",
    "t0 = time.time()\n",
    "transform_points(v, T)\n",
    "print(\"transfrom_points takes {:.4f} seconds.\".format(time.time() - t0))\n",
    "\n",
    "# transform points with transform_points_numpy\n",
    "t0 = time.time()\n",
    "transform_points_numpy(v, T)\n",
    "print(\"transfrom_points_numpy takes {:.4f} seconds.\".format(time.time() - t0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "**NOTE**:\n",
    "<p style=\"background-color: yellow;\">\n",
    "If you want to apply several transformations on a big mesh, it is faster to multiply transformations first \n",
    "and then apply only one transformation to mesh.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Frame and Transformation\n",
    "\n",
    "<img src='images/frame_transformation.svg' style='height:450px' />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Difference between change-basis transformation and transformation between frames.\n",
    "\n",
    "`Transformation.change_basis(f1, f2)` and `Transformation.from_frame_to_frame(f1, f2)`\n",
    "\n",
    "A change-basis transformation allows to remap geometry of one coordinate system in another, i.e. represent the same coordinates in 2 different frames,\n",
    "whereas the Transformation between 2 frames allows to transform geometry from one coordinate system into the other one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[    0.7933,    0.2220,    0.5668,   -2.1644],\n",
      " [   -0.4588,    0.8301,    0.3169,   -0.3765],\n",
      " [   -0.4002,   -0.5115,    0.7604,    1.3025],\n",
      " [    0.0000,    0.0000,    0.0000,    1.0000]]\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"This example computes a transformation between two frames F1 and F2.\n",
    "\"\"\"\n",
    "from compas.geometry import Frame\n",
    "from compas.geometry import Transformation\n",
    "\n",
    "F1 = Frame([2, 2, 2], [0.12, 0.58, 0.81], [-0.80, 0.53, -0.26])\n",
    "F2 = Frame([1, 1, 1], [0.68, 0.68, 0.27], [-0.67, 0.73, -0.15])\n",
    "\n",
    "T = Transformation.from_frame_to_frame(F1, F2)\n",
    "print(T)\n",
    "\n",
    "# now transform F1 with T\n",
    "F2 == F1.transformed(T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[    0.6931,   -0.2561,   -0.6738,    1.6319],\n",
      " [    0.2201,    0.9653,   -0.1406,   -0.0903],\n",
      " [    0.6864,   -0.0508,    0.7254,    0.5734],\n",
      " [    0.0000,    0.0000,    0.0000,    1.0000]]\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"This example computes a change-basis transformation between two frames F1 and F2.\n",
    "\"\"\"\n",
    "from compas.geometry import Frame\n",
    "from compas.geometry import Transformation\n",
    "\n",
    "F1 = Frame([2, 2, 2], [0.12, 0.58, 0.81], [-0.80, 0.53, -0.26])\n",
    "F2 = Frame([1, 1, 1], [0.68, 0.68, 0.27], [-0.67, 0.73, -0.15])\n",
    "\n",
    "T = Transformation.change_basis(F1, F2)\n",
    "print(T)\n",
    "\n",
    "# F1 local = worldXY F1 in F2\n",
    "Point(0, 0, 0).transformed(T) == F2.to_local_coords(F1.point)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Box frame transformed Frame(Point(2.978, 2.010, 1.790), Vector(-0.680, -0.105, 0.726), Vector(0.733, -0.132, 0.668))\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Example: Bring a box from the world coordinate system into another coordinate system.\n",
    "\"\"\"\n",
    "from compas.geometry import Frame\n",
    "from compas.geometry import Transformation\n",
    "from compas.geometry import Box\n",
    "\n",
    "# Box in the world coordinate system\n",
    "frame = Frame([1, 0, 0], [-0.45, 0.1, 0.3], [1, 0, 0])\n",
    "width, length, height = 1, 1, 1\n",
    "box = Box(frame, width, length, height)\n",
    "\n",
    "# Frame F representing a coordinate system\n",
    "F = Frame([2, 2, 2], [0.978, 0.010, -0.210], [0.090, 0.882, 0.463])\n",
    "\n",
    "# Get transformation between frames and apply transformation on box.\n",
    "T = Transformation.from_frame_to_frame(Frame.worldXY(), F)\n",
    "box_transformed = box.transformed(T)\n",
    "print(\"Box frame transformed\", box_transformed.frame)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5246226cba5e406da7593c22d3d05c25",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Renderer(camera=PerspectiveCamera(aspect=1.5, children=(DirectionalLight(intensity=0.5, position=(0.0, 0.0, 1.…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "viewer = ThreeJsViewer()\n",
    "viewer.draw_frame(Frame.worldXY())\n",
    "viewer.draw_box(box)\n",
    "viewer.draw_frame(F)\n",
    "viewer.draw_box(box_transformed, color=\"#00aaff\")\n",
    "camera_position=[5.0, -5.0, 2.0]\n",
    "viewer.show(camera_position)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Difference between `transform()` and `transformed()`\n",
    "\n",
    "\n",
    "* Make a copy of box and transform it (don't change box):\n",
    "        box_transformed = box.transformed(T)\n",
    "* Transform box (returns `None`):\n",
    "        box.transform(T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "**NOTE**:\n",
    "<p style=\"background-color: yellow;\">\n",
    "Depending on the size of the object, copying takes time. So consider carefully if you really need a copy.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Rotation and orientation\n",
    "\n",
    "A `Rotation` is a circular movement of an object around a point of rotation. A three-dimensional object can always be rotated around an infinite number of imaginary lines called rotation axes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[   -0.5847,   -0.4415,    0.6806,    0.0000],\n",
      " [    0.6544,    0.2391,    0.7173,    0.0000],\n",
      " [   -0.4794,    0.8648,    0.1492,    0.0000],\n",
      " [    0.0000,    0.0000,    0.0000,    1.0000]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"There are several ways to construct a `Rotation`.\n",
    "\"\"\"\n",
    "import math\n",
    "from compas.geometry import Rotation\n",
    "\n",
    "R = Rotation.from_axis_and_angle([1, 0, 0], math.radians(30))\n",
    "R = Rotation.from_axis_and_angle([1, 0, 0], math.radians(30), point=[1, 0, 0])\n",
    "R = Rotation.from_basis_vectors([0.68, 0.68, 0.27], [-0.67, 0.73, -0.15])\n",
    "R = Rotation.from_frame(Frame([1, 1, 1], [0.68, 0.68, 0.27], [-0.67, 0.73, -0.15]))\n",
    "R = Rotation.from_axis_angle_vector([-0.043, -0.254, 0.617])\n",
    "R = Rotation.from_quaternion([0.945, -0.021, -0.125, 0.303])\n",
    "R = Rotation.from_euler_angles([1.4, 0.5, 2.3], static=True, axes='xyz')\n",
    "\n",
    "print(R)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "from compas.geometry import Sphere\n",
    "\n",
    "viewer = ThreeJsViewer()\n",
    "sphere = viewer.draw_sphere(Sphere((0,2,0), 0.5))\n",
    "\n",
    "times = []\n",
    "transformations = []\n",
    "\n",
    "for i in range(0, 360, 1):\n",
    "    transformations.append(Rotation.from_axis_and_angle([0,0,1], math.radians(i)))\n",
    "    times.append(i * 0.01)\n",
    "\n",
    "sphere_action = viewer.create_action(sphere, transformations, times)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5844bc15b59044fcabd48e957c57ebf7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Renderer(camera=PerspectiveCamera(aspect=1.5, children=(DirectionalLight(intensity=0.5, position=(0.0, 0.0, 1.…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5c85992b467a4881b0c796d4d43f940d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "AnimationAction(clip=AnimationClip(tracks=(VectorKeyframeTrack(name='.position', times=array([0.  , 0.01, 0.02…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "camera_position=[0.0, 0.0, 10.0]\n",
    "viewer.show(camera_position=camera_position, action=sphere_action)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Euler angles\n",
    "\n",
    "The Euler angles are three angles introduced by Leonhard Euler to describe the orientation of a rigid body with respect\n",
    "to a fixed coordinate system.\n",
    "\n",
    "The three elemental rotations may be \n",
    "* extrinsic (`static=True`, rotations about the axes xyz of the original coordinate system, which is assumed to remain motionless), or\n",
    "* intrinsic (`static=False`, rotations about the axes of the rotating coordinate system XYZ, solidary with the moving body, which changes its orientation after each elemental rotation)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<img src='https://upload.wikimedia.org/wikipedia/commons/thumb/8/82/Euler.png/543px-Euler.png' style='height:450px' />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Euler angles are typically denoted as α, β, γ. Different authors use different sets of rotation axes to \n",
    "define Euler angles (`axes='xyz'`,`axes='xyx'`, ...) or different names for the same angles.\n",
    "In flight dynamics, the principal rotations described with Euler angles are known as *pitch*, *roll* and *yaw*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from compas.geometry import *\n",
    "\n",
    "box = Box(Frame([0,0,0], [1,0,0], [0,1,0]), 1., 1., 1.)\n",
    " \n",
    "alpha, beta, gamma = 0.3, 0.5, 0.7\n",
    "xaxis, yaxis, zaxis = [1, 0, 0], [0, 1, 0], [0, 0, 1]\n",
    "\n",
    "Rx = Rotation.from_axis_and_angle(xaxis, alpha)\n",
    "Ry = Rotation.from_axis_and_angle(yaxis, beta)\n",
    "Rz = Rotation.from_axis_and_angle(zaxis, gamma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "viewer = ThreeJsViewer()\n",
    "jbox = viewer.draw_box(box)\n",
    "frame = viewer.draw_frame(box.frame)\n",
    "\n",
    "times = [0, 3, 5, 8, 10, 13, 17]\n",
    "transformations = [Transformation()]\n",
    "transformations += [Rx] * 2\n",
    "transformations += [Rx * Ry] * 2\n",
    "transformations += [Rx * Ry * Rz] * 2\n",
    "\n",
    "box_action = viewer.create_action(jbox, transformations, times)\n",
    "frame_action = viewer.create_action(frame, transformations, times)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "30d051d6291248c4ba438219dd608ee0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Renderer(camera=PerspectiveCamera(aspect=1.5, children=(DirectionalLight(intensity=0.5, position=(0.0, 0.0, 1.…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "viewer.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "943860933d364d719562d971614710e9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "AnimationAction(clip=AnimationClip(tracks=(VectorKeyframeTrack(name='.position', times=array([ 0,  3,  5,  8, …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "box_action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "177247731cfd455089358ee69b33f7f8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "AnimationAction(clip=AnimationClip(tracks=(VectorKeyframeTrack(name='.position', times=array([ 0,  3,  5,  8, …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "frame_action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Example: Rotations from euler angles, rotate an object based on 3 euler angles.\n",
    "\"\"\"\n",
    "\n",
    "import compas\n",
    "from compas.geometry import Frame\n",
    "from compas.geometry import Rotation\n",
    "from compas.datastructures import Mesh\n",
    "from compas.datastructures import mesh_transform\n",
    "\n",
    "# euler angles\n",
    "alpha, beta, gamma = -0.156, -0.274, 0.785\n",
    "static, axes = True, 'xyz'\n",
    "\n",
    "# Version 1: Create Rotation from angles\n",
    "R1 = Rotation.from_euler_angles([alpha, beta, gamma], static, axes)\n",
    "\n",
    "# Version 2: Concatenate 3 Rotations\n",
    "xaxis, yaxis, zaxis = [1, 0, 0], [0, 1, 0], [0, 0, 1]\n",
    "Rx = Rotation.from_axis_and_angle(xaxis, alpha)\n",
    "Ry = Rotation.from_axis_and_angle(yaxis, beta)\n",
    "Rz = Rotation.from_axis_and_angle(zaxis, gamma)\n",
    " \n",
    "if static: # check difference between pre- and post-concatenation!\n",
    "    R2 = Rz * Ry * Rx\n",
    "else:\n",
    "    R2 = Rx * Ry * Rz\n",
    "\n",
    "# Check\n",
    "print(R1 == R2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Axis-angle representation\n",
    "\n",
    "The axis–angle representation of a rotation parameterizes a rotation in a three-dimensional Euclidean space by two \n",
    "quantities: a unit vector $\\mathbf{e}$ indicating the direction of an axis of rotation, and an angle $θ$ describing \n",
    "the magnitude of the rotation about the axis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split"
   },
   "source": [
    "<img src='https://upload.wikimedia.org/wikipedia/commons/thumb/7/7b/Angle_axis_vector.svg/300px-Angle_axis_vector.svg.png' style='height:250px' />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vector(-0.064, -0.380, 0.923) 0.6686209688605346\n",
      "Vector(-0.064, -0.380, 0.923) 0.6686209688605343\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Example: Create a rotation from and axis and an angle.\n",
    "\"\"\"\n",
    "from compas.geometry import *\n",
    "aav = Vector(-0.043, -0.254, 0.617)\n",
    "angle, axis = aav.unitized(), aav.length\n",
    "print(angle, axis)\n",
    "R = Rotation.from_axis_angle_vector(aav)\n",
    "axis, angle = R.axis_and_angle\n",
    "print(axis, angle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Unit Quaternion\n",
    "\n",
    "In mathematics, the quaternions are a number system that extends the complex numbers. \n",
    "\n",
    "Quaternions are generally represented in the form:\n",
    "\n",
    "${\\displaystyle a+b\\ \\mathbf{i} +c\\ \\mathbf{j} +d\\ \\mathbf{k} }$\n",
    "\n",
    "where $a$, $b$, $c$, and $d$ are real numbers, and $\\mathbf{i}$, $\\mathbf{j}$, and $\\mathbf{k}$ are the fundamental quaternion units.\n",
    "\n",
    "Unit quaternions, also known as versors, provide a convenient mathematical notation for representing orientations and \n",
    "rotations of objects in three dimensions. Compared to Euler angles they are simpler to compose and compared to \n",
    "rotation matrices they are more compact, more numerically stable, and more efficient. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "from compas.geometry import Rotation\n",
    "from compas.geometry import Quaternion\n",
    "\n",
    "q = Quaternion(0.918958, -0.020197, -0.151477, 0.363544)\n",
    "print(q.is_unit)\n",
    "R = Rotation.from_quaternion(q)\n",
    "print(R.quaternion == q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quaternion(0.916525, -0.019350, -0.155237, 0.368117)\n",
      "[0.08268917200390957, -0.3034379323245168, 0.7764953222906119]\n",
      "[0.7853981633974483, -0.27371608012579823, -0.1561844248311574]\n",
      "Vector(-0.040, -0.319, 0.757)\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Example: Different Robot vendors use different conventions to describe TCP orientation.\"\"\"\n",
    "\n",
    "from compas.geometry import Point\n",
    "from compas.geometry import Vector\n",
    "from compas.geometry import Frame\n",
    "\n",
    "point = Point(0.0, 0.0, 63.0)\n",
    "xaxis = Vector(0.68, 0.68, 0.27)\n",
    "yaxis = Vector(-0.67, 0.73, -0.15)\n",
    "F = Frame(point, xaxis, yaxis)\n",
    "\n",
    "print(F.quaternion) # ABB\n",
    "print(F.euler_angles(static=False, axes='xyz')) # Staubli\n",
    "print(F.euler_angles(static=False, axes='zyx')) # KUKA\n",
    "print(F.axis_angle_vector) # UR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Assignment Task 1\n",
    "\n",
    "Project the box corner coordinates of a (rotated and translated) box onto the xy-plane. You can use either \n",
    "orthogonal, parallel or perspective Projection. In the end visualize the edges of the projected box corners\n",
    "(tip: Mesh will help you there).\n",
    "\n",
    "\n",
    "<div align=\"center\"><br><img src=\"images/assignment1_1.jpg\" width=\"600\" /></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Further information\n",
    "\n",
    "* https://en.wikipedia.org/wiki/Transformation_matrix\n",
    "* https://en.wikipedia.org/wiki/Euler_angles\n",
    "* https://en.wikipedia.org/wiki/Axis%E2%80%93angle_representation\n",
    "* https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  },
  "rise": {
   "theme": "white"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}