iiw2021_CXII_fabry_cagtay_01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "# 2021 IIW Annual Assembly C-XII\n",
    "This notebook is an extended interactive version of the `weldx` features and example dataset presented at the **2021 IIW Annual Assembly C-XII** meeting.\n",
    "\n",
    "The code of this notebook can be found here: https://github.com/BAMWelDX/IIW2021_AA_CXII\n",
    "\n",
    "You can launch this notebook as an interactive binder session in your browser following this link: \\\n",
    "https://mybinder.org/v2/gh/BAMWelDX/IIW2021_AA_CXII/main?urlpath=lab/tree/iiw2021_CXII_fabry_cagtay_01.ipynb\n",
    "\n",
    "The `weldx` documentation and code is available online:\\\n",
    "https://weldx.readthedocs.io/en/latest/ \\\n",
    "https://github.com/BAMWelDX/weldx\n",
    "\n",
    "The `weldx` documentation and GitHub links for this specific code version `v0.5.0` can be found here:\\\n",
    "https://weldx.readthedocs.io/en/v0.5.0/index.html \\\n",
    "https://github.com/BAMWelDX/weldx/tree/v0.5.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Process Video\n",
    "To give an ovierview of this welding example, here is a video recording of the welding experiment conducted at BAM.\n",
    "\n",
    "We can see the pre- and post-welding scan of the workpiece geometry as well as the position of the temperature measurements.\n",
    "\n",
    "<video controls src=\"./data/WID417.avi\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Imports\n",
    "We start with some general python package imports used throughout this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import pprint\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "import weldx\n",
    "from weldx import Q_, WeldxFile\n",
    "from weldx.asdf.util import get_schema_path, view_tree\n",
    "\n",
    "pp = pprint.PrettyPrinter(indent=2)\n",
    "pprint = pp.pprint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Some helper functions for this notebook are included in the `helpers.py` file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default plotting styles\n",
    "plt.rcParams.update({\"axes.grid\": True, \"figure.figsize\": (10, 6)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from helpers import (\n",
    "    add_axis_labels_3d,\n",
    "    ax_setup,\n",
    "    build_base_csm,\n",
    "    create_geometry,\n",
    "    cs_colors,\n",
    "    plot_gmaw,\n",
    "    plot_measurements,\n",
    "    plot_signal,\n",
    "    welding_wire_geo_data,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## 1. Opening the file\n",
    "We define the `weldx` filename that contains the data used for this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "filename = \"./single_pass_weld.weldx\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "To get an overview of the file contents we can use the `view_tree` function of the `weldx` library to create an interactive tree view.\n",
    "\n",
    "Try searching for a specific term like `wire_feedrate` using the ***Filter...*** box in the upper right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "view_tree(filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To open and access the example dataset we will use the `WeldxFile` class.\n",
    "\n",
    "```python\n",
    "wx_file = WeldxFile(filename, \"r\", sync=False)\n",
    "```\n",
    "\n",
    "You can find more infos about handling `weldx` files in the tutorial: https://weldx.readthedocs.io/en/latest/tutorials/weldxfile.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "The file is expected to validate against the schema `single_pass_weld-0.1.0.yaml`.\\\n",
    "The schema ensures that all elements of the `weldx` file pass the requirements defined in the schema, including:\n",
    "\n",
    "- all requirement entries are present in the file:\n",
    "  - `workpiece`\n",
    "  - `TCP`\n",
    "  - `welding_current`\n",
    "  - `welding_voltage`\n",
    "  - `measurement chains`\n",
    "  - `equipment`\n",
    "- all entries and objects stored in the file have the correct type\n",
    "- all additional restrictions defined in `single_pass_weld-0.1.0.yaml` are met\n",
    "\n",
    "The details describing the schema requirements can be found here: https://weldx.readthedocs.io/en/v0.5.0/generated/datamodels/single_pass_weld-0.1.0.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "file_schema = get_schema_path(\"single_pass_weld-0.1.0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We open the `weldx` file and run a validation agains the `single_pass_weld-0.1.0.yaml` schema."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with WeldxFile(\n",
    "    filename,\n",
    "    \"r\",\n",
    "    custom_schema=file_schema,\n",
    "    sync=False,\n",
    "    asdffile_kwargs={\"copy_arrays\": True},\n",
    ") as file:\n",
    "    wx_file = file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now access and explore the contents of the file interactively in our notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## 2. General metadata\n",
    "First let's look at some general simple metadata stored in the WelDX-file.\n",
    "\n",
    "The (optional) `reference_timestamp` field is used to indicate the start time of the experiment (the moment of arc ignition). All time data that is not given as absolute time are interpreted as relative to the given reference time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wx_file.get(\"reference_timestamp\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "We can deduce the total runtime of the experiment from the TCP movement of the welding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wx_file[\"TCP\"].time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **WelDX** standard introduces the `wx_user` field to store user specific content."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wx_file.get(\"wx_user\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define a time index from start to end of the experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = wx_file[\"TCP\"].time.as_timedelta_index()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3. Workpiece definition\n",
    "The file schema mandates that the user provides workpiece information with the following properties:\n",
    "- `base_metal` referenced by a common name and the associated standard\n",
    "- the `geometry` consisting of a groove description following ISO 9692-1 and the seam length"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Here is how this information is stored the `workpiece` entry of the example dataset `weldx` file:\n",
    "```yaml\n",
    "workpiece:\n",
    "  base_metal: {common_name: S355J2+N, standard: 'DIN EN 10225-2:2011'}\n",
    "  geometry:\n",
    "    groove_shape: !weldx!groove/iso_9692_1_2013_12/VGroove-0.1.0\n",
    "      t: !weldx!units/quantity-0.1.0 {value: 8, units: !weldx!units/units-0.1.0 millimeter}\n",
    "      alpha: !weldx!units/quantity-0.1.0 {value: 45, units: !weldx!units/units-0.1.0 degree}\n",
    "      b: !weldx!units/quantity-0.1.0 {value: 1, units: !weldx!units/units-0.1.0 millimeter}\n",
    "      c: !weldx!units/quantity-0.1.0 {value: 1, units: !weldx!units/units-0.1.0 millimeter}\n",
    "      code_number: ['1.3', '1.5']\n",
    "    seam_length: !weldx!units/quantity-0.1.0 {value: 350, units: !weldx!units/units-0.1.0 millimeter}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### workpiece material\n",
    "\n",
    "Since we know exactly where to find the information in the file, we can access the metadata directly for all files that validate against the file schema."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wx_file[\"workpiece\"][\"base_metal\"][\"common_name\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wx_file[\"workpiece\"][\"base_metal\"][\"standard\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### seam length\n",
    "\n",
    "The total seam length of the workpiece is also stored.\\\n",
    "As throughout most of the functionality of the `weldx` API, physical units must be used where appropriate to avoid ambiguity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seam_length = wx_file[\"workpiece\"][\"geometry\"][\"seam_length\"]\n",
    "print(seam_length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### welding groove\n",
    "\n",
    "The groove shape will be loaded into a specific `weldx` type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "groove = wx_file[\"workpiece\"][\"geometry\"][\"groove_shape\"]\n",
    "str(groove)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "The `weldx` API includes convinient functions to create and visualize different welding groove shapes.\\\n",
    "Many examples and details are available in this tutorial: https://weldx.readthedocs.io/en/v0.5.0/tutorials/groove_types_01.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To get a picture of the groove shape we can simply call the `plot` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "groove.plot()\n",
    "fig = plt.gcf()\n",
    "fig.set_size_inches(7, 7);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 3D Geometry\n",
    "With all the metadata of the workpiece available, it is easy to visualize a simple 3D model of the specimen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "geometry = create_geometry(groove, seam_length, Q_(10, \"mm\"))\n",
    "geometry.plot(profile_raster_width=Q_(4, \"mm\"), trace_raster_width=Q_(60, \"mm\"))\n",
    "ax_setup(plt.gca())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## 4. Welding TCP movement description\n",
    "\n",
    "The path of the welding wire along the weld seam is given by the `TCP` property.\n",
    "\n",
    "The weld path is a linear movement between two points at a constant weld speed. The TCP reference frame is the workpiece base coordinate system, starting at the beginning of the weld seam. The x-axis coordinates will indicate the start- and end-point of the welding process along the workpiece length. The y- and z-coordinates determine the position of the TCP in relation to the cross-sectional groove plane.\n",
    "\n",
    "The information is stored in a [LocalCoordinateSystem](https://weldx.readthedocs.io/en/v0.5.0/_autosummary/weldx.transformations.LocalCoordinateSystem.html#weldx.transformations.LocalCoordinateSystem) instance with two points and the start and end time relative to the `reference_timestamp`.\n",
    "\n",
    "The YAML section of the `weldx` file describing the TCP movement looks like this:\n",
    "\n",
    "```yaml\n",
    "TCP: !weldx!core/transformations/local_coordinate_system-0.1.0\n",
    "  reference_time: !weldx!time/timestamp-0.1.0 2021-03-17T11:06:42.334400\n",
    "  time: !weldx!time/timedeltaindex-0.1.0\n",
    "    values: !core/ndarray-1.0.0\n",
    "      data: [0, 41333333333]\n",
    "      datatype: int64\n",
    "      shape: [2]\n",
    "    start: !weldx!time/timedelta-0.1.0 P0DT0H0M0S\n",
    "    end: !weldx!time/timedelta-0.1.0 P0DT0H0M41.333333333S\n",
    "    min: !weldx!time/timedelta-0.1.0 P0DT0H0M0S\n",
    "    max: !weldx!time/timedelta-0.1.0 P0DT0H0M41.333333333S\n",
    "  coordinates: !weldx!core/variable-0.1.0\n",
    "    name: coordinates\n",
    "    dimensions: [time, c]\n",
    "    dtype: <f8\n",
    "    data: !core/ndarray-1.0.0\n",
    "      data:\n",
    "      - [20.0, 0.0, 3.0]\n",
    "      - [330.0, 0.0, 3.0]\n",
    "      datatype: float64\n",
    "      shape: [2, 3]\n",
    "```\n",
    "\n",
    "The `data` section of the coordiantes describe the start end end point in 3D space: `[20.0, 0.0, 3.0]` to `[330.0, 0.0, 3.0]` .\n",
    "Therefor the welded part of the workpiece will extend from 20 mm to 330 mm of the joint. The offset in z-direction is 3 mm from the workpiece bottom."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can create a `CoordinateSystemManager` instance and add the movement of the welding TCP to the geometry plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "csm_base = build_base_csm(wx_file, plot=False)\n",
    "csm_base.plot(\n",
    "    reference_system=\"workpiece\",\n",
    "    coordinate_systems=[\"TCP weld\"],\n",
    "    data_sets=[\"workpiece (simple)\"],\n",
    "    colors=cs_colors,\n",
    "    show_wireframe=True,\n",
    "    show_data_labels=False,\n",
    "    show_vectors=False,\n",
    ")\n",
    "ax_setup(plt.gca())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 5. Process description\n",
    "The arc welding process must be defined using the following properties:\n",
    "```yaml\n",
    "process:\n",
    "  type: object\n",
    "  properties:\n",
    "    welding_process:\n",
    "      $ref: \"asdf://weldx.bam.de/weldx/schemas/process/GMAW-0.1.0\"\n",
    "    shielding_gas:\n",
    "      tag: \"asdf://weldx.bam.de/weldx/tags/aws/process/shielding_gas_for_procedure-0.1.*\"\n",
    "    weld_speed:\n",
    "      ...\n",
    "    welding_wire:\n",
    "      ...\n",
    "  required: [welding_process, shielding_gas, weld_speed, welding_wire]\n",
    "```\n",
    "\n",
    "We can store the process property in a new variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "process = wx_file[\"process\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "The weld speed is restricted to a constant value of dimension \"[length]/[time]\"\n",
    "```yaml\n",
    "weld_speed:\n",
    "  tag: \"asdf://weldx.bam.de/weldx/tags/core/time_series-0.1.*\"\n",
    "  wx_unit: \"m/s\"\n",
    "  wx_shape: [1]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "process[\"weld_speed\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The welding wire is described by the constant diameter and a string describing the classification.\n",
    "```yaml\n",
    "welding_wire:\n",
    "  type: object\n",
    "  properties:\n",
    "    diameter:\n",
    "      description: |\n",
    "        The diameter of the welding wire.\n",
    "      tag: \"asdf://weldx.bam.de/weldx/tags/units/quantity-0.1.*\"\n",
    "      wx_unit: \"m\"\n",
    "      wx_shape: [1]\n",
    "    class:\n",
    "      type: string\n",
    "```\n",
    "\n",
    "Additional metadata can be stored in the `wx_user` field if necessary. In the example, a G4Si1 wire with 1.2 mm diameter was used. The manufacturer and charge number are also given."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "process[\"welding_wire\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The shielding gas information consists of a common name and the gas mixture."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "pprint(process[\"shielding_gas\"].torch_shielding_gas.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# switch to static plots\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `welding_process` describes the parameters set at the welding power source during the course of the experiment.\n",
    "\n",
    "Parameters are represented by a [`TimeSeries`](https://weldx.readthedocs.io/en/v0.5.0/tutorials/timeseries_01.html) object and can vary over time. In this example, all parameters are set to constant values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "gmaw_process = process[\"welding_process\"]\n",
    "fig, ax = plot_gmaw(gmaw_process, t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 6. Measurements\n",
    "We can list all measurements stored in the file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for measurement in wx_file[\"measurements\"]:\n",
    "    print(measurement.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also create a plot showing all signals stored in the measurement chains listed under `measurements`.\n",
    "\n",
    "In the example dataset the welding current and voltage are recorded during the welding process. The temperature-measurements are recorded before and after the welding experiment. Due to the use of reference times, all signals can be synchronized. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "plot_measurements(wx_file[\"measurements\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# switch to interactive plots\n",
    "%matplotlib widget"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Plot the voltage measurement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_signal(wx_file[\"welding_voltage\"], name=\"welding_voltage\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Plot the current meausurement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "plot_signal(wx_file[\"welding_current\"], name=\"welding_current\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Here is a detailed look at the current waveform:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "plot_signal(wx_file[\"welding_current\"], name=\"welding_current\", limits=(23, 23.025))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 7. Measurement chains\n",
    "To document how a welding related measurement was conducted, we can describe and store measurement chains using the `weldx` API.\n",
    "This includes:\n",
    "- describing the measurement equipment\n",
    "- describing multiple transformation steps from raw-data to the final measurement\n",
    "- providing information about measurement uncertainties and errors\n",
    "- attaching certification examples or similar files\n",
    "\n",
    "An in depth example describing measurement chains can be found in the documentation: [meassurement_example](https://weldx.readthedocs.io/en/v0.5.0/tutorials/measurement_example.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### current measurement chain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "current_measurement_chain = wx_file[\"measurements\"][0].measurement_chain\n",
    "\n",
    "current_source = current_measurement_chain.source\n",
    "print(current_source.name)\n",
    "for processor in current_measurement_chain.transformations:\n",
    "    print(processor.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each measurement chain object can be visualized with it's plot function. The squared nodes represent signals, the circular nodes show data that is present for a single signal. Transformation steps between signals are given with name and some info."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# switch to static plots\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(nrows=1, figsize=(12, 6))\n",
    "wx_file[\"measurements\"][0].measurement_chain.plot(ax);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(nrows=1, figsize=(12, 6))\n",
    "wx_file[\"measurements\"][1].measurement_chain.plot(ax);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(nrows=1, figsize=(12, 6))\n",
    "wx_file[\"measurements\"][2].measurement_chain.plot(ax);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 8. coordinate systems\n",
    "The `weldx` API contains multiple functions to describe dependencies and transformations between multiple different coordinate systems.\n",
    "\n",
    "- translations and rotations\n",
    "- constant and time dependent transformations\n",
    "- transformation between different systems\n",
    "- grouping multiple systems into subsystems\n",
    "- transforming spatial data between different coordinate systems\n",
    "- visualization of transformations and systems"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "There are multiple tutorials available covering coordinate transformations using the `LocalCoordinateSystem` and `CoordinateSystemManager` classes:\n",
    "\n",
    "- https://weldx.readthedocs.io/en/v0.5.0/tutorials/transformations_01_coordinate_systems.html\n",
    "- https://weldx.readthedocs.io/en/v0.5.0/tutorials/transformations_02_coordinate_system_manager.html\n",
    "- https://weldx.readthedocs.io/en/v0.5.0/tutorials/transformations_02_coordinate_system_manager.html#Visualizing-the-coordinate-systems-of-the-CSM\n",
    "- https://weldx.readthedocs.io/en/v0.5.0/tutorials/welding_example_02_weaving.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# switch to static plots\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "In addition to the simplified weldment specification, the example dataset contains the complete coordinate system information describing the BAM arc welding setup.\n",
    "\n",
    "- the definition of the reference user frame used for robot programming\n",
    "- the recorded actual TCP movement of the robot\n",
    "- the movement of a laser line scanner attached to the robot head"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "We can load the instance of the coordinate system manager directly from the `weldx` file.\\\n",
    "Following the file schema the data can be accessed under the key `coordinate_systems`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "csm = wx_file[\"coordinate_systems\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualize all loaded coordinate systems using the built-in `plot` functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "csm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "csm.plot_graph()\n",
    "plt.gcf().set_size_inches(w=6, h=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Let's take another look at the weld specimen.\n",
    "\n",
    "<img src='./data/WID417_pre.JPG' width=\"640\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "The workpiece coordinate system has it's origin located at the start of the workpiece at groove center. We can calculate the position of the thermocouple placement in the workpiece coordinate system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "csm.get_cs(\"T1\", \"user_frame\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "The second thermocouple is offset by 5 mm from the first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "csm.get_cs(\"T2\", \"T1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following command will calculate the recorded robot TCP movement in reference to the workpiece coordinate system.\n",
    "Since the robot movement is time dependent, the result will be a time dependent coordiante system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "csm.get_cs(\"TCP\", \"workpiece\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "csm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Interactive 3D visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Add geometry data to CSM\n",
    "\n",
    "For visualization using the `k3d` backend we create some 3D data from the workpiece description metadata and add it to the `CoordinateSystemManager`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "geometry_full_width = create_geometry(groove, seam_length, Q_(100, \"mm\"))\n",
    "spatial_data_geo_full = geometry_full_width.spatial_data(\n",
    "    profile_raster_width=Q_(4, \"mm\"), trace_raster_width=Q_(60, \"mm\")\n",
    ")\n",
    "spatial_data_geo_full.coordinates = spatial_data_geo_full.coordinates.astype(\"float32\")\n",
    "\n",
    "spatial_data_geo_reduced = geometry.spatial_data(\n",
    "    profile_raster_width=Q_(4, \"mm\"), trace_raster_width=Q_(60, \"mm\")\n",
    ")\n",
    "\n",
    "csm.assign_data(spatial_data_geo_full, \"workpiece geometry\", \"workpiece\")\n",
    "csm.assign_data(spatial_data_geo_reduced, \"workpiece geometry (reduced)\", \"workpiece\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "We also add a 3D model of the welding wire and attach it to the `TCP` coordinate system. The wire model will follow the TCP movement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "welding_wire_diameter = wx_file[\"process\"][\"welding_wire\"][\"diameter\"].m\n",
    "csm.assign_data(\n",
    "    welding_wire_geo_data(welding_wire_diameter / 2, 17, 16), \"welding_wire\", \"TCP\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Here is an example visualization of the experiment design.\\\n",
    "The reconstruction is entierly based on the metadata stored inside the `weldx` file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "csm.plot(\n",
    "    reference_system=\"workpiece\",\n",
    "    coordinate_systems=[\"TCP design\", \"T1\", \"T2\"],\n",
    "    data_sets=[\"workpiece geometry\", \"welding_wire\"],\n",
    "    colors=cs_colors,\n",
    "    show_data_labels=True,\n",
    "    backend=\"k3d\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the same visualization, this time using only actual measurement data for the plot.\n",
    "\n",
    "The `TCP` motion is taken from the robot recording of the actual TCP during welding operation.\\\n",
    "The workpiece data was obtained from a 3D scan of the workpiece data before and after welding. We can switch the pre- and post-weld scan data for the plot by selecting the corresponding datasets `scan_0` or `scan_1` in the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "csm.plot(\n",
    "    reference_system=\"workpiece\",\n",
    "    coordinate_systems=[\"TCP\", \"T1\", \"T2\"],\n",
    "    data_sets=[\"scan_0\", \"welding_wire\"],\n",
    "    colors=cs_colors,\n",
    "    show_data_labels=True,\n",
    "    backend=\"k3d\",\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "weldx",
   "language": "python",
   "name": "weldx-dev"
  },
  "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.9.2"
  },
  "rise": {
   "autolaunch": false,
   "footer": "<h3>IIW joint intermediate meeting C-I, C-IV, C-XII, SG-212 - 30.03.2021</h3>",
   "header": "<h1>WelDX - progress report on the welding data exchange format</h1>",
   "scroll": true,
   "theme": "white",
   "transition": "fade"
  },
  "toc-autonumbering": false,
  "toc-showmarkdowntxt": false,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}