{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "filter-00",
   "metadata": {},
   "source": [
    "# Region and Locset Filters\n",
    "\n",
    "This notebook is intentionally small-step: prepare a few morphology presets, define a small set of visualization knobs, then use short calls to show what each filter expression selects.\n",
    "\n",
    "The most important split is:\n",
    "\n",
    "- **Region filters** select branch intervals and are used by `Cell.paint(...)`.\n",
    "- **Locset filters** select branch-local points and are used by `Cell.place(...)`.\n",
    "\n",
    "Before the filters themselves, we first make the visualization level and CV policy explicit so every plot is easy to adjust.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "filter-01",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ.setdefault('JAX_PLATFORMS', 'cpu')\n",
    "os.environ.setdefault('PYVISTA_OFF_SCREEN', 'true')\n",
    "os.environ.setdefault('MPLBACKEND', 'Agg')\n",
    "\n",
    "from collections import Counter\n",
    "from pathlib import Path\n",
    "import warnings\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import brainunit as u\n",
    "import braincell\n",
    "import braincell.mech as mech\n",
    "from braincell import Morphology, Cell, CVPerBranch\n",
    "from braincell.filter import (\n",
    "    AllRegion,\n",
    "    EmptyRegion,\n",
    "    BranchSlice,\n",
    "    BranchInFilter,\n",
    "    BranchRangeFilter,\n",
    "    AtLocation,\n",
    "    RootLocation,\n",
    "    BranchPoints,\n",
    "    Terminals,\n",
    "    UniformSamples,\n",
    "    RandomSamples,\n",
    "    at,\n",
    "    branch_in,\n",
    "    branch_range,\n",
    ")\n",
    "\n",
    "warnings.filterwarnings(\n",
    "    'ignore',\n",
    "    message=r'from_points\\(\\) produced .* zero-length segment',\n",
    ")\n",
    "\n",
    "plt.rcParams['figure.dpi'] = 120\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-02",
   "metadata": {},
   "source": [
    "## 1. Prepare Morphology Presets\n",
    "\n",
    "The examples move from a tiny tree to richer real morphologies. Later code cells only refer to these variables.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "filter-03",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning: no DISPLAY environment variable.\n",
      "--No graphics will be displayed.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "morph_simple branches=   9  root=soma        types={'axon': 2, 'basal_dendrite': 6, 'soma': 1}\n",
      "morph_io     branches=  31  root=soma        types={'basal_dendrite': 25, 'soma': 6}\n",
      "morph_pc     branches= 461  root=soma        types={'dendrite': 460, 'soma': 1}\n"
     ]
    }
   ],
   "source": [
    "repo_root = Path(braincell.__file__).resolve().parents[1]\n",
    "morpho_dir = repo_root / 'data' / 'morphology' \n",
    "\n",
    "morph_simple = Morphology.from_swc(morpho_dir / 'example_tree.swc')\n",
    "morph_io = Morphology.from_swc(morpho_dir / 'io.swc')\n",
    "morph_pc = Morphology.from_asc(morpho_dir / 'pc.asc')\n",
    "\n",
    "MORPH_PRESETS = {\n",
    "    'morph_simple': morph_simple,\n",
    "    'morph_io': morph_io,\n",
    "    'morph_pc': morph_pc,\n",
    "}\n",
    "\n",
    "\n",
    "def describe_morph(name, morph):\n",
    "    type_count = dict(sorted(Counter(branch.type for branch in morph.branches).items()))\n",
    "    print(f'{name:<12} branches={len(morph.branches):>4}  root={morph.root.name:<10}  types={type_count}')\n",
    "\n",
    "\n",
    "for name, morph in MORPH_PRESETS.items():\n",
    "    describe_morph(name, morph)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-04",
   "metadata": {},
   "source": [
    "## 2. Visualization Knobs and Display Helpers\n",
    "\n",
    "`Cell.vis_topology(...)` can render the same selection at three topology levels:\n",
    "\n",
    "- `level='node'`: runtime point-tree view. Attachment points, CV midpoints, and branch terminal points can all be visible.\n",
    "- `level='cv'`: one node per control volume. This is the default for region examples in this notebook because it shows partial branch coverage clearly.\n",
    "- `level='branch'`: one node per morphology branch. This is compact and useful for branch metadata filters. Locsets cannot be drawn at branch level.\n",
    "\n",
    "The CV view depends on the control-volume policy. Here the global default is `CVPerBranch(cv_per_branch=2)`, meaning each branch is split into two CVs for the visualization cell. Change the constants below and rerun later cells to compare different settings.\n",
    "\n",
    "Each `compare_regions(...)` / `compare_locsets(...)` call also accepts per-panel overrides, so one row can compare different `level`, `layout`, `cv_per_branch`, or even different morphologies.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "filter-05",
   "metadata": {},
   "outputs": [],
   "source": [
    "CELL_CACHE = {}\n",
    "MORPH_NAMES = {id(morph): name for name, morph in MORPH_PRESETS.items()}\n",
    "COLORS = ('#ef4444', '#0ea5e9', '#22c55e', '#f59e0b', '#a855f7', '#14b8a6')\n",
    "\n",
    "# Global plot defaults. Change these and rerun later cells when comparing views.\n",
    "DEFAULT_MORPH = morph_simple\n",
    "DEFAULT_REGION_LEVEL = 'cv'\n",
    "DEFAULT_REGION_LAYOUT = 'twopi'\n",
    "DEFAULT_LOCSET_LEVEL = 'node'\n",
    "DEFAULT_LOCSET_LAYOUT = 'kamada_kawai'\n",
    "DEFAULT_CV_PER_BRANCH = 2\n",
    "DEFAULT_LAYOUT_SCALE = 1.5\n",
    "DEFAULT_PANEL_WIDTH = 3.8\n",
    "DEFAULT_PANEL_HEIGHT = 3.4\n",
    "\n",
    "\n",
    "def morph_name(morph):\n",
    "    return MORPH_NAMES.get(id(morph), 'morph')\n",
    "\n",
    "\n",
    "def resolve_morph(morph):\n",
    "    if morph is None:\n",
    "        return DEFAULT_MORPH\n",
    "    if isinstance(morph, str):\n",
    "        return MORPH_PRESETS[morph]\n",
    "    return morph\n",
    "\n",
    "\n",
    "def get_cell(morph, *, cv_per_branch=None):\n",
    "    cv_per_branch = DEFAULT_CV_PER_BRANCH if cv_per_branch is None else cv_per_branch\n",
    "    key = (id(morph), int(cv_per_branch))\n",
    "    if key not in CELL_CACHE:\n",
    "        cell = Cell(morph, cv_policy=CVPerBranch(cv_per_branch=int(cv_per_branch)))\n",
    "        cell.init_state()\n",
    "        CELL_CACHE[key] = cell\n",
    "    return CELL_CACHE[key]\n",
    "\n",
    "\n",
    "def _spec_from_item(item, *, default_morph, default_level, default_layout, default_cv_per_branch, default_layout_scale):\n",
    "    if isinstance(item, dict):\n",
    "        spec = dict(item)\n",
    "    else:\n",
    "        label, expr = item\n",
    "        spec = {'label': label, 'expr': expr}\n",
    "    spec['morph'] = resolve_morph(spec.get('morph', default_morph))\n",
    "    spec['level'] = spec.get('level', default_level)\n",
    "    spec['layout'] = spec.get('layout', default_layout)\n",
    "    spec['preset'] = spec.get('preset', None)\n",
    "    spec['layout_scale'] = spec.get('layout_scale', default_layout_scale)\n",
    "    spec['cv_per_branch'] = spec.get('cv_per_branch', default_cv_per_branch)\n",
    "    return spec\n",
    "\n",
    "\n",
    "def _topology_kwargs(spec, *, ax, highlight_color):\n",
    "    kwargs = {\n",
    "        'level': spec['level'],\n",
    "        'highlight_color': highlight_color,\n",
    "        'node_color': '#d1d5db',\n",
    "        'edge_color': '#e5e7eb',\n",
    "        'root_color': '#000000',\n",
    "        'ax': ax,\n",
    "        'show': False,\n",
    "    }\n",
    "    if spec.get('layout') is not None:\n",
    "        kwargs['layout'] = spec['layout']\n",
    "    if spec.get('preset') is not None:\n",
    "        kwargs['preset'] = spec['preset']\n",
    "    if spec.get('layout_scale') is not None:\n",
    "        kwargs['layout_scale'] = spec['layout_scale']\n",
    "    return kwargs\n",
    "\n",
    "\n",
    "def _plot_title(spec):\n",
    "    return f\"{spec['label']}\\n{morph_name(spec['morph'])} | {spec['level']} | cv={spec['cv_per_branch']}\"\n",
    "\n",
    "\n",
    "def compare_regions(\n",
    "    morph=None,\n",
    "    labeled_exprs=(),\n",
    "    *,\n",
    "    level=None,\n",
    "    layout=None,\n",
    "    cv_per_branch=None,\n",
    "    layout_scale=None,\n",
    "    width=None,\n",
    "    height=None,\n",
    "):\n",
    "    base_morph = resolve_morph(morph)\n",
    "    base_level = DEFAULT_REGION_LEVEL if level is None else level\n",
    "    base_layout = DEFAULT_REGION_LAYOUT if layout is None else layout\n",
    "    base_cv_per_branch = DEFAULT_CV_PER_BRANCH if cv_per_branch is None else cv_per_branch\n",
    "    base_layout_scale = DEFAULT_LAYOUT_SCALE if layout_scale is None else layout_scale\n",
    "    specs = [\n",
    "        _spec_from_item(\n",
    "            item,\n",
    "            default_morph=base_morph,\n",
    "            default_level=base_level,\n",
    "            default_layout=base_layout,\n",
    "            default_cv_per_branch=base_cv_per_branch,\n",
    "            default_layout_scale=base_layout_scale,\n",
    "        )\n",
    "        for item in labeled_exprs\n",
    "    ]\n",
    "    width = DEFAULT_PANEL_WIDTH if width is None else width\n",
    "    height = DEFAULT_PANEL_HEIGHT if height is None else height\n",
    "\n",
    "    fig, axes = plt.subplots(1, len(specs), figsize=(width * len(specs), height))\n",
    "    axes = [axes] if len(specs) == 1 else list(axes)\n",
    "\n",
    "    print(\n",
    "        'compare_regions defaults:',\n",
    "        f'morph={morph_name(base_morph)}',\n",
    "        f'level={base_level}',\n",
    "        f'layout={base_layout}',\n",
    "        f'cv_per_branch={base_cv_per_branch}',\n",
    "    )\n",
    "    for index, spec in enumerate(specs):\n",
    "        spec_morph = spec['morph']\n",
    "        expr = spec['expr']\n",
    "        mask = spec_morph.select(expr)\n",
    "        print(\n",
    "            f\"  {spec['label']:<28}\",\n",
    "            f\"morph={morph_name(spec_morph):<12}\",\n",
    "            f\"level={spec['level']:<6}\",\n",
    "            f\"layout={str(spec['layout'] or spec['preset']):<12}\",\n",
    "            f\"cv_per_branch={spec['cv_per_branch']:<2}\",\n",
    "            f\"intervals={len(mask.intervals):>4}\",\n",
    "            f\"sample={mask.intervals[:4]}\",\n",
    "        )\n",
    "        cell = get_cell(spec_morph, cv_per_branch=spec['cv_per_branch'])\n",
    "        kwargs = _topology_kwargs(spec, ax=axes[index], highlight_color=COLORS[index % len(COLORS)])\n",
    "        kwargs['region'] = expr\n",
    "        kwargs['coverage_mode'] = spec.get('coverage_mode', 'fraction')\n",
    "        cell.vis_topology(**kwargs)\n",
    "        axes[index].set_title(_plot_title(spec), fontsize=9)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def compare_locsets(\n",
    "    morph=None,\n",
    "    labeled_exprs=(),\n",
    "    *,\n",
    "    level=None,\n",
    "    layout=None,\n",
    "    cv_per_branch=None,\n",
    "    layout_scale=None,\n",
    "    width=None,\n",
    "    height=None,\n",
    "):\n",
    "    base_morph = resolve_morph(morph)\n",
    "    base_level = DEFAULT_LOCSET_LEVEL if level is None else level\n",
    "    base_layout = DEFAULT_LOCSET_LAYOUT if layout is None else layout\n",
    "    base_cv_per_branch = DEFAULT_CV_PER_BRANCH if cv_per_branch is None else cv_per_branch\n",
    "    base_layout_scale = DEFAULT_LAYOUT_SCALE if layout_scale is None else layout_scale\n",
    "    specs = [\n",
    "        _spec_from_item(\n",
    "            item,\n",
    "            default_morph=base_morph,\n",
    "            default_level=base_level,\n",
    "            default_layout=base_layout,\n",
    "            default_cv_per_branch=base_cv_per_branch,\n",
    "            default_layout_scale=base_layout_scale,\n",
    "        )\n",
    "        for item in labeled_exprs\n",
    "    ]\n",
    "    width = DEFAULT_PANEL_WIDTH if width is None else width\n",
    "    height = DEFAULT_PANEL_HEIGHT if height is None else height\n",
    "\n",
    "    fig, axes = plt.subplots(1, len(specs), figsize=(width * len(specs), height))\n",
    "    axes = [axes] if len(specs) == 1 else list(axes)\n",
    "\n",
    "    print(\n",
    "        'compare_locsets defaults:',\n",
    "        f'morph={morph_name(base_morph)}',\n",
    "        f'level={base_level}',\n",
    "        f'layout={base_layout}',\n",
    "        f'cv_per_branch={base_cv_per_branch}',\n",
    "    )\n",
    "    for index, spec in enumerate(specs):\n",
    "        if spec['level'] == 'branch':\n",
    "            raise ValueError(\"Locsets can be visualized with level='node' or level='cv', not level='branch'.\")\n",
    "        spec_morph = spec['morph']\n",
    "        expr = spec['expr']\n",
    "        mask = spec_morph.select(expr)\n",
    "        print(\n",
    "            f\"  {spec['label']:<28}\",\n",
    "            f\"morph={morph_name(spec_morph):<12}\",\n",
    "            f\"level={spec['level']:<6}\",\n",
    "            f\"layout={str(spec['layout'] or spec['preset']):<12}\",\n",
    "            f\"cv_per_branch={spec['cv_per_branch']:<2}\",\n",
    "            f\"points={len(mask.points):>4}\",\n",
    "            f\"sample={mask.display_names[:4]}\",\n",
    "        )\n",
    "        cell = get_cell(spec_morph, cv_per_branch=spec['cv_per_branch'])\n",
    "        kwargs = _topology_kwargs(spec, ax=axes[index], highlight_color=COLORS[index % len(COLORS)])\n",
    "        kwargs['locset'] = expr\n",
    "        cell.vis_topology(**kwargs)\n",
    "        axes[index].set_title(_plot_title(spec), fontsize=9)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-06",
   "metadata": {},
   "source": [
    "### 2.1 One Region, Different Views\n",
    "\n",
    "This first example keeps the filter fixed and changes the display settings. It shows why `level` and `cv_per_branch` matter before we start comparing filter logic.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "filter-07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compare_regions defaults: morph=morph_simple level=cv layout=twopi cv_per_branch=2\n",
      "  node view                    morph=morph_simple level=node   layout=dendrotweaks cv_per_branch=2  intervals=   1 sample=((3, 0.1, 0.8),)\n",
      "  cv, 1 per branch             morph=morph_simple level=cv     layout=twopi        cv_per_branch=1  intervals=   1 sample=((3, 0.1, 0.8),)\n",
      "  cv, 2 per branch             morph=morph_simple level=cv     layout=twopi        cv_per_branch=2  intervals=   1 sample=((3, 0.1, 0.8),)\n",
      "  branch view                  morph=morph_simple level=branch layout=dot          cv_per_branch=2  intervals=   1 sample=((3, 0.1, 0.8),)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1824x408 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "same_region = BranchSlice(branch_index=3, prox=0.10, dist=0.80)\n",
    "\n",
    "compare_regions(\n",
    "    morph_simple,\n",
    "    [\n",
    "        {'label': 'node view', 'expr': same_region, 'level': 'node', 'preset': 'dendrotweaks', 'layout': None},\n",
    "        {'label': 'cv, 1 per branch', 'expr': same_region, 'level': 'cv', 'layout': 'twopi', 'cv_per_branch': 1},\n",
    "        {'label': 'cv, 2 per branch', 'expr': same_region, 'level': 'cv', 'layout': 'twopi', 'cv_per_branch': 2},\n",
    "        {'label': 'branch view', 'expr': same_region, 'level': 'branch', 'layout': 'dot'},\n",
    "    ],\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-08",
   "metadata": {},
   "source": [
    "## 3. Region Filters\n",
    "\n",
    "A region is a set of continuous branch intervals: `(branch_id, prox, dist)`.\n",
    "\n",
    "Start with the small morphology so every selection is easy to inspect.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-09",
   "metadata": {},
   "source": [
    "### 3.1 Explicit Regions\n",
    "\n",
    "Use `AllRegion`, `EmptyRegion`, and `BranchSlice` when you already know the branch ids and normalized coordinates.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "filter-10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compare_regions defaults: morph=morph_simple level=cv layout=twopi cv_per_branch=1\n",
      "  all branches                 morph=morph_simple level=cv     layout=twopi        cv_per_branch=1  intervals=   9 sample=((0, 0.0, 1.0), (1, 0.0, 1.0), (2, 0.0, 1.0), (3, 0.0, 1.0))\n",
      "  branch 3: 10%-80%            morph=morph_simple level=cv     layout=twopi        cv_per_branch=1  intervals=   1 sample=((3, 0.1, 0.8),)\n",
      "  two branch slices            morph=morph_simple level=cv     layout=twopi        cv_per_branch=1  intervals=   2 sample=((1, 0.0, 1.0), (3, 0.2, 0.8))\n",
      "  empty                        morph=morph_simple level=cv     layout=twopi        cv_per_branch=1  intervals=   0 sample=()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1824x408 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "compare_regions(\n",
    "    morph_simple,\n",
    "    [\n",
    "        ('all branches', AllRegion()),\n",
    "        ('branch 3: 10%-80%', BranchSlice(branch_index=3, prox=0.10, dist=0.80)),\n",
    "        ('two branch slices', BranchSlice(branch_index=[1, 3], prox=[0.0, 0.20], dist=[1.0, 0.80])),\n",
    "        ('empty', EmptyRegion()),\n",
    "    ],\n",
    "    level='cv',\n",
    "    layout='twopi',\n",
    "    cv_per_branch=1,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-11",
   "metadata": {},
   "source": [
    "### 3.2 Branch Metadata Predicates\n",
    "\n",
    "Use `branch_in(...)` when the rule is equality or membership over branch metadata / topology.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "filter-12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compare_regions defaults: morph=morph_simple level=branch layout=dot cv_per_branch=2\n",
      "  type == soma                 morph=morph_simple level=branch layout=dot          cv_per_branch=2  intervals=   1 sample=((0, 0.0, 1.0),)\n",
      "  type == basal                morph=morph_simple level=branch layout=dot          cv_per_branch=2  intervals=   6 sample=((3, 0.0, 1.0), (4, 0.0, 1.0), (5, 0.0, 1.0), (6, 0.0, 1.0))\n",
      "  children of branch 3         morph=morph_simple level=branch layout=dot          cv_per_branch=2  intervals=   3 sample=((4, 0.0, 1.0), (7, 0.0, 1.0), (8, 0.0, 1.0))\n",
      "  order in {2, 3}              morph=morph_simple level=branch layout=dot          cv_per_branch=2  intervals=   6 sample=((2, 0.0, 1.0), (4, 0.0, 1.0), (5, 0.0, 1.0), (6, 0.0, 1.0))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1824x408 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "compare_regions(\n",
    "    morph_simple,\n",
    "    [\n",
    "        ('type == soma', branch_in('type', 'soma')),\n",
    "        ('type == basal', branch_in('type', 'basal_dendrite')),\n",
    "        ('children of branch 3', branch_in('parent_id', {3})),\n",
    "        ('order in {2, 3}', branch_in('branch_order', {2, 3})),\n",
    "    ],\n",
    "    level='branch',\n",
    "    layout='dot',\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-13",
   "metadata": {},
   "source": [
    "### 3.3 Numeric and Quantity Ranges\n",
    "\n",
    "Use `branch_range(...)` for numeric topology values and unit-carrying branch metrics.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "filter-14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compare_regions defaults: morph=morph_simple level=branch layout=dot cv_per_branch=2\n",
      "  branch_id [1, 4]             morph=morph_simple level=branch layout=dot          cv_per_branch=2  intervals=   4 sample=((1, 0.0, 1.0), (2, 0.0, 1.0), (3, 0.0, 1.0), (4, 0.0, 1.0))\n",
      "  length >= 20 um              morph=morph_simple level=branch layout=dot          cv_per_branch=2  intervals=   5 sample=((1, 0.0, 1.0), (3, 0.0, 1.0), (4, 0.0, 1.0), (5, 0.0, 1.0))\n",
      "  mean_radius <= 1 um          morph=morph_simple level=branch layout=dot          cv_per_branch=2  intervals=   3 sample=((1, 0.0, 1.0), (2, 0.0, 1.0), (8, 0.0, 1.0))\n",
      "  volume <= 80 um^3            morph=morph_simple level=branch layout=dot          cv_per_branch=2  intervals=   3 sample=((2, 0.0, 1.0), (6, 0.0, 1.0), (8, 0.0, 1.0))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1824x408 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "compare_regions(\n",
    "    morph_simple,\n",
    "    [\n",
    "        ('branch_id [1, 4]', branch_range('branch_id', (1, 4), closed='both')),\n",
    "        ('length >= 20 um', branch_range('length', (20.0 * u.um, None), closed='left')),\n",
    "        ('mean_radius <= 1 um', branch_range('mean_radius', (None, 1.0 * u.um), closed='right')),\n",
    "        ('volume <= 80 um^3', branch_range('volume', (None, 80.0 * (u.um ** 3)), closed='right')),\n",
    "    ],\n",
    "    level='branch',\n",
    "    layout='dot',\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-15",
   "metadata": {},
   "source": [
    "### 3.4 Region Set Algebra\n",
    "\n",
    "Region expressions compose with union, intersection, difference, and complement.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "filter-16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compare_regions defaults: morph=morph_pc level=cv layout=twopi cv_per_branch=2\n",
      "  left | right                 morph=morph_pc     level=cv     layout=twopi        cv_per_branch=2  intervals=   1 sample=((3, 0.0, 1.0),)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  left & right                 morph=morph_pc     level=cv     layout=twopi        cv_per_branch=2  intervals=   1 sample=((3, 0.4, 0.6),)\n",
      "  left - right                 morph=morph_pc     level=cv     layout=twopi        cv_per_branch=2  intervals=   1 sample=((3, 0.0, 0.4),)\n",
      "  exclude.complement()         morph=morph_pc     level=cv     layout=twopi        cv_per_branch=2  intervals= 461 sample=((0, 0.0, 1.0), (2, 0.0, 1.0), (3, 0.0, 0.2), (3, 0.8, 1.0))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1824x408 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "left = BranchSlice(branch_index=3, prox=0.00, dist=0.60)\n",
    "right = BranchSlice(branch_index=3, prox=0.40, dist=1.00)\n",
    "exclude = BranchSlice(branch_index=[1, 3], prox=[0.00, 0.20], dist=[1.00, 0.80])\n",
    "\n",
    "compare_regions(\n",
    "    morph_pc,\n",
    "    [\n",
    "        ('left | right', left | right),\n",
    "        ('left & right', left & right),\n",
    "        ('left - right', left - right),\n",
    "        ('exclude.complement()', exclude.complement()),\n",
    "    ],\n",
    "    level='cv',\n",
    "    layout='twopi',\n",
    "    cv_per_branch=2,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-17",
   "metadata": {},
   "source": [
    "### 3.5 Same Logic on `morph_io`\n",
    "\n",
    "Once the filter expression is clear, the same calls work on a richer morphology.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "filter-18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compare_regions defaults: morph=morph_io level=branch layout=dot cv_per_branch=2\n",
      "  basal branches               morph=morph_io     level=branch layout=dot          cv_per_branch=2  intervals=  25 sample=((6, 0.0, 1.0), (7, 0.0, 1.0), (8, 0.0, 1.0), (9, 0.0, 1.0))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  length >= 100 um             morph=morph_io     level=branch layout=dot          cv_per_branch=2  intervals=  10 sample=((8, 0.0, 1.0), (10, 0.0, 1.0), (11, 0.0, 1.0), (13, 0.0, 1.0))\n",
      "  basal & long                 morph=morph_io     level=branch layout=dot          cv_per_branch=2  intervals=  10 sample=((8, 0.0, 1.0), (10, 0.0, 1.0), (11, 0.0, 1.0), (13, 0.0, 1.0))\n",
      "  order [2, 4)                 morph=morph_io     level=branch layout=dot          cv_per_branch=2  intervals=  16 sample=((7, 0.0, 1.0), (8, 0.0, 1.0), (9, 0.0, 1.0), (12, 0.0, 1.0))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1824x408 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "basal = branch_in('type', 'basal_dendrite')\n",
    "long = branch_range('length', (100.0 * u.um, None), closed='left')\n",
    "mid_order = branch_range('branch_order', (2, 4), closed='left')\n",
    "\n",
    "compare_regions(\n",
    "    morph_io,\n",
    "    [\n",
    "        ('basal branches', basal),\n",
    "        ('length >= 100 um', long),\n",
    "        ('basal & long', basal & long),\n",
    "        ('order [2, 4)', mid_order),\n",
    "    ],\n",
    "    level='branch',\n",
    "    layout='dot',\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-19",
   "metadata": {},
   "source": [
    "### 3.6 Same Logic on `morph_pc`\n",
    "\n",
    "On a larger morphology, use the same small vocabulary: metadata predicates, metric ranges, and set algebra.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "filter-20",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compare_regions defaults: morph=morph_pc level=branch layout=dot cv_per_branch=2\n",
      "  order [6, 8)                 morph=morph_pc     level=branch layout=dot          cv_per_branch=2  intervals=  52 sample=((6, 0.0, 1.0), (7, 0.0, 1.0), (8, 0.0, 1.0), (9, 0.0, 1.0))\n",
      "  length <= 5 um               morph=morph_pc     level=branch layout=dot          cv_per_branch=2  intervals= 113 sample=((7, 0.0, 1.0), (8, 0.0, 1.0), (9, 0.0, 1.0), (10, 0.0, 1.0))\n",
      "  mean_radius <= 0.5 um        morph=morph_pc     level=branch layout=dot          cv_per_branch=2  intervals= 328 sample=((5, 0.0, 1.0), (6, 0.0, 1.0), (7, 0.0, 1.0), (8, 0.0, 1.0))\n",
      "  deep & short                 morph=morph_pc     level=branch layout=dot          cv_per_branch=2  intervals=  18 sample=((7, 0.0, 1.0), (8, 0.0, 1.0), (9, 0.0, 1.0), (10, 0.0, 1.0))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 4032x1200 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "deep = branch_range('branch_order', (6, 8), closed='left')\n",
    "short = branch_range('length', (None, 5.0 * u.um), closed='right')\n",
    "thin = branch_range('mean_radius', (None, 0.5 * u.um), closed='right')\n",
    "\n",
    "compare_regions(\n",
    "    morph_pc,\n",
    "    [\n",
    "        ('order [6, 8)', deep),\n",
    "        ('length <= 5 um', short),\n",
    "        ('mean_radius <= 0.5 um', thin),\n",
    "        ('deep & short', deep & short),\n",
    "    ],\n",
    "    level='branch',\n",
    "    layout='dot',\n",
    "    width=8.4,\n",
    "    height=10.0,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-21",
   "metadata": {},
   "source": [
    "## 4. Locset Filters\n",
    "\n",
    "A locset is a set of points: `(branch_id, x)`.\n",
    "\n",
    "Locsets are separate from regions because they mark point-process sites instead of continuous branch intervals.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-22",
   "metadata": {},
   "source": [
    "### 4.1 Direct Point Selectors\n",
    "\n",
    "Use direct locsets when you know the exact site or want built-in structural points.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "filter-23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compare_locsets defaults: morph=morph_simple level=node layout=kamada_kawai cv_per_branch=2\n",
      "  root midpoint                morph=morph_simple level=node   layout=kamada_kawai cv_per_branch=2  points=   1 sample=('soma(0.5)',)\n",
      "  at('soma', 1.0)              morph=morph_simple level=node   layout=kamada_kawai cv_per_branch=2  points=   1 sample=('soma(1)',)\n",
      "  AtLocation('axon_0', 0.5)    morph=morph_simple level=node   layout=kamada_kawai cv_per_branch=2  points=   1 sample=('axon_0(0.5)',)\n",
      "  branch points                morph=morph_simple level=node   layout=kamada_kawai cv_per_branch=2  points=   5 sample=('soma(0)', 'soma(1)', 'basal_dendrite_0(0)', 'basal_dendrite_0(1)')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1824x408 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "compare_locsets(\n",
    "    morph_simple,\n",
    "    [\n",
    "        ('root midpoint', RootLocation(x=0.5)),\n",
    "        (\"at('soma', 1.0)\", at('soma', 1.0)),\n",
    "        (\"AtLocation('axon_0', 0.5)\", AtLocation(branch='axon_0', x=0.5)),\n",
    "        ('branch points', BranchPoints()),\n",
    "    ],\n",
    "    level='node',\n",
    "    layout='kamada_kawai',\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-24",
   "metadata": {},
   "source": [
    "### 4.2 Structural Locsets and Set Algebra\n",
    "\n",
    "Locsets also compose with union, intersection, and difference.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "filter-25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compare_locsets defaults: morph=morph_simple level=node layout=kamada_kawai cv_per_branch=2\n",
      "  terminals                    morph=morph_simple level=node   layout=kamada_kawai cv_per_branch=2  points=   5 sample=('axon_1(1)', 'basal_dendrite_2(1)', 'basal_dendrite_3(1)', 'basal_dendrite_4(1)')\n",
      "  branch points                morph=morph_simple level=node   layout=kamada_kawai cv_per_branch=2  points=   5 sample=('soma(0)', 'soma(1)', 'basal_dendrite_0(0)', 'basal_dendrite_0(1)')\n",
      "  branch_points | terminals    morph=morph_simple level=node   layout=kamada_kawai cv_per_branch=2  points=  10 sample=('soma(0)', 'soma(1)', 'axon_1(1)', 'basal_dendrite_0(0)')\n",
      "  terminals - first            morph=morph_simple level=node   layout=kamada_kawai cv_per_branch=2  points=   4 sample=('basal_dendrite_2(1)', 'basal_dendrite_3(1)', 'basal_dendrite_4(1)', 'basal_dendrite_5(1)')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1824x408 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "branch_points = BranchPoints()\n",
    "terminals = Terminals()\n",
    "first_terminal = morph_simple.select(terminals).points[0]\n",
    "\n",
    "compare_locsets(\n",
    "    morph_simple,\n",
    "    [\n",
    "        ('terminals', terminals),\n",
    "        ('branch points', branch_points),\n",
    "        ('branch_points | terminals', branch_points | terminals),\n",
    "        ('terminals - first', terminals - at(first_terminal[0], first_terminal[1])),\n",
    "    ],\n",
    "    level='node',\n",
    "    layout='kamada_kawai',\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-26",
   "metadata": {},
   "source": [
    "### 4.3 Sampling Points from a Region\n",
    "\n",
    "`UniformSamples` and `RandomSamples` take a region expression, then choose points inside it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "filter-27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "same random seed gives same points: True\n",
      "\n",
      "compare_locsets defaults: morph=morph_io level=cv layout=twopi cv_per_branch=2\n",
      "  terminals                    morph=morph_io     level=cv     layout=twopi        cv_per_branch=2  points=  17 sample=('soma_1(1)', 'basal_dendrite_2(1)', 'basal_dendrite_4(1)', 'basal_dendrite_5(1)')\n",
      "  uniform samples              morph=morph_io     level=cv     layout=twopi        cv_per_branch=2  points=   8 sample=('basal_dendrite_2(0.405)', 'basal_dendrite_4(0.537347)', 'basal_dendrite_7(0.548927)', 'basal_dendrite_12(0.435744)')\n",
      "  random seed 7                morph=morph_io     level=cv     layout=twopi        cv_per_branch=2  points=   8 sample=('soma_1(0.504548)', 'basal_dendrite_5(0.278426)', 'basal_dendrite_7(0.25487)', 'basal_dendrite_15(0.797069)')\n",
      "  same random seed             morph=morph_io     level=cv     layout=twopi        cv_per_branch=2  points=   8 sample=('soma_1(0.504548)', 'basal_dendrite_5(0.278426)', 'basal_dendrite_7(0.25487)', 'basal_dendrite_15(0.797069)')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1824x408 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sampling_region = branch_range('branch_order', (1, None), closed='left')\n",
    "uniform = UniformSamples(region=sampling_region, count=8)\n",
    "random_a = RandomSamples(region=sampling_region, count=8, seed=7)\n",
    "random_b = RandomSamples(region=sampling_region, count=8, seed=7)\n",
    "\n",
    "print('same random seed gives same points:', morph_io.select(random_a).points == morph_io.select(random_b).points)\n",
    "print()\n",
    "\n",
    "compare_locsets(\n",
    "    morph_io,\n",
    "    [\n",
    "        ('terminals', Terminals()),\n",
    "        ('uniform samples', uniform),\n",
    "        ('random seed 7', random_a),\n",
    "        ('same random seed', random_b),\n",
    "    ],\n",
    "    level='cv',\n",
    "    layout='twopi',\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-28",
   "metadata": {},
   "source": [
    "### 4.4 Locsets on `morph_pc`\n",
    "\n",
    "The same locset calls work on the larger morphology. The filter logic stays small; only the morphology changes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "filter-29",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compare_locsets defaults: morph=morph_pc level=cv layout=dot cv_per_branch=2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  branch points                morph=morph_pc     level=cv     layout=dot          cv_per_branch=2  points= 228 sample=('dendrite_0(1)', 'dendrite_1(1)', 'dendrite_2(1)', 'dendrite_3(1)')\n",
      "  terminals                    morph=morph_pc     level=cv     layout=dot          cv_per_branch=2  points= 229 sample=('dendrite_6(1)', 'dendrite_7(1)', 'dendrite_10(1)', 'dendrite_11(1)')\n",
      "  uniform deep samples         morph=morph_pc     level=cv     layout=dot          cv_per_branch=2  points=  12 sample=('dendrite_8(0.333287)', 'dendrite_20(0.845796)', 'dendrite_80(0.793563)', 'dendrite_88(0.921427)')\n",
      "  random deep samples          morph=morph_pc     level=cv     layout=dot          cv_per_branch=2  points=  12 sample=('dendrite_17(0.284201)', 'dendrite_17(0.430628)', 'dendrite_20(0.97346)', 'dendrite_26(0.292721)')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2112x480 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pc_sampling_region = branch_range('branch_order', (6, 8), closed='left')\n",
    "\n",
    "compare_locsets(\n",
    "    morph_pc,\n",
    "    [\n",
    "        ('branch points', BranchPoints()),\n",
    "        ('terminals', Terminals()),\n",
    "        ('uniform deep samples', UniformSamples(region=pc_sampling_region, count=12)),\n",
    "        ('random deep samples', RandomSamples(region=pc_sampling_region, count=12, seed=3)),\n",
    "    ],\n",
    "    level='cv',\n",
    "    layout='dot',\n",
    "    width=4.4,\n",
    "    height=4.0,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-30",
   "metadata": {},
   "source": [
    "## 5. Filters as Cell Inputs\n",
    "\n",
    "The same expressions are the user-facing handles for mechanism placement.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "filter-31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cell(root='soma', n_cv=18, n_point=28, initialized=True)\n",
      "painted region intervals: ((1, 0.0, 1.0), (2, 0.0, 1.0))\n",
      "probe site points      : ('soma(0.5)',)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 960x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cell = Cell(morph_simple, cv_policy=CVPerBranch(cv_per_branch=2))\n",
    "axon_region = branch_in('type', 'axon')\n",
    "probe_site = RootLocation(0.5)\n",
    "\n",
    "cell.paint(\n",
    "    axon_region,\n",
    "    mech.Channel('IL', g_max=0.03 * (u.mS / u.cm ** 2), E=-65.0 * u.mV),\n",
    ")\n",
    "cell.place(probe_site, mech.StateProbe())\n",
    "cell.init_state()\n",
    "\n",
    "print(cell)\n",
    "print('painted region intervals:', morph_simple.select(axon_region).intervals)\n",
    "print('probe site points      :', morph_simple.select(probe_site).display_names)\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(8.0, 3.6))\n",
    "cell.vis_topology(level='branch', layout='dot', region=axon_region, ax=axes[0], show=False)\n",
    "axes[0].set_title('paint: axon region')\n",
    "cell.vis_topology(level='node', layout='kamada_kawai', layout_scale=1.5, locset=probe_site, ax=axes[1], show=False, highlight_color='#f97316')\n",
    "axes[1].set_title('place: root locset')\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filter-32",
   "metadata": {},
   "source": [
    "## 6. Quick Reference\n",
    "\n",
    "Plot configuration lives in the global constants near the top of the notebook. You can also override per panel with dictionaries:\n",
    "\n",
    "```python\n",
    "compare_regions(\n",
    "    morph_simple,\n",
    "    [\n",
    "        {'label': 'cv view', 'expr': expr, 'level': 'cv', 'layout': 'twopi', 'cv_per_branch': 2},\n",
    "        {'label': 'branch view', 'expr': expr, 'level': 'branch', 'layout': 'dot'},\n",
    "    ],\n",
    ")\n",
    "```\n",
    "\n",
    "Implemented region selectors:\n",
    "\n",
    "| API | Use when |\n",
    "| --- | --- |\n",
    "| `AllRegion()` / `EmptyRegion()` | select all / no branch intervals |\n",
    "| `BranchSlice(...)` | select explicit `(branch_id, prox, dist)` intervals |\n",
    "| `branch_in(property, values)` | match branch metadata, topology, or scalar metric values |\n",
    "| `branch_range(property, bounds, closed=...)` | filter numeric or `brainunit` quantity-valued branch properties |\n",
    "| `left | right`, `left & right`, `left - right`, `expr.complement()` | compose region expressions |\n",
    "\n",
    "Supported scalar branch properties:\n",
    "\n",
    "- metadata / topology: `branch_id`, `name`, `type`, `parent_id`, `n_children`, `branch_order`, `n_tapers`\n",
    "- geometry metrics: `length`, `mean_radius`, `area`, `volume`\n",
    "\n",
    "Implemented locset selectors:\n",
    "\n",
    "| API | Use when |\n",
    "| --- | --- |\n",
    "| `RootLocation(x)` | choose a point on branch `0` |\n",
    "| `AtLocation(branch, x)` / `at(branch, x)` | choose an explicit branch-local point |\n",
    "| `BranchPoints()` | choose branch-point sites on the parent side |\n",
    "| `Terminals()` | choose terminal branch distal ends |\n",
    "| `UniformSamples(region, count)` | evenly sample points from a region |\n",
    "| `RandomSamples(region, count, seed)` | reproducibly sample random points from a region |\n",
    "| `left | right`, `left & right`, `left - right` | compose locset expressions |\n",
    "\n",
    "Exported but not implemented yet: `RadiusRangeRegion`, `TreeDistanceRegion`, `EuclideanDistanceRegion`, `SubtreeRegion`, `RegionAnchors`, and `StepSamples`.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "braincell",
   "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.10.16"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "156edba69c7444cb8b69a45f17d1d364": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "2.0.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "2.0.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_allow_html": false,
       "layout": "IPY_MODEL_39cd983a750e44c881a21e512b4a58d5",
       "placeholder": "​",
       "style": "IPY_MODEL_95c48461a41a4668ab6f75b2593e4a55",
       "tabbable": null,
       "tooltip": null,
       "value": "<iframe srcdoc=\"<!DOCTYPE html>\n<html>\n  <head>\n    <meta http-equiv=&quot;Content-type&quot; content=&quot;text/html; charset=utf-8&quot;/>\n    <meta name=&quot;viewport&quot; content=&quot;width=device-width, height=device-height, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no&quot;>\n  </head>\n  <body>\n    <div class=&quot;content&quot;></div>\n<script type=&quot;text/javascript&quot;>\n!function(){var e={853:function(e,t,n){&quot;use strict&quot;;n.r(t),n.d(t,{initLocalFileLoader:function(){return XC},load:function(){return qC}});var r={};n.r(r),n.d(r,{add:function(){return J},adjoint:function(){return T},clone:function(){return d},copy:function(){return p},create:function(){return u},determinant:function(){return y},equals:function(){return oe},exactEquals:function(){return re},frob:function(){return Q},fromQuat:function(){return G},fromQuat2:function(){return L},fromRotation:function(){return R},fromRotationTranslation:function(){return D},fromRotationTranslationScale:function(){return _},fromRotationTranslationScaleOrigin:function(){return k},fromScaling:function(){return P},fromTranslation:function(){return O},fromValues:function(){return f},fromXRotation:function(){return M},fromYRotation:function(){return E},fromZRotation:function(){return V},frustum:function(){return U},getRotation:function(){return F},getScaling:function(){return N},getTranslation:function(){return B},identity:function(){return m},invert:function(){return v},lookAt:function(){return X},mul:function(){return ae},multiply:function(){return b},multiplyScalar:function(){return te},multiplyScalarAndAdd:function(){return ne},ortho:function(){return $},orthoNO:function(){return K},orthoZO:function(){return q},perspective:function(){return W},perspectiveFromFieldOfView:function(){return j},perspectiveNO:function(){return z},perspectiveZO:function(){return H},rotate:function(){return S},rotateX:function(){return A},rotateY:function(){return I},rotateZ:function(){return w},scale:function(){return C},set:function(){return g},str:function(){return Z},sub:function(){return ie},subtract:function(){return ee},targetTo:function(){return Y},translate:function(){return x},transpose:function(){return h}});var o={};n.r(o),n.d(o,{add:function(){return Ee},adjoint:function(){return he},clone:function(){return ce},copy:function(){return ue},create:function(){return se},determinant:function(){return ve},equals:function(){return Ne},exactEquals:function(){return Be},frob:function(){return Me},fromMat2d:function(){return Ie},fromMat4:function(){return le},fromQuat:function(){return we},fromRotation:function(){return Se},fromScaling:function(){return Ae},fromTranslation:function(){return Ce},fromValues:function(){return de},identity:function(){return fe},invert:function(){return me},mul:function(){return Fe},multiply:function(){return Te},multiplyScalar:function(){return De},multiplyScalarAndAdd:function(){return Le},normalFromMat4:function(){return Oe},projection:function(){return Pe},rotate:function(){return be},scale:function(){return xe},set:function(){return pe},str:function(){return Re},sub:function(){return _e},subtract:function(){return Ve},translate:function(){return ye},transpose:function(){return ge}});const a=document.querySelector(&quot;head&quot;);a&&[16,32,96,160,196].forEach((e=>{const t=document.createElement(&quot;link&quot;);t.setAttribute(&quot;rel&quot;,&quot;icon&quot;),t.setAttribute(&quot;href&quot;,`https://kitware.github.io/vtk-js/icon/favicon-${e}x${e}.png`),t.setAttribute(&quot;sizes&quot;,`${e}x${e}`),t.setAttribute(&quot;type&quot;,&quot;image/png&quot;),a.appendChild(t)}));var i=1e-6,s=&quot;undefined&quot;!=typeof Float32Array?Float32Array:Array;Math.random;var l=Math.PI/180;function c(e){return e*l}function u(){var e=new s(16);return s!=Float32Array&&(e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0),e[0]=1,e[5]=1,e[10]=1,e[15]=1,e}function d(e){var t=new s(16);return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t[4]=e[4],t[5]=e[5],t[6]=e[6],t[7]=e[7],t[8]=e[8],t[9]=e[9],t[10]=e[10],t[11]=e[11],t[12]=e[12],t[13]=e[13],t[14]=e[14],t[15]=e[15],t}function p(e,t){return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[4]=t[4],e[5]=t[5],e[6]=t[6],e[7]=t[7],e[8]=t[8],e[9]=t[9],e[10]=t[10],e[11]=t[11],e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15],e}function f(e,t,n,r,o,a,i,l,c,u,d,p,f,g,m,h){var v=new s(16);return v[0]=e,v[1]=t,v[2]=n,v[3]=r,v[4]=o,v[5]=a,v[6]=i,v[7]=l,v[8]=c,v[9]=u,v[10]=d,v[11]=p,v[12]=f,v[13]=g,v[14]=m,v[15]=h,v}function g(e,t,n,r,o,a,i,s,l,c,u,d,p,f,g,m,h){return e[0]=t,e[1]=n,e[2]=r,e[3]=o,e[4]=a,e[5]=i,e[6]=s,e[7]=l,e[8]=c,e[9]=u,e[10]=d,e[11]=p,e[12]=f,e[13]=g,e[14]=m,e[15]=h,e}function m(e){return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=1,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=1,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function h(e,t){if(e===t){var n=t[1],r=t[2],o=t[3],a=t[6],i=t[7],s=t[11];e[1]=t[4],e[2]=t[8],e[3]=t[12],e[4]=n,e[6]=t[9],e[7]=t[13],e[8]=r,e[9]=a,e[11]=t[14],e[12]=o,e[13]=i,e[14]=s}else e[0]=t[0],e[1]=t[4],e[2]=t[8],e[3]=t[12],e[4]=t[1],e[5]=t[5],e[6]=t[9],e[7]=t[13],e[8]=t[2],e[9]=t[6],e[10]=t[10],e[11]=t[14],e[12]=t[3],e[13]=t[7],e[14]=t[11],e[15]=t[15];return e}function v(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8],d=t[9],p=t[10],f=t[11],g=t[12],m=t[13],h=t[14],v=t[15],T=n*s-r*i,y=n*l-o*i,b=n*c-a*i,x=r*l-o*s,C=r*c-a*s,S=o*c-a*l,A=u*m-d*g,I=u*h-p*g,w=u*v-f*g,O=d*h-p*m,P=d*v-f*m,R=p*v-f*h,M=T*R-y*P+b*O+x*w-C*I+S*A;return M?(M=1/M,e[0]=(s*R-l*P+c*O)*M,e[1]=(o*P-r*R-a*O)*M,e[2]=(m*S-h*C+v*x)*M,e[3]=(p*C-d*S-f*x)*M,e[4]=(l*w-i*R-c*I)*M,e[5]=(n*R-o*w+a*I)*M,e[6]=(h*b-g*S-v*y)*M,e[7]=(u*S-p*b+f*y)*M,e[8]=(i*P-s*w+c*A)*M,e[9]=(r*w-n*P-a*A)*M,e[10]=(g*C-m*b+v*T)*M,e[11]=(d*b-u*C-f*T)*M,e[12]=(s*I-i*O-l*A)*M,e[13]=(n*O-r*I+o*A)*M,e[14]=(m*y-g*x-h*T)*M,e[15]=(u*x-d*y+p*T)*M,e):null}function T(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8],d=t[9],p=t[10],f=t[11],g=t[12],m=t[13],h=t[14],v=t[15];return e[0]=s*(p*v-f*h)-d*(l*v-c*h)+m*(l*f-c*p),e[1]=-(r*(p*v-f*h)-d*(o*v-a*h)+m*(o*f-a*p)),e[2]=r*(l*v-c*h)-s*(o*v-a*h)+m*(o*c-a*l),e[3]=-(r*(l*f-c*p)-s*(o*f-a*p)+d*(o*c-a*l)),e[4]=-(i*(p*v-f*h)-u*(l*v-c*h)+g*(l*f-c*p)),e[5]=n*(p*v-f*h)-u*(o*v-a*h)+g*(o*f-a*p),e[6]=-(n*(l*v-c*h)-i*(o*v-a*h)+g*(o*c-a*l)),e[7]=n*(l*f-c*p)-i*(o*f-a*p)+u*(o*c-a*l),e[8]=i*(d*v-f*m)-u*(s*v-c*m)+g*(s*f-c*d),e[9]=-(n*(d*v-f*m)-u*(r*v-a*m)+g*(r*f-a*d)),e[10]=n*(s*v-c*m)-i*(r*v-a*m)+g*(r*c-a*s),e[11]=-(n*(s*f-c*d)-i*(r*f-a*d)+u*(r*c-a*s)),e[12]=-(i*(d*h-p*m)-u*(s*h-l*m)+g*(s*p-l*d)),e[13]=n*(d*h-p*m)-u*(r*h-o*m)+g*(r*p-o*d),e[14]=-(n*(s*h-l*m)-i*(r*h-o*m)+g*(r*l-o*s)),e[15]=n*(s*p-l*d)-i*(r*p-o*d)+u*(r*l-o*s),e}function y(e){var t=e[0],n=e[1],r=e[2],o=e[3],a=e[4],i=e[5],s=e[6],l=e[7],c=e[8],u=e[9],d=e[10],p=e[11],f=e[12],g=e[13],m=e[14],h=e[15];return(t*i-n*a)*(d*h-p*m)-(t*s-r*a)*(u*h-p*g)+(t*l-o*a)*(u*m-d*g)+(n*s-r*i)*(c*h-p*f)-(n*l-o*i)*(c*m-d*f)+(r*l-o*s)*(c*g-u*f)}function b(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=t[9],f=t[10],g=t[11],m=t[12],h=t[13],v=t[14],T=t[15],y=n[0],b=n[1],x=n[2],C=n[3];return e[0]=y*r+b*s+x*d+C*m,e[1]=y*o+b*l+x*p+C*h,e[2]=y*a+b*c+x*f+C*v,e[3]=y*i+b*u+x*g+C*T,y=n[4],b=n[5],x=n[6],C=n[7],e[4]=y*r+b*s+x*d+C*m,e[5]=y*o+b*l+x*p+C*h,e[6]=y*a+b*c+x*f+C*v,e[7]=y*i+b*u+x*g+C*T,y=n[8],b=n[9],x=n[10],C=n[11],e[8]=y*r+b*s+x*d+C*m,e[9]=y*o+b*l+x*p+C*h,e[10]=y*a+b*c+x*f+C*v,e[11]=y*i+b*u+x*g+C*T,y=n[12],b=n[13],x=n[14],C=n[15],e[12]=y*r+b*s+x*d+C*m,e[13]=y*o+b*l+x*p+C*h,e[14]=y*a+b*c+x*f+C*v,e[15]=y*i+b*u+x*g+C*T,e}function x(e,t,n){var r,o,a,i,s,l,c,u,d,p,f,g,m=n[0],h=n[1],v=n[2];return t===e?(e[12]=t[0]*m+t[4]*h+t[8]*v+t[12],e[13]=t[1]*m+t[5]*h+t[9]*v+t[13],e[14]=t[2]*m+t[6]*h+t[10]*v+t[14],e[15]=t[3]*m+t[7]*h+t[11]*v+t[15]):(r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=t[9],f=t[10],g=t[11],e[0]=r,e[1]=o,e[2]=a,e[3]=i,e[4]=s,e[5]=l,e[6]=c,e[7]=u,e[8]=d,e[9]=p,e[10]=f,e[11]=g,e[12]=r*m+s*h+d*v+t[12],e[13]=o*m+l*h+p*v+t[13],e[14]=a*m+c*h+f*v+t[14],e[15]=i*m+u*h+g*v+t[15]),e}function C(e,t,n){var r=n[0],o=n[1],a=n[2];return e[0]=t[0]*r,e[1]=t[1]*r,e[2]=t[2]*r,e[3]=t[3]*r,e[4]=t[4]*o,e[5]=t[5]*o,e[6]=t[6]*o,e[7]=t[7]*o,e[8]=t[8]*a,e[9]=t[9]*a,e[10]=t[10]*a,e[11]=t[11]*a,e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15],e}function S(e,t,n,r){var o,a,s,l,c,u,d,p,f,g,m,h,v,T,y,b,x,C,S,A,I,w,O,P,R=r[0],M=r[1],E=r[2],V=Math.hypot(R,M,E);return V<i?null:(R*=V=1/V,M*=V,E*=V,o=Math.sin(n),s=1-(a=Math.cos(n)),l=t[0],c=t[1],u=t[2],d=t[3],p=t[4],f=t[5],g=t[6],m=t[7],h=t[8],v=t[9],T=t[10],y=t[11],b=R*R*s+a,x=M*R*s+E*o,C=E*R*s-M*o,S=R*M*s-E*o,A=M*M*s+a,I=E*M*s+R*o,w=R*E*s+M*o,O=M*E*s-R*o,P=E*E*s+a,e[0]=l*b+p*x+h*C,e[1]=c*b+f*x+v*C,e[2]=u*b+g*x+T*C,e[3]=d*b+m*x+y*C,e[4]=l*S+p*A+h*I,e[5]=c*S+f*A+v*I,e[6]=u*S+g*A+T*I,e[7]=d*S+m*A+y*I,e[8]=l*w+p*O+h*P,e[9]=c*w+f*O+v*P,e[10]=u*w+g*O+T*P,e[11]=d*w+m*O+y*P,t!==e&&(e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15]),e)}function A(e,t,n){var r=Math.sin(n),o=Math.cos(n),a=t[4],i=t[5],s=t[6],l=t[7],c=t[8],u=t[9],d=t[10],p=t[11];return t!==e&&(e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15]),e[4]=a*o+c*r,e[5]=i*o+u*r,e[6]=s*o+d*r,e[7]=l*o+p*r,e[8]=c*o-a*r,e[9]=u*o-i*r,e[10]=d*o-s*r,e[11]=p*o-l*r,e}function I(e,t,n){var r=Math.sin(n),o=Math.cos(n),a=t[0],i=t[1],s=t[2],l=t[3],c=t[8],u=t[9],d=t[10],p=t[11];return t!==e&&(e[4]=t[4],e[5]=t[5],e[6]=t[6],e[7]=t[7],e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15]),e[0]=a*o-c*r,e[1]=i*o-u*r,e[2]=s*o-d*r,e[3]=l*o-p*r,e[8]=a*r+c*o,e[9]=i*r+u*o,e[10]=s*r+d*o,e[11]=l*r+p*o,e}function w(e,t,n){var r=Math.sin(n),o=Math.cos(n),a=t[0],i=t[1],s=t[2],l=t[3],c=t[4],u=t[5],d=t[6],p=t[7];return t!==e&&(e[8]=t[8],e[9]=t[9],e[10]=t[10],e[11]=t[11],e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15]),e[0]=a*o+c*r,e[1]=i*o+u*r,e[2]=s*o+d*r,e[3]=l*o+p*r,e[4]=c*o-a*r,e[5]=u*o-i*r,e[6]=d*o-s*r,e[7]=p*o-l*r,e}function O(e,t){return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=1,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=1,e[11]=0,e[12]=t[0],e[13]=t[1],e[14]=t[2],e[15]=1,e}function P(e,t){return e[0]=t[0],e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=t[1],e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=t[2],e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function R(e,t,n){var r,o,a,s=n[0],l=n[1],c=n[2],u=Math.hypot(s,l,c);return u<i?null:(s*=u=1/u,l*=u,c*=u,r=Math.sin(t),a=1-(o=Math.cos(t)),e[0]=s*s*a+o,e[1]=l*s*a+c*r,e[2]=c*s*a-l*r,e[3]=0,e[4]=s*l*a-c*r,e[5]=l*l*a+o,e[6]=c*l*a+s*r,e[7]=0,e[8]=s*c*a+l*r,e[9]=l*c*a-s*r,e[10]=c*c*a+o,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e)}function M(e,t){var n=Math.sin(t),r=Math.cos(t);return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=r,e[6]=n,e[7]=0,e[8]=0,e[9]=-n,e[10]=r,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function E(e,t){var n=Math.sin(t),r=Math.cos(t);return e[0]=r,e[1]=0,e[2]=-n,e[3]=0,e[4]=0,e[5]=1,e[6]=0,e[7]=0,e[8]=n,e[9]=0,e[10]=r,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function V(e,t){var n=Math.sin(t),r=Math.cos(t);return e[0]=r,e[1]=n,e[2]=0,e[3]=0,e[4]=-n,e[5]=r,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=1,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function D(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=r+r,l=o+o,c=a+a,u=r*s,d=r*l,p=r*c,f=o*l,g=o*c,m=a*c,h=i*s,v=i*l,T=i*c;return e[0]=1-(f+m),e[1]=d+T,e[2]=p-v,e[3]=0,e[4]=d-T,e[5]=1-(u+m),e[6]=g+h,e[7]=0,e[8]=p+v,e[9]=g-h,e[10]=1-(u+f),e[11]=0,e[12]=n[0],e[13]=n[1],e[14]=n[2],e[15]=1,e}function L(e,t){var n=new s(3),r=-t[0],o=-t[1],a=-t[2],i=t[3],l=t[4],c=t[5],u=t[6],d=t[7],p=r*r+o*o+a*a+i*i;return p>0?(n[0]=2*(l*i+d*r+c*a-u*o)/p,n[1]=2*(c*i+d*o+u*r-l*a)/p,n[2]=2*(u*i+d*a+l*o-c*r)/p):(n[0]=2*(l*i+d*r+c*a-u*o),n[1]=2*(c*i+d*o+u*r-l*a),n[2]=2*(u*i+d*a+l*o-c*r)),D(e,t,n),e}function B(e,t){return e[0]=t[12],e[1]=t[13],e[2]=t[14],e}function N(e,t){var n=t[0],r=t[1],o=t[2],a=t[4],i=t[5],s=t[6],l=t[8],c=t[9],u=t[10];return e[0]=Math.hypot(n,r,o),e[1]=Math.hypot(a,i,s),e[2]=Math.hypot(l,c,u),e}function F(e,t){var n=new s(3);N(n,t);var r=1/n[0],o=1/n[1],a=1/n[2],i=t[0]*r,l=t[1]*o,c=t[2]*a,u=t[4]*r,d=t[5]*o,p=t[6]*a,f=t[8]*r,g=t[9]*o,m=t[10]*a,h=i+d+m,v=0;return h>0?(v=2*Math.sqrt(h+1),e[3]=.25*v,e[0]=(p-g)/v,e[1]=(f-c)/v,e[2]=(l-u)/v):i>d&&i>m?(v=2*Math.sqrt(1+i-d-m),e[3]=(p-g)/v,e[0]=.25*v,e[1]=(l+u)/v,e[2]=(f+c)/v):d>m?(v=2*Math.sqrt(1+d-i-m),e[3]=(f-c)/v,e[0]=(l+u)/v,e[1]=.25*v,e[2]=(p+g)/v):(v=2*Math.sqrt(1+m-i-d),e[3]=(l-u)/v,e[0]=(f+c)/v,e[1]=(p+g)/v,e[2]=.25*v),e}function _(e,t,n,r){var o=t[0],a=t[1],i=t[2],s=t[3],l=o+o,c=a+a,u=i+i,d=o*l,p=o*c,f=o*u,g=a*c,m=a*u,h=i*u,v=s*l,T=s*c,y=s*u,b=r[0],x=r[1],C=r[2];return e[0]=(1-(g+h))*b,e[1]=(p+y)*b,e[2]=(f-T)*b,e[3]=0,e[4]=(p-y)*x,e[5]=(1-(d+h))*x,e[6]=(m+v)*x,e[7]=0,e[8]=(f+T)*C,e[9]=(m-v)*C,e[10]=(1-(d+g))*C,e[11]=0,e[12]=n[0],e[13]=n[1],e[14]=n[2],e[15]=1,e}function k(e,t,n,r,o){var a=t[0],i=t[1],s=t[2],l=t[3],c=a+a,u=i+i,d=s+s,p=a*c,f=a*u,g=a*d,m=i*u,h=i*d,v=s*d,T=l*c,y=l*u,b=l*d,x=r[0],C=r[1],S=r[2],A=o[0],I=o[1],w=o[2],O=(1-(m+v))*x,P=(f+b)*x,R=(g-y)*x,M=(f-b)*C,E=(1-(p+v))*C,V=(h+T)*C,D=(g+y)*S,L=(h-T)*S,B=(1-(p+m))*S;return e[0]=O,e[1]=P,e[2]=R,e[3]=0,e[4]=M,e[5]=E,e[6]=V,e[7]=0,e[8]=D,e[9]=L,e[10]=B,e[11]=0,e[12]=n[0]+A-(O*A+M*I+D*w),e[13]=n[1]+I-(P*A+E*I+L*w),e[14]=n[2]+w-(R*A+V*I+B*w),e[15]=1,e}function G(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=n+n,s=r+r,l=o+o,c=n*i,u=r*i,d=r*s,p=o*i,f=o*s,g=o*l,m=a*i,h=a*s,v=a*l;return e[0]=1-d-g,e[1]=u+v,e[2]=p-h,e[3]=0,e[4]=u-v,e[5]=1-c-g,e[6]=f+m,e[7]=0,e[8]=p+h,e[9]=f-m,e[10]=1-c-d,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function U(e,t,n,r,o,a,i){var s=1/(n-t),l=1/(o-r),c=1/(a-i);return e[0]=2*a*s,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=2*a*l,e[6]=0,e[7]=0,e[8]=(n+t)*s,e[9]=(o+r)*l,e[10]=(i+a)*c,e[11]=-1,e[12]=0,e[13]=0,e[14]=i*a*2*c,e[15]=0,e}function z(e,t,n,r,o){var a,i=1/Math.tan(t/2);return e[0]=i/n,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=i,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[11]=-1,e[12]=0,e[13]=0,e[15]=0,null!=o&&o!==1/0?(a=1/(r-o),e[10]=(o+r)*a,e[14]=2*o*r*a):(e[10]=-1,e[14]=-2*r),e}Math.hypot||(Math.hypot=function(){for(var e=0,t=arguments.length;t--;)e+=arguments[t]*arguments[t];return Math.sqrt(e)});var W=z;function H(e,t,n,r,o){var a,i=1/Math.tan(t/2);return e[0]=i/n,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=i,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[11]=-1,e[12]=0,e[13]=0,e[15]=0,null!=o&&o!==1/0?(a=1/(r-o),e[10]=o*a,e[14]=o*r*a):(e[10]=-1,e[14]=-r),e}function j(e,t,n,r){var o=Math.tan(t.upDegrees*Math.PI/180),a=Math.tan(t.downDegrees*Math.PI/180),i=Math.tan(t.leftDegrees*Math.PI/180),s=Math.tan(t.rightDegrees*Math.PI/180),l=2/(i+s),c=2/(o+a);return e[0]=l,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=c,e[6]=0,e[7]=0,e[8]=-(i-s)*l*.5,e[9]=(o-a)*c*.5,e[10]=r/(n-r),e[11]=-1,e[12]=0,e[13]=0,e[14]=r*n/(n-r),e[15]=0,e}function K(e,t,n,r,o,a,i){var s=1/(t-n),l=1/(r-o),c=1/(a-i);return e[0]=-2*s,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=-2*l,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=2*c,e[11]=0,e[12]=(t+n)*s,e[13]=(o+r)*l,e[14]=(i+a)*c,e[15]=1,e}var $=K;function q(e,t,n,r,o,a,i){var s=1/(t-n),l=1/(r-o),c=1/(a-i);return e[0]=-2*s,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=-2*l,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=c,e[11]=0,e[12]=(t+n)*s,e[13]=(o+r)*l,e[14]=a*c,e[15]=1,e}function X(e,t,n,r){var o,a,s,l,c,u,d,p,f,g,h=t[0],v=t[1],T=t[2],y=r[0],b=r[1],x=r[2],C=n[0],S=n[1],A=n[2];return Math.abs(h-C)<i&&Math.abs(v-S)<i&&Math.abs(T-A)<i?m(e):(d=h-C,p=v-S,f=T-A,o=b*(f*=g=1/Math.hypot(d,p,f))-x*(p*=g),a=x*(d*=g)-y*f,s=y*p-b*d,(g=Math.hypot(o,a,s))?(o*=g=1/g,a*=g,s*=g):(o=0,a=0,s=0),l=p*s-f*a,c=f*o-d*s,u=d*a-p*o,(g=Math.hypot(l,c,u))?(l*=g=1/g,c*=g,u*=g):(l=0,c=0,u=0),e[0]=o,e[1]=l,e[2]=d,e[3]=0,e[4]=a,e[5]=c,e[6]=p,e[7]=0,e[8]=s,e[9]=u,e[10]=f,e[11]=0,e[12]=-(o*h+a*v+s*T),e[13]=-(l*h+c*v+u*T),e[14]=-(d*h+p*v+f*T),e[15]=1,e)}function Y(e,t,n,r){var o=t[0],a=t[1],i=t[2],s=r[0],l=r[1],c=r[2],u=o-n[0],d=a-n[1],p=i-n[2],f=u*u+d*d+p*p;f>0&&(u*=f=1/Math.sqrt(f),d*=f,p*=f);var g=l*p-c*d,m=c*u-s*p,h=s*d-l*u;return(f=g*g+m*m+h*h)>0&&(g*=f=1/Math.sqrt(f),m*=f,h*=f),e[0]=g,e[1]=m,e[2]=h,e[3]=0,e[4]=d*h-p*m,e[5]=p*g-u*h,e[6]=u*m-d*g,e[7]=0,e[8]=u,e[9]=d,e[10]=p,e[11]=0,e[12]=o,e[13]=a,e[14]=i,e[15]=1,e}function Z(e){return&quot;mat4(&quot;+e[0]+&quot;, &quot;+e[1]+&quot;, &quot;+e[2]+&quot;, &quot;+e[3]+&quot;, &quot;+e[4]+&quot;, &quot;+e[5]+&quot;, &quot;+e[6]+&quot;, &quot;+e[7]+&quot;, &quot;+e[8]+&quot;, &quot;+e[9]+&quot;, &quot;+e[10]+&quot;, &quot;+e[11]+&quot;, &quot;+e[12]+&quot;, &quot;+e[13]+&quot;, &quot;+e[14]+&quot;, &quot;+e[15]+&quot;)&quot;}function Q(e){return Math.hypot(e[0],e[1],e[2],e[3],e[4],e[5],e[6],e[7],e[8],e[9],e[10],e[11],e[12],e[13],e[14],e[15])}function J(e,t,n){return e[0]=t[0]+n[0],e[1]=t[1]+n[1],e[2]=t[2]+n[2],e[3]=t[3]+n[3],e[4]=t[4]+n[4],e[5]=t[5]+n[5],e[6]=t[6]+n[6],e[7]=t[7]+n[7],e[8]=t[8]+n[8],e[9]=t[9]+n[9],e[10]=t[10]+n[10],e[11]=t[11]+n[11],e[12]=t[12]+n[12],e[13]=t[13]+n[13],e[14]=t[14]+n[14],e[15]=t[15]+n[15],e}function ee(e,t,n){return e[0]=t[0]-n[0],e[1]=t[1]-n[1],e[2]=t[2]-n[2],e[3]=t[3]-n[3],e[4]=t[4]-n[4],e[5]=t[5]-n[5],e[6]=t[6]-n[6],e[7]=t[7]-n[7],e[8]=t[8]-n[8],e[9]=t[9]-n[9],e[10]=t[10]-n[10],e[11]=t[11]-n[11],e[12]=t[12]-n[12],e[13]=t[13]-n[13],e[14]=t[14]-n[14],e[15]=t[15]-n[15],e}function te(e,t,n){return e[0]=t[0]*n,e[1]=t[1]*n,e[2]=t[2]*n,e[3]=t[3]*n,e[4]=t[4]*n,e[5]=t[5]*n,e[6]=t[6]*n,e[7]=t[7]*n,e[8]=t[8]*n,e[9]=t[9]*n,e[10]=t[10]*n,e[11]=t[11]*n,e[12]=t[12]*n,e[13]=t[13]*n,e[14]=t[14]*n,e[15]=t[15]*n,e}function ne(e,t,n,r){return e[0]=t[0]+n[0]*r,e[1]=t[1]+n[1]*r,e[2]=t[2]+n[2]*r,e[3]=t[3]+n[3]*r,e[4]=t[4]+n[4]*r,e[5]=t[5]+n[5]*r,e[6]=t[6]+n[6]*r,e[7]=t[7]+n[7]*r,e[8]=t[8]+n[8]*r,e[9]=t[9]+n[9]*r,e[10]=t[10]+n[10]*r,e[11]=t[11]+n[11]*r,e[12]=t[12]+n[12]*r,e[13]=t[13]+n[13]*r,e[14]=t[14]+n[14]*r,e[15]=t[15]+n[15]*r,e}function re(e,t){return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]&&e[3]===t[3]&&e[4]===t[4]&&e[5]===t[5]&&e[6]===t[6]&&e[7]===t[7]&&e[8]===t[8]&&e[9]===t[9]&&e[10]===t[10]&&e[11]===t[11]&&e[12]===t[12]&&e[13]===t[13]&&e[14]===t[14]&&e[15]===t[15]}function oe(e,t){var n=e[0],r=e[1],o=e[2],a=e[3],s=e[4],l=e[5],c=e[6],u=e[7],d=e[8],p=e[9],f=e[10],g=e[11],m=e[12],h=e[13],v=e[14],T=e[15],y=t[0],b=t[1],x=t[2],C=t[3],S=t[4],A=t[5],I=t[6],w=t[7],O=t[8],P=t[9],R=t[10],M=t[11],E=t[12],V=t[13],D=t[14],L=t[15];return Math.abs(n-y)<=i*Math.max(1,Math.abs(n),Math.abs(y))&&Math.abs(r-b)<=i*Math.max(1,Math.abs(r),Math.abs(b))&&Math.abs(o-x)<=i*Math.max(1,Math.abs(o),Math.abs(x))&&Math.abs(a-C)<=i*Math.max(1,Math.abs(a),Math.abs(C))&&Math.abs(s-S)<=i*Math.max(1,Math.abs(s),Math.abs(S))&&Math.abs(l-A)<=i*Math.max(1,Math.abs(l),Math.abs(A))&&Math.abs(c-I)<=i*Math.max(1,Math.abs(c),Math.abs(I))&&Math.abs(u-w)<=i*Math.max(1,Math.abs(u),Math.abs(w))&&Math.abs(d-O)<=i*Math.max(1,Math.abs(d),Math.abs(O))&&Math.abs(p-P)<=i*Math.max(1,Math.abs(p),Math.abs(P))&&Math.abs(f-R)<=i*Math.max(1,Math.abs(f),Math.abs(R))&&Math.abs(g-M)<=i*Math.max(1,Math.abs(g),Math.abs(M))&&Math.abs(m-E)<=i*Math.max(1,Math.abs(m),Math.abs(E))&&Math.abs(h-V)<=i*Math.max(1,Math.abs(h),Math.abs(V))&&Math.abs(v-D)<=i*Math.max(1,Math.abs(v),Math.abs(D))&&Math.abs(T-L)<=i*Math.max(1,Math.abs(T),Math.abs(L))}var ae=b,ie=ee;function se(){var e=new s(9);return s!=Float32Array&&(e[1]=0,e[2]=0,e[3]=0,e[5]=0,e[6]=0,e[7]=0),e[0]=1,e[4]=1,e[8]=1,e}function le(e,t){return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[4],e[4]=t[5],e[5]=t[6],e[6]=t[8],e[7]=t[9],e[8]=t[10],e}function ce(e){var t=new s(9);return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t[4]=e[4],t[5]=e[5],t[6]=e[6],t[7]=e[7],t[8]=e[8],t}function ue(e,t){return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[4]=t[4],e[5]=t[5],e[6]=t[6],e[7]=t[7],e[8]=t[8],e}function de(e,t,n,r,o,a,i,l,c){var u=new s(9);return u[0]=e,u[1]=t,u[2]=n,u[3]=r,u[4]=o,u[5]=a,u[6]=i,u[7]=l,u[8]=c,u}function pe(e,t,n,r,o,a,i,s,l,c){return e[0]=t,e[1]=n,e[2]=r,e[3]=o,e[4]=a,e[5]=i,e[6]=s,e[7]=l,e[8]=c,e}function fe(e){return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=1,e[5]=0,e[6]=0,e[7]=0,e[8]=1,e}function ge(e,t){if(e===t){var n=t[1],r=t[2],o=t[5];e[1]=t[3],e[2]=t[6],e[3]=n,e[5]=t[7],e[6]=r,e[7]=o}else e[0]=t[0],e[1]=t[3],e[2]=t[6],e[3]=t[1],e[4]=t[4],e[5]=t[7],e[6]=t[2],e[7]=t[5],e[8]=t[8];return e}function me(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8],d=u*i-s*c,p=-u*a+s*l,f=c*a-i*l,g=n*d+r*p+o*f;return g?(g=1/g,e[0]=d*g,e[1]=(-u*r+o*c)*g,e[2]=(s*r-o*i)*g,e[3]=p*g,e[4]=(u*n-o*l)*g,e[5]=(-s*n+o*a)*g,e[6]=f*g,e[7]=(-c*n+r*l)*g,e[8]=(i*n-r*a)*g,e):null}function he(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8];return e[0]=i*u-s*c,e[1]=o*c-r*u,e[2]=r*s-o*i,e[3]=s*l-a*u,e[4]=n*u-o*l,e[5]=o*a-n*s,e[6]=a*c-i*l,e[7]=r*l-n*c,e[8]=n*i-r*a,e}function ve(e){var t=e[0],n=e[1],r=e[2],o=e[3],a=e[4],i=e[5],s=e[6],l=e[7],c=e[8];return t*(c*a-i*l)+n*(-c*o+i*s)+r*(l*o-a*s)}function Te(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=n[0],f=n[1],g=n[2],m=n[3],h=n[4],v=n[5],T=n[6],y=n[7],b=n[8];return e[0]=p*r+f*i+g*c,e[1]=p*o+f*s+g*u,e[2]=p*a+f*l+g*d,e[3]=m*r+h*i+v*c,e[4]=m*o+h*s+v*u,e[5]=m*a+h*l+v*d,e[6]=T*r+y*i+b*c,e[7]=T*o+y*s+b*u,e[8]=T*a+y*l+b*d,e}function ye(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=n[0],f=n[1];return e[0]=r,e[1]=o,e[2]=a,e[3]=i,e[4]=s,e[5]=l,e[6]=p*r+f*i+c,e[7]=p*o+f*s+u,e[8]=p*a+f*l+d,e}function be(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=Math.sin(n),f=Math.cos(n);return e[0]=f*r+p*i,e[1]=f*o+p*s,e[2]=f*a+p*l,e[3]=f*i-p*r,e[4]=f*s-p*o,e[5]=f*l-p*a,e[6]=c,e[7]=u,e[8]=d,e}function xe(e,t,n){var r=n[0],o=n[1];return e[0]=r*t[0],e[1]=r*t[1],e[2]=r*t[2],e[3]=o*t[3],e[4]=o*t[4],e[5]=o*t[5],e[6]=t[6],e[7]=t[7],e[8]=t[8],e}function Ce(e,t){return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=1,e[5]=0,e[6]=t[0],e[7]=t[1],e[8]=1,e}function Se(e,t){var n=Math.sin(t),r=Math.cos(t);return e[0]=r,e[1]=n,e[2]=0,e[3]=-n,e[4]=r,e[5]=0,e[6]=0,e[7]=0,e[8]=1,e}function Ae(e,t){return e[0]=t[0],e[1]=0,e[2]=0,e[3]=0,e[4]=t[1],e[5]=0,e[6]=0,e[7]=0,e[8]=1,e}function Ie(e,t){return e[0]=t[0],e[1]=t[1],e[2]=0,e[3]=t[2],e[4]=t[3],e[5]=0,e[6]=t[4],e[7]=t[5],e[8]=1,e}function we(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=n+n,s=r+r,l=o+o,c=n*i,u=r*i,d=r*s,p=o*i,f=o*s,g=o*l,m=a*i,h=a*s,v=a*l;return e[0]=1-d-g,e[3]=u-v,e[6]=p+h,e[1]=u+v,e[4]=1-c-g,e[7]=f-m,e[2]=p-h,e[5]=f+m,e[8]=1-c-d,e}function Oe(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8],d=t[9],p=t[10],f=t[11],g=t[12],m=t[13],h=t[14],v=t[15],T=n*s-r*i,y=n*l-o*i,b=n*c-a*i,x=r*l-o*s,C=r*c-a*s,S=o*c-a*l,A=u*m-d*g,I=u*h-p*g,w=u*v-f*g,O=d*h-p*m,P=d*v-f*m,R=p*v-f*h,M=T*R-y*P+b*O+x*w-C*I+S*A;return M?(M=1/M,e[0]=(s*R-l*P+c*O)*M,e[1]=(l*w-i*R-c*I)*M,e[2]=(i*P-s*w+c*A)*M,e[3]=(o*P-r*R-a*O)*M,e[4]=(n*R-o*w+a*I)*M,e[5]=(r*w-n*P-a*A)*M,e[6]=(m*S-h*C+v*x)*M,e[7]=(h*b-g*S-v*y)*M,e[8]=(g*C-m*b+v*T)*M,e):null}function Pe(e,t,n){return e[0]=2/t,e[1]=0,e[2]=0,e[3]=0,e[4]=-2/n,e[5]=0,e[6]=-1,e[7]=1,e[8]=1,e}function Re(e){return&quot;mat3(&quot;+e[0]+&quot;, &quot;+e[1]+&quot;, &quot;+e[2]+&quot;, &quot;+e[3]+&quot;, &quot;+e[4]+&quot;, &quot;+e[5]+&quot;, &quot;+e[6]+&quot;, &quot;+e[7]+&quot;, &quot;+e[8]+&quot;)&quot;}function Me(e){return Math.hypot(e[0],e[1],e[2],e[3],e[4],e[5],e[6],e[7],e[8])}function Ee(e,t,n){return e[0]=t[0]+n[0],e[1]=t[1]+n[1],e[2]=t[2]+n[2],e[3]=t[3]+n[3],e[4]=t[4]+n[4],e[5]=t[5]+n[5],e[6]=t[6]+n[6],e[7]=t[7]+n[7],e[8]=t[8]+n[8],e}function Ve(e,t,n){return e[0]=t[0]-n[0],e[1]=t[1]-n[1],e[2]=t[2]-n[2],e[3]=t[3]-n[3],e[4]=t[4]-n[4],e[5]=t[5]-n[5],e[6]=t[6]-n[6],e[7]=t[7]-n[7],e[8]=t[8]-n[8],e}function De(e,t,n){return e[0]=t[0]*n,e[1]=t[1]*n,e[2]=t[2]*n,e[3]=t[3]*n,e[4]=t[4]*n,e[5]=t[5]*n,e[6]=t[6]*n,e[7]=t[7]*n,e[8]=t[8]*n,e}function Le(e,t,n,r){return e[0]=t[0]+n[0]*r,e[1]=t[1]+n[1]*r,e[2]=t[2]+n[2]*r,e[3]=t[3]+n[3]*r,e[4]=t[4]+n[4]*r,e[5]=t[5]+n[5]*r,e[6]=t[6]+n[6]*r,e[7]=t[7]+n[7]*r,e[8]=t[8]+n[8]*r,e}function Be(e,t){return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]&&e[3]===t[3]&&e[4]===t[4]&&e[5]===t[5]&&e[6]===t[6]&&e[7]===t[7]&&e[8]===t[8]}function Ne(e,t){var n=e[0],r=e[1],o=e[2],a=e[3],s=e[4],l=e[5],c=e[6],u=e[7],d=e[8],p=t[0],f=t[1],g=t[2],m=t[3],h=t[4],v=t[5],T=t[6],y=t[7],b=t[8];return Math.abs(n-p)<=i*Math.max(1,Math.abs(n),Math.abs(p))&&Math.abs(r-f)<=i*Math.max(1,Math.abs(r),Math.abs(f))&&Math.abs(o-g)<=i*Math.max(1,Math.abs(o),Math.abs(g))&&Math.abs(a-m)<=i*Math.max(1,Math.abs(a),Math.abs(m))&&Math.abs(s-h)<=i*Math.max(1,Math.abs(s),Math.abs(h))&&Math.abs(l-v)<=i*Math.max(1,Math.abs(l),Math.abs(v))&&Math.abs(c-T)<=i*Math.max(1,Math.abs(c),Math.abs(T))&&Math.abs(u-y)<=i*Math.max(1,Math.abs(u),Math.abs(y))&&Math.abs(d-b)<=i*Math.max(1,Math.abs(d),Math.abs(b))}var Fe=Te,_e=Ve,ke=n(730);const Ge=n(59)(),Ue={vtkObject:()=>null};function ze(e){if(null==e)return e;if(e.isA)return e;if(!e.vtkClass)return Ge.console&&Ge.console.error&&Ge.console.error(&quot;Invalid VTK object&quot;),null;const t=Ue[e.vtkClass];if(!t)return Ge.console&&Ge.console.error&&Ge.console.error(`No vtk class found for Object of type ${e.vtkClass}`),null;const n={...e};Object.keys(n).forEach((e=>{n[e]&&&quot;object&quot;==typeof n[e]&&n[e].vtkClass&&(n[e]=ze(n[e]))}));const r=t(n);return r&&r.modified&&r.modified(),r}ze.register=function(e,t){Ue[e]=t};class We extends Array{push(){for(let e=0;e<arguments.length;e++)this.includes(arguments[e])||super.push(arguments[e]);return this.length}}let He=0;const je=e=>{throw new Error(`Named parameter '${e}' is missing`)},Ke=Symbol(&quot;void&quot;),$e={};function qe(){}[&quot;log&quot;,&quot;debug&quot;,&quot;info&quot;,&quot;warn&quot;,&quot;error&quot;,&quot;time&quot;,&quot;timeEnd&quot;,&quot;group&quot;,&quot;groupEnd&quot;].forEach((e=>{$e[e]=qe})),Ge.console=console.hasOwnProperty(&quot;log&quot;)?console:$e;const Xe={debug:qe,error:Ge.console.error||qe,info:Ge.console.info||qe,log:Ge.console.log||qe,warn:Ge.console.warn||qe};function Ye(e,t){Xe[e]&&(Xe[e]=t||qe)}function Ze(){Xe.log(...arguments)}function Qe(){Xe.info(...arguments)}function Je(){Xe.debug(...arguments)}function et(){Xe.error(...arguments)}function tt(){Xe.warn(...arguments)}const nt={};function rt(e){nt[e]||(Xe.error(e),nt[e]=!0)}const ot=Object.create(null);ot.Float32Array=Float32Array,ot.Float64Array=Float64Array,ot.Uint8Array=Uint8Array,ot.Int8Array=Int8Array,ot.Uint16Array=Uint16Array,ot.Int16Array=Int16Array,ot.Uint32Array=Uint32Array,ot.Int32Array=Int32Array,ot.Uint8ClampedArray=Uint8ClampedArray;try{ot.BigInt64Array=BigInt64Array,ot.BigUint64Array=BigUint64Array}catch{}function at(e){for(var t=arguments.length,n=new Array(t>1?t-1:0),r=1;r<t;r++)n[r-1]=arguments[r];return new(ot[e]||Float64Array)(...n)}function it(e){for(var t=arguments.length,n=new Array(t>1?t-1:0),r=1;r<t;r++)n[r-1]=arguments[r];return(ot[e]||Float64Array).from(...n)}function st(e){return e.charAt(0).toUpperCase()+e.slice(1)}function lt(e){return st(&quot;_&quot;===e[0]?e.slice(1):e)}function ct(e){return e.charAt(0).toLowerCase()+e.slice(1)}function ut(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:2,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1e3;const r=[&quot;TB&quot;,&quot;GB&quot;,&quot;MB&quot;,&quot;KB&quot;];let o=Number(e),a=&quot;B&quot;;for(;o>n;)o/=n,a=r.pop();return`${o.toFixed(t)} ${a}`}function dt(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:&quot; &quot;;const n=[];let r=e;for(;r>1e3;)n.push((&quot;000&quot;+r%1e3).slice(-3)),r=Math.floor(r/1e3);return r>0&&n.push(r),n.reverse(),n.join(t)}function pt(e){Object.keys(e).forEach((t=>{Array.isArray(e[t])&&(e[t]=[].concat(e[t]))}))}function ft(e){return e&&e.isA?e.getState():e}function gt(e){setTimeout(e,0)}function mt(e,t){const n=performance.now();e.finally((()=>{const e=performance.now()-n;t(e)}))}function ht(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};pt(t);const n=[];if(Number.isInteger(t.mtime)||(t.mtime=++He),&quot;classHierarchy&quot;in t){if(!(t.classHierarchy instanceof We)){const e=new We;for(let n=0;n<t.classHierarchy.length;n++)e.push(t.classHierarchy[n]);t.classHierarchy=e}}else t.classHierarchy=new We(&quot;vtkObject&quot;);function r(e){n[e]=null}return e.isDeleted=()=>!!t.deleted,e.modified=r=>{t.deleted?et(&quot;instance deleted - cannot call any method&quot;):r&&r<e.getMTime()||(t.mtime=++He,n.forEach((t=>t&&t(e))))},e.onModified=e=>{if(t.deleted)return et(&quot;instance deleted - cannot call any method&quot;),null;const o=n.length;return n.push(e),function(e){return Object.freeze({unsubscribe:function(){r(e)}})}(o)},e.getMTime=()=>t.mtime,e.isA=e=>{let n=t.classHierarchy.length;for(;n--;)if(t.classHierarchy[n]===e)return!0;return!1},e.getClassName=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.classHierarchy[t.classHierarchy.length-1-e]},e.set=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1&&void 0!==arguments[1]&&arguments[1],o=arguments.length>2&&void 0!==arguments[2]&&arguments[2],a=!1;return Object.keys(n).forEach((i=>{const s=o?null:e[`set${st(i)}`];s&&Array.isArray(n[i])&&s.length>1?a=s(...n[i])||a:s?a=s(n[i])||a:(-1!==[&quot;mtime&quot;].indexOf(i)||r||tt(`Warning: Set value to model directly ${i}, ${n[i]}`),a=t[i]!==n[i]||a,t[i]=n[i])})),a},e.get=function(){for(var e=arguments.length,n=new Array(e),r=0;r<e;r++)n[r]=arguments[r];if(!n.length)return t;const o={};return n.forEach((e=>{o[e]=t[e]})),o},e.getReferenceByName=e=>t[e],e.delete=()=>{Object.keys(t).forEach((e=>delete t[e])),n.forEach(((e,t)=>r(t))),t.deleted=!0},e.getState=()=>{if(t.deleted)return null;const n={...t,vtkClass:e.getClassName()};Object.keys(n).forEach((e=>{null===n[e]||void 0===n[e]||&quot;_&quot;===e[0]?delete n[e]:n[e].isA?n[e]=n[e].getState():Array.isArray(n[e])?n[e]=n[e].map(ft):function(e){return Object.values(ot).some((t=>e instanceof t))}(n[e])&&(n[e]=Array.from(n[e]))}));const r={};return Object.keys(n).sort().forEach((e=>{r[e]=n[e]})),r.mtime&&delete r.mtime,r},e.shallowCopy=function(n){let r=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(n.getClassName()!==e.getClassName())throw new Error(`Cannot ShallowCopy ${n.getClassName()} into ${e.getClassName()}`);const o=n.get(),a=Object.keys(t).sort();Object.keys(o).sort().forEach((e=>{const n=a.indexOf(e);-1===n?r&&Je(`add ${e} in shallowCopy`):a.splice(n,1),t[e]=o[e]})),a.length&&r&&Je(`Untouched keys: ${a.join(&quot;, &quot;)}`),e.modified()},e.toJSON=function(){return e.getState()},e}const vt={object(e,t,n){return function(){return{...t[n.name]}}}};function Tt(e,t,n){n.forEach((n=>{if(&quot;object&quot;==typeof n){const r=vt[n.type];e[`get${lt(n.name)}`]=r?r(e,t,n):()=>t[n.name]}else e[`get${lt(n)}`]=()=>t[n]}))}const yt={enum(e,t,n){const r=`_on${lt(n.name)}Changed`;return o=>{if(&quot;string&quot;==typeof o){if(void 0!==n.enum[o])return t[n.name]!==n.enum[o]&&(t[n.name]=n.enum[o],e.modified(),!0);throw et(`Set Enum with invalid argument ${n}, ${o}`),new RangeError(&quot;Set Enum with invalid string argument&quot;)}if(&quot;number&quot;==typeof o){if(t[n.name]!==o){if(-1!==Object.keys(n.enum).map((e=>n.enum[e])).indexOf(o)){const a=t[n.name];return t[n.name]=o,t[r]?.(e,t,o,a),e.modified(),!0}throw et(`Set Enum outside numeric range ${n}, ${o}`),new RangeError(&quot;Set Enum outside numeric range&quot;)}return!1}throw et(`Set Enum with invalid argument (String/Number) ${n}, ${o}`),new TypeError(&quot;Set Enum with invalid argument (String/Number)&quot;)}},object(e,t,n){1===n.params?.length&&tt('Setter of type &quot;object&quot; with a single &quot;param&quot; field is not supported');const r=`_on${lt(n.name)}Changed`;return function(){for(var o=arguments.length,a=new Array(o),i=0;i<o;i++)a[i]=arguments[i];let s;if(s=a.length>1&&n.params?.length?n.params.reduce(((e,t,n)=>Object.assign(e,{[t]:a[n]})),{}):a[0],!ke(t[n.name],s)){const o=t[n.name];return t[n.name]=s,t[r]?.(e,t,s,o),e.modified(),!0}return!1}}};function bt(e){if(&quot;object&quot;==typeof e){const t=yt[e.type];if(t)return(n,r)=>t(n,r,e);throw et(`No setter for field ${e}`),new TypeError(&quot;No setter for field&quot;)}return function(t,n){const r=`_on${lt(e)}Changed`;return function(o){if(n.deleted)return et(&quot;instance deleted - cannot call any method&quot;),!1;if(n[e]!==o){const a=n[e.name];return n[e]=o,n[r]?.(t,n,o,a),t.modified(),!0}return!1}}}function xt(e,t,n){n.forEach((n=>{&quot;object&quot;==typeof n?e[`set${lt(n.name)}`]=bt(n)(e,t):e[`set${lt(n)}`]=bt(n)(e,t)}))}function Ct(e,t,n){Tt(e,t,n),xt(e,t,n)}function St(e,t,n){n.forEach((n=>{e[`get${lt(n)}`]=()=>t[n]?Array.from(t[n]):t[n],e[`get${lt(n)}ByReference`]=()=>t[n]}))}function At(e,t,n,r){let o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:void 0;n.forEach((n=>{if(t[n]&&r&&t[n].length!==r)throw new RangeError(`Invalid initial number of values for array (${n})`);const a=`_on${lt(n)}Changed`;e[`set${lt(n)}`]=function(){if(t.deleted)return et(&quot;instance deleted - cannot call any method&quot;),!1;for(var i=arguments.length,s=new Array(i),l=0;l<i;l++)s[l]=arguments[l];let c,u=s,d=!1;if(1===u.length&&(null==u[0]||u[0].length>=0)&&(u=u[0],d=!0),null==u)c=t[n]!==u;else{if(r&&u.length!==r){if(!(u.length<r&&void 0!==o))throw new RangeError(`Invalid number of values for array setter (${n})`);for(u=Array.from(u),d=!1;u.length<r;)u.push(o)}c=null==t[n]||t[n].length!==u.length;for(let e=0;!c&&e<u.length;++e)c=t[n][e]!==u[e];c&&d&&(u=Array.from(u))}if(c){const r=t[n.name];t[n]=u,t[a]?.(e,t,u,r),e.modified()}return c},e[`set${lt(n)}From`]=e=>{const r=t[n];e.forEach(((e,t)=>{r[t]=e}))}}))}function It(e,t,n,r){let o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:void 0;St(e,t,n),At(e,t,n,r,o)}function wt(e,t,n){for(let e=0;e<n.length;e++){const r=n[e];void 0!==t[r]&&(t[`_${r}`]=t[r],delete t[r])}}function Ot(e,t,n,r){function o(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;t.deleted?et(&quot;instance deleted - cannot call any method&quot;):r>=t.numberOfInputs?et(`algorithm ${e.getClassName()} only has ${t.numberOfInputs} input ports. To add more input ports, use addInputData()`):(t.inputData[r]!==n||t.inputConnection[r])&&(t.inputData[r]=n,t.inputConnection[r]=null,e.modified&&e.modified())}function a(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;if(t.deleted)et(&quot;instance deleted - cannot call any method&quot;);else{if(r>=t.numberOfInputs){let n=`algorithm ${e.getClassName()} only has `;return n+=`${t.numberOfInputs}`,n+=&quot; input ports. To add more input ports, use addInputConnection()&quot;,void et(n)}t.inputData[r]=null,t.inputConnection[r]=n}}function i(){let e=t.numberOfInputs;for(;e&&!t.inputData[e-1]&&!t.inputConnection[e-1];)e--;return e===t.numberOfInputs&&t.numberOfInputs++,e}function s(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.deleted?(et(&quot;instance deleted - cannot call any method&quot;),null):(e.shouldUpdate()&&e.update(),t.output[n])}if(t.inputData?t.inputData=t.inputData.map(ze):t.inputData=[],t.inputConnection?t.inputConnection=t.inputConnection.map(ze):t.inputConnection=[],t.output?t.output=t.output.map(ze):t.output=[],t.inputArrayToProcess?t.inputArrayToProcess=t.inputArrayToProcess.map(ze):t.inputArrayToProcess=[],t.numberOfInputs=n,e.shouldUpdate=()=>{const n=e.getMTime();let o=1/0,a=r;for(;a--;){if(!t.output[a]||t.output[a].isDeleted())return!0;const e=t.output[a].getMTime();if(e<n)return!0;e<o&&(o=e)}for(a=t.numberOfInputs;a--;)if(t.inputConnection[a]?.filter.shouldUpdate()||e.getInputData(a)?.getMTime()>o)return!0;return!1},t.numberOfInputs){let n=t.numberOfInputs;for(;n--;)t.inputData.push(null),t.inputConnection.push(null);e.setInputData=o,e.setInputConnection=a,e.addInputData=function(e){t.deleted?et(&quot;instance deleted - cannot call any method&quot;):o(e,i())},e.addInputConnection=function(e){t.deleted?et(&quot;instance deleted - cannot call any method&quot;):a(e,i())},e.getInputData=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.inputConnection[e]&&(t.inputData[e]=t.inputConnection[e]()),t.inputData[e]},e.getInputConnection=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.inputConnection[e]}}r&&(e.getOutputData=s,e.getOutputPort=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;const n=()=>s(t);return n.filter=e,n}),e.update=()=>{const n=[];if(t.numberOfInputs){let r=0;for(;r<t.numberOfInputs;)n[r]=e.getInputData(r),r++}e.requestData&&!e.isDeleted()&&e.shouldUpdate()&&e.requestData(n,t.output)},e.getNumberOfInputPorts=()=>t.numberOfInputs,e.getNumberOfOutputPorts=()=>r||t.output.length,e.getInputArrayToProcess=e=>{const n=t.inputArrayToProcess[e],r=t.inputData[e];return n&&r?r[`get${n.fieldAssociation}`]().getArray(n.arrayName):null},e.setInputArrayToProcess=function(e,n,r){let o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:&quot;Scalars&quot;;for(;t.inputArrayToProcess.length<e;)t.inputArrayToProcess.push(null);t.inputArrayToProcess[e]={arrayName:n,fieldAssociation:r,attributeType:o}}}const Pt=Symbol(&quot;Event abort&quot;);function Rt(e,t,n){const r=[],o=e.delete;let a=1;function i(e){for(let t=0;t<r.length;++t){const[n]=r[t];if(n===e)return void r.splice(t,1)}}e[`invoke${lt(n)}`]=function(){if(t.deleted)return void et(&quot;instance deleted - cannot call any method&quot;);const n=r.slice();for(let t=0;t<n.length;++t){const[,r,o]=n[t];if(r)if(o<0)setTimeout((()=>r.apply(e,arguments)),1-o);else if(r.apply(e,arguments)===Pt)break}},e[`on${lt(n)}`]=function(e){let o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;if(!e.apply)return console.error(`Invalid callback for event ${n}`),null;if(t.deleted)return et(&quot;instance deleted - cannot call any method&quot;),null;const s=a++;return r.push([s,e,o]),r.sort(((e,t)=>t[2]-e[2])),function(e){return Object.freeze({unsubscribe:function(){i(e)}})}(s)},e.delete=()=>{o(),r.forEach((e=>{let[t]=e;return i(t)}))}}function Mt(e,t){const n=function(){const t={};return e(t,{},arguments.length>0&&void 0!==arguments[0]?arguments[0]:{}),Object.freeze(t)};return t&&ze.register(t,n),n}function Et(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return function(){for(var e=arguments.length,n=new Array(e),r=0;r<e;r++)n[r]=arguments[r];return t.filter((e=>!!e)).map((e=>e(...n)))}}function Vt(e){return e&&e.isA&&e.isA(&quot;vtkObject&quot;)}function Dt(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[],r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[];if(Vt(e)){if(r.indexOf(e)>=0)return n;r.push(e);const o=t(e);void 0!==o&&n.push(o);const a=e.get();Object.keys(a).forEach((e=>{const o=a[e];Array.isArray(o)?o.forEach((e=>{Dt(e,t,n,r)})):Dt(o,t,n,r)}))}return n}function Lt(e,t,n){var r=this;let o;const a=function(){for(var a=arguments.length,i=new Array(a),s=0;s<a;s++)i[s]=arguments[s];const l=r,c=n&&!o;clearTimeout(o),o=setTimeout((()=>{o=null,n||e.apply(l,i)}),t),c&&e.apply(l,i)};return a.cancel=()=>clearTimeout(o),a}function Bt(e,t){let n=!1,r=null;function o(){n=!1,null!==r&&(a(...r),r=null)}function a(){for(var a=arguments.length,i=new Array(a),s=0;s<a;s++)i[s]=arguments[s];n?r=i:(n=!0,e(...i),setTimeout(o,t))}return a}function Nt(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};t.keystore=Object.assign(t.keystore||{},n),e.setKey=(e,n)=>{t.keystore[e]=n},e.getKey=e=>t.keystore[e],e.getAllKeys=()=>Object.keys(t.keystore),e.deleteKey=e=>delete t.keystore[e],e.clearKeystore=()=>e.getAllKeys().forEach((e=>delete t.keystore[e]))}let Ft=1;const _t=&quot;__root__&quot;;function kt(e,t){Nt(e,t);const n=e.delete;t.proxyId=&quot;&quot;+Ft++,t.ui=JSON.parse(JSON.stringify(t.ui||[])),Tt(e,t,[&quot;proxyId&quot;,&quot;proxyGroup&quot;,&quot;proxyName&quot;]),Ct(e,t,[&quot;proxyManager&quot;]);const r={},o={};function a(e,t){o[t]||(o[t]=[]);const n=o[t];for(let t=0;t<e.length;t++)n.push(e[t].name),r[e[t].name]=e[t],e[t].children&&e[t].children.length&&a(e[t].children,e[t].name)}function i(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:_t;const r=[],a=t.proxyId,s=function(){return o[arguments.length>0&&void 0!==arguments[0]?arguments[0]:_t]}(n)||[];for(let t=0;t<s.length;t++){const n=s[t],o=e[`get${lt(n)}`],l={id:a,name:n,value:o?o():void 0},c=i(n);c.length&&(l.children=c),r.push(l)}return r}a(t.ui,_t),e.updateUI=n=>{t.ui=JSON.parse(JSON.stringify(n||[])),Object.keys(r).forEach((e=>delete r[e])),Object.keys(o).forEach((e=>delete o[e])),a(t.ui,_t),e.modified()},e.updateProxyProperty=(e,t)=>{const n=r[e];n?Object.assign(n,t):r[e]={...t}},e.activate=()=>{if(t.proxyManager){const n=`setActive${lt(e.getProxyGroup().slice(0,-1))}`;t.proxyManager[n]&&t.proxyManager[n](e)}},t.propertyLinkSubscribers={},e.registerPropertyLinkForGC=(e,n)=>{n in t.propertyLinkSubscribers||(t.propertyLinkSubscribers[n]=[]),t.propertyLinkSubscribers[n].push(e)},e.gcPropertyLinks=n=>{const r=t.propertyLinkSubscribers[n]||[];for(;r.length;)r.pop().unbind(e)},t.propertyLinkMap={},e.getPropertyLink=function(e){let n=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(t.propertyLinkMap[e])return t.propertyLinkMap[e];let r=null;const o=[];let a=0,i=!1;function s(n){let s=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(i)return null;const l=[];let c=null;for(a=o.length;a--;){const e=o[a];e.instance===n?c=e:l.push(e)}if(!c)return null;const u=c.instance[`get${lt(c.propertyName)}`]();if(!function(e,t){if(e===t)return!0;if(Array.isArray(e)&&Array.isArray(t)){if(e.length!==t.length)return!1;for(let n=0;n<e.length;n++)if(e[n]!==t[n])return!1;return!0}return!1}(u,r)||s){for(r=u,i=!0;l.length;){const e=l.pop();e.instance.set({[e.propertyName]:r})}i=!1}return t.propertyLinkMap[e].persistent&&(t.propertyLinkMap[e].value=u),u}function l(e,t){const n=[];for(a=o.length;a--;){const r=o[a];r.instance!==e||r.propertyName!==t&&void 0!==t||(r.subscription.unsubscribe(),n.push(a))}for(;n.length;)o.splice(n.pop(),1)}const c={bind:function(n,r){let a=arguments.length>2&&void 0!==arguments[2]&&arguments[2];const i=n.onModified(s),c=o[0];return o.push({instance:n,propertyName:r,subscription:i}),a&&(t.propertyLinkMap[e].persistent&&void 0!==t.propertyLinkMap[e].value?n.set({[r]:t.propertyLinkMap[e].value}):c&&s(c.instance,!0)),{unsubscribe:()=>l(n,r)}},unbind:l,unsubscribe:function(){for(;o.length;)o.pop().subscription.unsubscribe()},persistent:n};return t.propertyLinkMap[e]=c,c},e.listPropertyNames=()=>i().map((e=>e.name)),e.getPropertyByName=e=>i().find((t=>t.name===e)),e.getPropertyDomainByName=e=>(r[e]||{}).domain,e.getProxySection=()=>({id:t.proxyId,name:t.proxyGroup,ui:t.ui,properties:i()}),e.delete=()=>{const r=Object.keys(t.propertyLinkMap);let o=r.length;for(;o--;)t.propertyLinkMap[r[o]].unsubscribe();Object.keys(t.propertyLinkSubscribers).forEach(e.gcPropertyLinks),n()},e.getState=()=>null,gt((function(){if(t.links)for(let n=0;n<t.links.length;n++){const{link:r,property:o,persistent:a,updateOnBind:i,type:s}=t.links[n];if(&quot;application&quot;===s){const n=t.proxyManager.getPropertyLink(r,a);e.registerPropertyLinkForGC(n,&quot;application&quot;),n.bind(e,o,i)}}}))}function Gt(e,t,n){const r=e.delete,o=[],a=Object.keys(n);let i=a.length;for(;i--;){const r=a[i],{modelKey:s,property:l,modified:c=!0}=n[r],u=lt(l),d=lt(r);e[`get${d}`]=t[s][`get${u}`],e[`set${d}`]=t[s][`set${u}`],c&&o.push(t[s].onModified(e.modified))}e.delete=()=>{for(;o.length;)o.pop().unsubscribe();r()}}function Ut(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};function o(e){const n=Object.keys(e);let r=n.length;for(;r--;){const o=n[r];t[o].set(e[o])}}t.this=e;const a=Object.keys(r);let i=a.length;for(;i--;){const s=a[i];t[s]=r[s];const l=n[s];e[`set${lt(s)}`]=n=>{n!==t[s]&&(t[s]=n,o(l[n]),e.modified())}}a.length&&Tt(e,t,a)}function zt(e){let t=0,n=0,r=0,o=0;return&quot;detail&quot;in e&&(n=e.detail),&quot;wheelDelta&quot;in e&&(n=-e.wheelDelta/120),&quot;wheelDeltaY&quot;in e&&(n=-e.wheelDeltaY/120),&quot;wheelDeltaX&quot;in e&&(t=-e.wheelDeltaX/120),&quot;axis&quot;in e&&e.axis===e.HORIZONTAL_AXIS&&(t=n,n=0),r=10*t,o=10*n,&quot;deltaY&quot;in e&&(o=e.deltaY),&quot;deltaX&quot;in e&&(r=e.deltaX),(r||o)&&e.deltaMode&&(1===e.deltaMode?(r*=40,o*=40):(r*=800,o*=800)),r&&!t&&(t=r<1?-1:1),o&&!n&&(n=o<1?-1:1),{spinX:t,spinY:n||t,pixelX:r,pixelY:o||r}}var Wt={algo:Ot,capitalize:st,chain:Et,debounce:Lt,enumToString:function(e,t){return Object.keys(e).find((n=>e[n]===t))},event:Rt,EVENT_ABORT:Pt,formatBytesToProperUnit:ut,formatNumbersWithThousandSeparator:dt,get:Tt,getArray:St,getCurrentGlobalMTime:function(){return He},getStateArrayMapFunc:ft,isVtkObject:Vt,keystore:Nt,measurePromiseExecution:mt,moveToProtected:wt,newInstance:Mt,newTypedArray:at,newTypedArrayFrom:it,normalizeWheel:zt,obj:ht,proxy:kt,proxyPropertyMapping:Gt,proxyPropertyState:Ut,safeArrays:pt,set:xt,setArray:At,setGet:Ct,setGetArray:It,setImmediate:gt,setLoggerFunction:Ye,throttle:Bt,traverseInstanceTree:Dt,TYPED_ARRAYS:ot,uncapitalize:ct,VOID:Ke,vtkDebugMacro:Je,vtkErrorMacro:et,vtkInfoMacro:Qe,vtkLogMacro:Ze,vtkOnceErrorMacro:rt,vtkWarningMacro:tt,objectSetterMap:yt,requiredParam:je},Ht=Object.freeze({__proto__:null,requiredParam:je,VOID:Ke,setLoggerFunction:Ye,vtkLogMacro:Ze,vtkInfoMacro:Qe,vtkDebugMacro:Je,vtkErrorMacro:et,vtkWarningMacro:tt,vtkOnceErrorMacro:rt,TYPED_ARRAYS:ot,newTypedArray:at,newTypedArrayFrom:it,capitalize:st,_capitalize:lt,uncapitalize:ct,formatBytesToProperUnit:ut,formatNumbersWithThousandSeparator:dt,setImmediateVTK:gt,measurePromiseExecution:mt,obj:ht,get:Tt,set:xt,setGet:Ct,getArray:St,setArray:At,setGetArray:It,moveToProtected:wt,algo:Ot,EVENT_ABORT:Pt,event:Rt,newInstance:Mt,chain:Et,isVtkObject:Vt,traverseInstanceTree:Dt,debounce:Lt,throttle:Bt,keystore:Nt,proxy:kt,proxyPropertyMapping:Gt,proxyPropertyState:Ut,normalizeWheel:zt,default:Wt});const{vtkErrorMacro:jt}=Wt,Kt={renderable:null,myFactory:null,children:[],visited:!1};function $t(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Kt,n),Wt.obj(e,t),Wt.event(e,t,&quot;event&quot;),t._renderableChildMap=new Map,Wt.get(e,t,[&quot;visited&quot;]),Wt.setGet(e,t,[&quot;_parent&quot;,&quot;renderable&quot;,&quot;myFactory&quot;]),Wt.getArray(e,t,[&quot;children&quot;]),Wt.moveToProtected(e,t,[&quot;parent&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkViewNode&quot;),e.build=e=>{},e.render=e=>{},e.traverse=n=>{const r=n.getTraverseOperation(),o=e[r];if(o)o(n);else{e.apply(n,!0);for(let e=0;e<t.children.length;e++)t.children[e].traverse(n);e.apply(n,!1)}},e.apply=(t,n)=>{const r=e[t.getOperation()];r&&r(n,t)},e.getViewNodeFor=n=>{if(t.renderable===n)return e;for(let e=0;e<t.children.length;++e){const r=t.children[e].getViewNodeFor(n);if(r)return r}},e.getFirstAncestorOfType=e=>t._parent?t._parent.isA(e)?t._parent:t._parent.getFirstAncestorOfType(e):null,e.getLastAncestorOfType=e=>t._parent?t._parent.getLastAncestorOfType(e)||(t._parent.isA(e)?t._parent:null):null,e.addMissingNode=n=>{if(!n)return;const r=t._renderableChildMap.get(n);if(void 0!==r)return r.setVisited(!0),r;const o=e.createViewNode(n);return o?(o.setParent(e),o.setVisited(!0),t._renderableChildMap.set(n,o),t.children.push(o),o):void 0},e.addMissingNodes=function(n){let r=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(n&&n.length)for(let o=0;o<n.length;++o){const a=n[o],i=e.addMissingNode(a);if(r&&void 0!==i&&t.children[o]!==i)for(let e=o+1;e<t.children.length;++e)if(t.children[e]===i){t.children.splice(e,1),t.children.splice(o,0,i);break}}},e.addMissingChildren=n=>{if(n&&n.length)for(let r=0;r<n.length;++r){const o=n[r];if(-1===t.children.indexOf(o)){o.setParent(e),t.children.push(o);const n=o.getRenderable();n&&t._renderableChildMap.set(n,o)}o.setVisited(!0)}},e.removeNode=e=>{const n=t.children.findIndex((t=>t===e));if(n<0)return!1;const r=e.getRenderable();return r&&t._renderableChildMap.delete(r),e.delete(),t.children.splice(n,1),!0},e.prepareNodes=()=>{for(let e=0;e<t.children.length;++e)t.children[e].setVisited(!1)},e.setVisited=e=>{t.visited=e},e.removeUnusedNodes=()=>{let e=0;for(let n=0;n<t.children.length;++n){const r=t.children[n];if(r.getVisited())t.children[e++]=r,r.setVisited(!1);else{const e=r.getRenderable();e&&t._renderableChildMap.delete(e),r.delete()}}t.children.length=e},e.createViewNode=e=>{if(!t.myFactory)return jt(&quot;Cannot create view nodes without my own factory&quot;),null;const n=t.myFactory.createNode(e);return n&&n.setRenderable(e),n};const n=e.delete;e.delete=()=>{for(let e=0;e<t.children.length;e++)t.children[e].delete();n()}}(e,t)}var qt={newInstance:Wt.newInstance($t,&quot;vtkViewNode&quot;),extend:$t,PASS_TYPES:[&quot;Build&quot;,&quot;Render&quot;]};const Xt={};function Yt(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Xt,n),Wt.obj(e,t),function(e,t){t.overrides||(t.overrides={}),t.classHierarchy.push(&quot;vtkViewNodeFactory&quot;),e.createNode=n=>{if(n.isDeleted())return null;let r=0,o=n.getClassName(r++),a=!1;const i=Object.keys(t.overrides);for(;o&&!a;)-1!==i.indexOf(o)?a=!0:o=n.getClassName(r++);if(!a)return null;const s=t.overrides[o]();return s.setMyFactory(e),s}}(e,t)}var Zt={newInstance:Wt.newInstance(Yt,&quot;vtkViewNodeFactory&quot;),extend:Yt};const Qt=Object.create(null);function Jt(e,t){Qt[e]=t}const en={};function tn(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,en,n),t.overrides=Qt,Zt.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLViewNodeFactory&quot;)}(0,t)}var nn={newInstance:Wt.newInstance(tn,&quot;vtkOpenGLViewNodeFactory&quot;),extend:tn};const rn={context:null,lastRenderer:null,keyMatrixTime:null,keyMatrices:null};const on=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,rn,n),qt.extend(e,t,n),t.keyMatrixTime={},ht(t.keyMatrixTime),t.keyMatrices={normalMatrix:new Float64Array(9),vcpc:new Float64Array(16),wcvc:new Float64Array(16),wcpc:new Float64Array(16)},Ct(e,t,[&quot;context&quot;,&quot;keyMatrixTime&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLCamera&quot;),e.buildPass=n=>{n&&(t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getParent(),t.context=t._openGLRenderWindow.getContext())},e.opaquePass=e=>{if(e){const e=t._openGLRenderer.getTiledSizeAndOrigin();t.context.viewport(e.lowerLeftU,e.lowerLeftV,e.usize,e.vsize),t.context.scissor(e.lowerLeftU,e.lowerLeftV,e.usize,e.vsize)}},e.translucentPass=e.opaquePass,e.zBufferPass=e.opaquePass,e.opaqueZBufferPass=e.opaquePass,e.volumePass=e.opaquePass,e.getKeyMatrices=n=>{if(n!==t.lastRenderer||t._openGLRenderWindow.getMTime()>t.keyMatrixTime.getMTime()||e.getMTime()>t.keyMatrixTime.getMTime()||n.getMTime()>t.keyMatrixTime.getMTime()||t.renderable.getMTime()>t.keyMatrixTime.getMTime()){p(t.keyMatrices.wcvc,t.renderable.getViewMatrix()),le(t.keyMatrices.normalMatrix,t.keyMatrices.wcvc),me(t.keyMatrices.normalMatrix,t.keyMatrices.normalMatrix),h(t.keyMatrices.wcvc,t.keyMatrices.wcvc);const e=t._openGLRenderer.getAspectRatio();p(t.keyMatrices.vcpc,t.renderable.getProjectionMatrix(e,-1,1)),h(t.keyMatrices.vcpc,t.keyMatrices.vcpc),b(t.keyMatrices.wcpc,t.keyMatrices.vcpc,t.keyMatrices.wcvc),t.keyMatrixTime.modified(),t.lastRenderer=n}return t.keyMatrices}}(e,t)}));Jt(&quot;vtkCamera&quot;,on);const{vtkDebugMacro:an}=Ht,sn={context:null,_openGLRenderWindow:null,selector:null};const ln=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,sn,n),qt.extend(e,t,n),Tt(e,t,[&quot;shaderCache&quot;]),Ct(e,t,[&quot;selector&quot;]),wt(0,t,[&quot;openGLRenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLRenderer&quot;),e.buildPass=n=>{if(n){if(!t.renderable)return;e.updateLights(),e.prepareNodes(),e.addMissingNode(t.renderable.getActiveCamera()),e.addMissingNodes(t.renderable.getViewPropsWithNestedProps(),!0),e.removeUnusedNodes()}},e.updateLights=()=>{let e=0;const n=t.renderable.getLightsByReference();for(let t=0;t<n.length;++t)n[t].getSwitch()>0&&e++;return e||(an(&quot;No lights are on, creating one.&quot;),t.renderable.createLight()),e},e.zBufferPass=n=>{if(n){let n=0;const r=t.context;t.renderable.getTransparent()||(t.context.clearColor(1,0,0,1),n|=r.COLOR_BUFFER_BIT),t.renderable.getPreserveDepthBuffer()||(r.clearDepth(1),n|=r.DEPTH_BUFFER_BIT,t.context.depthMask(!0));const o=e.getTiledSizeAndOrigin();r.enable(r.SCISSOR_TEST),r.scissor(o.lowerLeftU,o.lowerLeftV,o.usize,o.vsize),r.viewport(o.lowerLeftU,o.lowerLeftV,o.usize,o.vsize),r.colorMask(!0,!0,!0,!0),n&&r.clear(n),r.enable(r.DEPTH_TEST)}},e.opaqueZBufferPass=t=>e.zBufferPass(t),e.cameraPass=t=>{t&&e.clear()},e.getAspectRatio=()=>{const e=t._parent.getSizeByReference(),n=t.renderable.getViewportByReference();return e[0]*(n[2]-n[0])/((n[3]-n[1])*e[1])},e.getTiledSizeAndOrigin=()=>{const e=t.renderable.getViewportByReference(),n=[0,0,1,1],r=e[0]-n[0],o=e[1]-n[1],a=t._parent.normalizedDisplayToDisplay(r,o),i=Math.round(a[0]),s=Math.round(a[1]),l=e[2]-n[0],c=e[3]-n[1],u=t._parent.normalizedDisplayToDisplay(l,c);let d=Math.round(u[0])-i,p=Math.round(u[1])-s;return d<0&&(d=0),p<0&&(p=0),{usize:d,vsize:p,lowerLeftU:i,lowerLeftV:s}},e.clear=()=>{let n=0;const r=t.context;if(!t.renderable.getTransparent()){const e=t.renderable.getBackgroundByReference();r.clearColor(e[0],e[1],e[2],e[3]),n|=r.COLOR_BUFFER_BIT}t.renderable.getPreserveDepthBuffer()||(r.clearDepth(1),n|=r.DEPTH_BUFFER_BIT,r.depthMask(!0)),r.colorMask(!0,!0,!0,!0);const o=e.getTiledSizeAndOrigin();r.enable(r.SCISSOR_TEST),r.scissor(o.lowerLeftU,o.lowerLeftV,o.usize,o.vsize),r.viewport(o.lowerLeftU,o.lowerLeftV,o.usize,o.vsize),n&&r.clear(n),r.enable(r.DEPTH_TEST)},e.releaseGraphicsResources=()=>{null!==t.selector&&t.selector.releaseGraphicsResources(),t.renderable&&t.renderable.getViewProps().forEach((e=>{e.modified()}))},e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))}}(e,t)}),&quot;vtkOpenGLRenderer&quot;);Jt(&quot;vtkRenderer&quot;,ln);const cn={context:null,keyMatrixTime:null,keyMatrices:null,activeTextures:null};const un=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,cn,n),qt.extend(e,t,n),t.keyMatrixTime={},ht(t.keyMatrixTime,{mtime:0}),t.keyMatrices={normalMatrix:fe(new Float64Array(9)),mcwc:m(new Float64Array(16))},Ct(e,t,[&quot;context&quot;]),Tt(e,t,[&quot;activeTextures&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLActor&quot;),e.buildPass=n=>{if(n){t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t.context=t._openGLRenderWindow.getContext(),e.prepareNodes(),e.addMissingNodes(t.renderable.getTextures()),e.addMissingNode(t.renderable.getMapper()),e.removeUnusedNodes(),t.ogltextures=null,t.activeTextures=null;for(let e=0;e<t.children.length;e++){const n=t.children[e];n.isA(&quot;vtkOpenGLTexture&quot;)?(t.ogltextures||(t.ogltextures=[]),t.ogltextures.push(n)):t.oglmapper=n}}},e.traverseZBufferPass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.traverseOpaqueZBufferPass=t=>e.traverseOpaquePass(t),e.traverseOpaquePass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&t.renderable.getIsOpaque()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.traverseTranslucentPass=n=>{!t.renderable||!t.renderable.getNestedVisibility()||t.renderable.getIsOpaque()||t._openGLRenderer.getSelector()&&!t.renderable.getNestedPickable()||(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.activateTextures=()=>{if(t.ogltextures){t.activeTextures=[];for(let e=0;e<t.ogltextures.length;e++){const n=t.ogltextures[e];n.render(),n.getHandle()&&t.activeTextures.push(n)}}},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;t.renderable.getIsOpaque()?n.incrementOpaqueActorCount():n.incrementTranslucentActorCount()}},e.zBufferPass=(t,n)=>e.opaquePass(t,n),e.opaqueZBufferPass=(t,n)=>e.opaquePass(t,n),e.opaquePass=(n,r)=>{if(n)t.context.depthMask(!0),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()},e.translucentPass=(n,r)=>{if(n)t.context.depthMask(t._openGLRenderer.getSelector()&&t.renderable.getNestedPickable()),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()},e.getKeyMatrices=()=>(t.renderable.getMTime()>t.keyMatrixTime.getMTime()&&(t.renderable.computeMatrix(),p(t.keyMatrices.mcwc,t.renderable.getMatrix()),h(t.keyMatrices.mcwc,t.keyMatrices.mcwc),t.renderable.getIsIdentity()?fe(t.keyMatrices.normalMatrix):(le(t.keyMatrices.normalMatrix,t.keyMatrices.mcwc),me(t.keyMatrices.normalMatrix,t.keyMatrices.normalMatrix),ge(t.keyMatrices.normalMatrix,t.keyMatrices.normalMatrix)),t.keyMatrixTime.modified()),t.keyMatrices)}(e,t)}));Jt(&quot;vtkActor&quot;,un);const dn={context:null,activeTextures:null};const pn=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,dn,n),qt.extend(e,t,n),Ct(e,t,[&quot;context&quot;]),Tt(e,t,[&quot;activeTextures&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLActor2D&quot;),e.buildPass=n=>{if(n){if(!t.renderable)return;t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t.context=t._openGLRenderWindow.getContext(),e.prepareNodes(),e.addMissingNodes(t.renderable.getTextures()),e.addMissingNode(t.renderable.getMapper()),e.removeUnusedNodes(),t.ogltextures=null,t.activeTextures=null;for(let e=0;e<t.children.length;e++){const n=t.children[e];n.isA(&quot;vtkOpenGLTexture&quot;)?(t.ogltextures||(t.ogltextures=[]),t.ogltextures.push(n)):t.oglmapper=n}}},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;n.incrementOverlayActorCount()}},e.traverseOpaquePass=n=>{t.oglmapper&&t.renderable&&t.renderable.getNestedVisibility()&&t.renderable.getIsOpaque()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.traverseTranslucentPass=n=>{t.oglmapper&&t.renderable&&t.renderable.getNestedVisibility()&&!t.renderable.getIsOpaque()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.traverseOverlayPass=n=>{t.oglmapper&&t.renderable&&t.renderable.getNestedVisibility()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable)&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.activateTextures=()=>{if(t.ogltextures){t.activeTextures=[];for(let e=0;e<t.ogltextures.length;e++){const n=t.ogltextures[e];n.render(),n.getHandle()&&t.activeTextures.push(n)}}},e.opaquePass=(n,r)=>{if(n)t.context.depthMask(!0),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()},e.translucentPass=(n,r)=>{if(n)t.context.depthMask(!1),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()},e.overlayPass=(n,r)=>{if(n)t.context.depthMask(!0),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()}}(e,t)}));function fn(){var e=new s(3);return s!=Float32Array&&(e[0]=0,e[1]=0,e[2]=0),e}function gn(e){var t=e[0],n=e[1],r=e[2];return Math.hypot(t,n,r)}function mn(e,t,n){var r=new s(3);return r[0]=e,r[1]=t,r[2]=n,r}function hn(e,t,n,r){return e[0]=t,e[1]=n,e[2]=r,e}function vn(e,t,n){return e[0]=t[0]+n[0],e[1]=t[1]+n[1],e[2]=t[2]+n[2],e}function Tn(e,t,n){return e[0]=t[0]-n[0],e[1]=t[1]-n[1],e[2]=t[2]-n[2],e}function yn(e,t,n){return e[0]=t[0]*n[0],e[1]=t[1]*n[1],e[2]=t[2]*n[2],e}function bn(e,t,n){return e[0]=t[0]*n,e[1]=t[1]*n,e[2]=t[2]*n,e}function xn(e,t){return e[0]=1/t[0],e[1]=1/t[1],e[2]=1/t[2],e}function Cn(e,t){var n=t[0],r=t[1],o=t[2],a=n*n+r*r+o*o;return a>0&&(a=1/Math.sqrt(a)),e[0]=t[0]*a,e[1]=t[1]*a,e[2]=t[2]*a,e}function Sn(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function An(e,t,n){var r=t[0],o=t[1],a=t[2],i=n[0],s=n[1],l=n[2];return e[0]=o*l-a*s,e[1]=a*i-r*l,e[2]=r*s-o*i,e}function In(e,t,n){var r=t[0],o=t[1],a=t[2],i=n[3]*r+n[7]*o+n[11]*a+n[15];return i=i||1,e[0]=(n[0]*r+n[4]*o+n[8]*a+n[12])/i,e[1]=(n[1]*r+n[5]*o+n[9]*a+n[13])/i,e[2]=(n[2]*r+n[6]*o+n[10]*a+n[14])/i,e}function wn(e,t,n){var r=t[0],o=t[1],a=t[2];return e[0]=r*n[0]+o*n[3]+a*n[6],e[1]=r*n[1]+o*n[4]+a*n[7],e[2]=r*n[2]+o*n[5]+a*n[8],e}function On(e,t){return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]}function Pn(e,t){var n=e[0],r=e[1],o=e[2],a=t[0],s=t[1],l=t[2];return Math.abs(n-a)<=i*Math.max(1,Math.abs(n),Math.abs(a))&&Math.abs(r-s)<=i*Math.max(1,Math.abs(r),Math.abs(s))&&Math.abs(o-l)<=i*Math.max(1,Math.abs(o),Math.abs(l))}Jt(&quot;vtkActor2D&quot;,pn);var Rn=Tn,Mn=yn,En=(fn(),Math.sqrt(50)),Vn=Math.sqrt(10),Dn=Math.sqrt(2);function Ln(e,t,n){var r=(t-e)/Math.max(0,n),o=Math.floor(Math.log(r)/Math.LN10),a=r/Math.pow(10,o);return o>=0?(a>=En?10:a>=Vn?5:a>=Dn?2:1)*Math.pow(10,o):-Math.pow(10,-o)/(a>=En?10:a>=Vn?5:a>=Dn?2:1)}function Bn(e,t){return null==e||null==t?NaN:e<t?-1:e>t?1:e>=t?0:NaN}function Nn(e){let t=e,n=e,r=e;function o(e,t,o=0,a=e.length){if(o<a){if(0!==n(t,t))return a;do{const n=o+a>>>1;r(e[n],t)<0?o=n+1:a=n}while(o<a)}return o}return 1===e.length&&(t=(t,n)=>e(t)-n,n=Bn,r=(t,n)=>Bn(e(t),n)),{left:o,center:function(e,n,r=0,a=e.length){const i=o(e,n,r,a-1);return i>r&&t(e[i-1],n)>-t(e[i],n)?i-1:i},right:function(e,t,o=0,a=e.length){if(o<a){if(0!==n(t,t))return a;do{const n=o+a>>>1;r(e[n],t)<=0?o=n+1:a=n}while(o<a)}return o}}}const Fn=Nn(Bn),_n=Fn.right;Fn.left,Nn((function(e){return null===e?NaN:+e})).center;var kn=_n;function Gn(e,t,n){e.prototype=t.prototype=n,n.constructor=e}function Un(e,t){var n=Object.create(e.prototype);for(var r in t)n[r]=t[r];return n}function zn(){}var Wn=.7,Hn=1/Wn,jn=&quot;\\\\s*([+-]?\\\\d+)\\\\s*&quot;,Kn=&quot;\\\\s*([+-]?(?:\\\\d*\\\\.)?\\\\d+(?:[eE][+-]?\\\\d+)?)\\\\s*&quot;,$n=&quot;\\\\s*([+-]?(?:\\\\d*\\\\.)?\\\\d+(?:[eE][+-]?\\\\d+)?)%\\\\s*&quot;,qn=/^#([0-9a-f]{3,8})$/,Xn=new RegExp(`^rgb\\\\(${jn},${jn},${jn}\\\\)$`),Yn=new RegExp(`^rgb\\\\(${$n},${$n},${$n}\\\\)$`),Zn=new RegExp(`^rgba\\\\(${jn},${jn},${jn},${Kn}\\\\)$`),Qn=new RegExp(`^rgba\\\\(${$n},${$n},${$n},${Kn}\\\\)$`),Jn=new RegExp(`^hsl\\\\(${Kn},${$n},${$n}\\\\)$`),er=new RegExp(`^hsla\\\\(${Kn},${$n},${$n},${Kn}\\\\)$`),tr={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function nr(){return this.rgb().formatHex()}function rr(){return this.rgb().formatRgb()}function or(e){var t,n;return e=(e+&quot;&quot;).trim().toLowerCase(),(t=qn.exec(e))?(n=t[1].length,t=parseInt(t[1],16),6===n?ar(t):3===n?new lr(t>>8&15|t>>4&240,t>>4&15|240&t,(15&t)<<4|15&t,1):8===n?ir(t>>24&255,t>>16&255,t>>8&255,(255&t)/255):4===n?ir(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|240&t,((15&t)<<4|15&t)/255):null):(t=Xn.exec(e))?new lr(t[1],t[2],t[3],1):(t=Yn.exec(e))?new lr(255*t[1]/100,255*t[2]/100,255*t[3]/100,1):(t=Zn.exec(e))?ir(t[1],t[2],t[3],t[4]):(t=Qn.exec(e))?ir(255*t[1]/100,255*t[2]/100,255*t[3]/100,t[4]):(t=Jn.exec(e))?gr(t[1],t[2]/100,t[3]/100,1):(t=er.exec(e))?gr(t[1],t[2]/100,t[3]/100,t[4]):tr.hasOwnProperty(e)?ar(tr[e]):&quot;transparent&quot;===e?new lr(NaN,NaN,NaN,0):null}function ar(e){return new lr(e>>16&255,e>>8&255,255&e,1)}function ir(e,t,n,r){return r<=0&&(e=t=n=NaN),new lr(e,t,n,r)}function sr(e,t,n,r){return 1===arguments.length?((o=e)instanceof zn||(o=or(o)),o?new lr((o=o.rgb()).r,o.g,o.b,o.opacity):new lr):new lr(e,t,n,null==r?1:r);var o}function lr(e,t,n,r){this.r=+e,this.g=+t,this.b=+n,this.opacity=+r}function cr(){return`#${fr(this.r)}${fr(this.g)}${fr(this.b)}`}function ur(){const e=dr(this.opacity);return`${1===e?&quot;rgb(&quot;:&quot;rgba(&quot;}${pr(this.r)}, ${pr(this.g)}, ${pr(this.b)}${1===e?&quot;)&quot;:`, ${e})`}`}function dr(e){return isNaN(e)?1:Math.max(0,Math.min(1,e))}function pr(e){return Math.max(0,Math.min(255,Math.round(e)||0))}function fr(e){return((e=pr(e))<16?&quot;0&quot;:&quot;&quot;)+e.toString(16)}function gr(e,t,n,r){return r<=0?e=t=n=NaN:n<=0||n>=1?e=t=NaN:t<=0&&(e=NaN),new hr(e,t,n,r)}function mr(e){if(e instanceof hr)return new hr(e.h,e.s,e.l,e.opacity);if(e instanceof zn||(e=or(e)),!e)return new hr;if(e instanceof hr)return e;var t=(e=e.rgb()).r/255,n=e.g/255,r=e.b/255,o=Math.min(t,n,r),a=Math.max(t,n,r),i=NaN,s=a-o,l=(a+o)/2;return s?(i=t===a?(n-r)/s+6*(n<r):n===a?(r-t)/s+2:(t-n)/s+4,s/=l<.5?a+o:2-a-o,i*=60):s=l>0&&l<1?0:i,new hr(i,s,l,e.opacity)}function hr(e,t,n,r){this.h=+e,this.s=+t,this.l=+n,this.opacity=+r}function vr(e){return(e=(e||0)%360)<0?e+360:e}function Tr(e){return Math.max(0,Math.min(1,e||0))}function yr(e,t,n){return 255*(e<60?t+(n-t)*e/60:e<180?n:e<240?t+(n-t)*(240-e)/60:t)}function br(e,t,n,r,o){var a=e*e,i=a*e;return((1-3*e+3*a-i)*t+(4-6*a+3*i)*n+(1+3*e+3*a-3*i)*r+i*o)/6}Gn(zn,or,{copy(e){return Object.assign(new this.constructor,this,e)},displayable(){return this.rgb().displayable()},hex:nr,formatHex:nr,formatHex8:function(){return this.rgb().formatHex8()},formatHsl:function(){return mr(this).formatHsl()},formatRgb:rr,toString:rr}),Gn(lr,sr,Un(zn,{brighter(e){return e=null==e?Hn:Math.pow(Hn,e),new lr(this.r*e,this.g*e,this.b*e,this.opacity)},darker(e){return e=null==e?Wn:Math.pow(Wn,e),new lr(this.r*e,this.g*e,this.b*e,this.opacity)},rgb(){return this},clamp(){return new lr(pr(this.r),pr(this.g),pr(this.b),dr(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:cr,formatHex:cr,formatHex8:function(){return`#${fr(this.r)}${fr(this.g)}${fr(this.b)}${fr(255*(isNaN(this.opacity)?1:this.opacity))}`},formatRgb:ur,toString:ur})),Gn(hr,(function(e,t,n,r){return 1===arguments.length?mr(e):new hr(e,t,n,null==r?1:r)}),Un(zn,{brighter(e){return e=null==e?Hn:Math.pow(Hn,e),new hr(this.h,this.s,this.l*e,this.opacity)},darker(e){return e=null==e?Wn:Math.pow(Wn,e),new hr(this.h,this.s,this.l*e,this.opacity)},rgb(){var e=this.h%360+360*(this.h<0),t=isNaN(e)||isNaN(this.s)?0:this.s,n=this.l,r=n+(n<.5?n:1-n)*t,o=2*n-r;return new lr(yr(e>=240?e-240:e+120,o,r),yr(e,o,r),yr(e<120?e+240:e-120,o,r),this.opacity)},clamp(){return new hr(vr(this.h),Tr(this.s),Tr(this.l),dr(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){const e=dr(this.opacity);return`${1===e?&quot;hsl(&quot;:&quot;hsla(&quot;}${vr(this.h)}, ${100*Tr(this.s)}%, ${100*Tr(this.l)}%${1===e?&quot;)&quot;:`, ${e})`}`}}));var xr=e=>()=>e;function Cr(e,t){var n=t-e;return n?function(e,t){return function(n){return e+n*t}}(e,n):xr(isNaN(e)?t:e)}var Sr=function e(t){var n=function(e){return 1==(e=+e)?Cr:function(t,n){return n-t?function(e,t,n){return e=Math.pow(e,n),t=Math.pow(t,n)-e,n=1/n,function(r){return Math.pow(e+r*t,n)}}(t,n,e):xr(isNaN(t)?n:t)}}(t);function r(e,t){var r=n((e=sr(e)).r,(t=sr(t)).r),o=n(e.g,t.g),a=n(e.b,t.b),i=Cr(e.opacity,t.opacity);return function(t){return e.r=r(t),e.g=o(t),e.b=a(t),e.opacity=i(t),e+&quot;&quot;}}return r.gamma=e,r}(1);function Ar(e){return function(t){var n,r,o=t.length,a=new Array(o),i=new Array(o),s=new Array(o);for(n=0;n<o;++n)r=sr(t[n]),a[n]=r.r||0,i[n]=r.g||0,s[n]=r.b||0;return a=e(a),i=e(i),s=e(s),r.opacity=1,function(e){return r.r=a(e),r.g=i(e),r.b=s(e),r+&quot;&quot;}}}function Ir(e,t){var n,r=t?t.length:0,o=e?Math.min(r,e.length):0,a=new Array(o),i=new Array(r);for(n=0;n<o;++n)a[n]=Dr(e[n],t[n]);for(;n<r;++n)i[n]=t[n];return function(e){for(n=0;n<o;++n)i[n]=a[n](e);return i}}function wr(e,t){var n=new Date;return e=+e,t=+t,function(r){return n.setTime(e*(1-r)+t*r),n}}function Or(e,t){return e=+e,t=+t,function(n){return e*(1-n)+t*n}}function Pr(e,t){var n,r={},o={};for(n in null!==e&&&quot;object&quot;==typeof e||(e={}),null!==t&&&quot;object&quot;==typeof t||(t={}),t)n in e?r[n]=Dr(e[n],t[n]):o[n]=t[n];return function(e){for(n in r)o[n]=r[n](e);return o}}Ar((function(e){var t=e.length-1;return function(n){var r=n<=0?n=0:n>=1?(n=1,t-1):Math.floor(n*t),o=e[r],a=e[r+1],i=r>0?e[r-1]:2*o-a,s=r<t-1?e[r+2]:2*a-o;return br((n-r/t)*t,i,o,a,s)}})),Ar((function(e){var t=e.length;return function(n){var r=Math.floor(((n%=1)<0?++n:n)*t),o=e[(r+t-1)%t],a=e[r%t],i=e[(r+1)%t],s=e[(r+2)%t];return br((n-r/t)*t,o,a,i,s)}}));var Rr=/[-+]?(?:\\d+\\.?\\d*|\\.?\\d+)(?:[eE][-+]?\\d+)?/g,Mr=new RegExp(Rr.source,&quot;g&quot;);function Er(e,t){var n,r,o,a=Rr.lastIndex=Mr.lastIndex=0,i=-1,s=[],l=[];for(e+=&quot;&quot;,t+=&quot;&quot;;(n=Rr.exec(e))&&(r=Mr.exec(t));)(o=r.index)>a&&(o=t.slice(a,o),s[i]?s[i]+=o:s[++i]=o),(n=n[0])===(r=r[0])?s[i]?s[i]+=r:s[++i]=r:(s[++i]=null,l.push({i:i,x:Or(n,r)})),a=Mr.lastIndex;return a<t.length&&(o=t.slice(a),s[i]?s[i]+=o:s[++i]=o),s.length<2?l[0]?function(e){return function(t){return e(t)+&quot;&quot;}}(l[0].x):function(e){return function(){return e}}(t):(t=l.length,function(e){for(var n,r=0;r<t;++r)s[(n=l[r]).i]=n.x(e);return s.join(&quot;&quot;)})}function Vr(e,t){t||(t=[]);var n,r=e?Math.min(t.length,e.length):0,o=t.slice();return function(a){for(n=0;n<r;++n)o[n]=e[n]*(1-a)+t[n]*a;return o}}function Dr(e,t){var n,r=typeof t;return null==t||&quot;boolean&quot;===r?xr(t):(&quot;number&quot;===r?Or:&quot;string&quot;===r?(n=or(t))?(t=n,Sr):Er:t instanceof or?Sr:t instanceof Date?wr:function(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}(t)?Vr:Array.isArray(t)?Ir:&quot;function&quot;!=typeof t.valueOf&&&quot;function&quot;!=typeof t.toString||isNaN(t)?Pr:Or)(e,t)}function Lr(e,t){return e=+e,t=+t,function(n){return Math.round(e*(1-n)+t*n)}}function Br(e){return+e}var Nr=[0,1];function Fr(e){return e}function _r(e,t){return(t-=e=+e)?function(n){return(n-e)/t}:function(e){return function(){return e}}(isNaN(t)?NaN:.5)}function kr(e,t,n){var r=e[0],o=e[1],a=t[0],i=t[1];return o<r?(r=_r(o,r),a=n(i,a)):(r=_r(r,o),a=n(a,i)),function(e){return a(r(e))}}function Gr(e,t,n){var r=Math.min(e.length,t.length)-1,o=new Array(r),a=new Array(r),i=-1;for(e[r]<e[0]&&(e=e.slice().reverse(),t=t.slice().reverse());++i<r;)o[i]=_r(e[i],e[i+1]),a[i]=n(t[i],t[i+1]);return function(t){var n=kn(e,t,1,r)-1;return a[n](o[n](t))}}function Ur(e,t){switch(arguments.length){case 0:break;case 1:this.range(e);break;default:this.range(t).domain(e)}return this}var zr,Wr=/^(?:(.)?([<>=^]))?([+\\-( ])?([$#])?(0)?(\\d+)?(,)?(\\.\\d+)?(~)?([a-z%])?$/i;function Hr(e){if(!(t=Wr.exec(e)))throw new Error(&quot;invalid format: &quot;+e);var t;return new jr({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}function jr(e){this.fill=void 0===e.fill?&quot; &quot;:e.fill+&quot;&quot;,this.align=void 0===e.align?&quot;>&quot;:e.align+&quot;&quot;,this.sign=void 0===e.sign?&quot;-&quot;:e.sign+&quot;&quot;,this.symbol=void 0===e.symbol?&quot;&quot;:e.symbol+&quot;&quot;,this.zero=!!e.zero,this.width=void 0===e.width?void 0:+e.width,this.comma=!!e.comma,this.precision=void 0===e.precision?void 0:+e.precision,this.trim=!!e.trim,this.type=void 0===e.type?&quot;&quot;:e.type+&quot;&quot;}function Kr(e,t){if((n=(e=t?e.toExponential(t-1):e.toExponential()).indexOf(&quot;e&quot;))<0)return null;var n,r=e.slice(0,n);return[r.length>1?r[0]+r.slice(2):r,+e.slice(n+1)]}function $r(e){return(e=Kr(Math.abs(e)))?e[1]:NaN}function qr(e,t){var n=Kr(e,t);if(!n)return e+&quot;&quot;;var r=n[0],o=n[1];return o<0?&quot;0.&quot;+new Array(-o).join(&quot;0&quot;)+r:r.length>o+1?r.slice(0,o+1)+&quot;.&quot;+r.slice(o+1):r+new Array(o-r.length+2).join(&quot;0&quot;)}Hr.prototype=jr.prototype,jr.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?&quot;0&quot;:&quot;&quot;)+(void 0===this.width?&quot;&quot;:Math.max(1,0|this.width))+(this.comma?&quot;,&quot;:&quot;&quot;)+(void 0===this.precision?&quot;&quot;:&quot;.&quot;+Math.max(0,0|this.precision))+(this.trim?&quot;~&quot;:&quot;&quot;)+this.type};var Xr={&quot;%&quot;:(e,t)=>(100*e).toFixed(t),b:e=>Math.round(e).toString(2),c:e=>e+&quot;&quot;,d:function(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString(&quot;en&quot;).replace(/,/g,&quot;&quot;):e.toString(10)},e:(e,t)=>e.toExponential(t),f:(e,t)=>e.toFixed(t),g:(e,t)=>e.toPrecision(t),o:e=>Math.round(e).toString(8),p:(e,t)=>qr(100*e,t),r:qr,s:function(e,t){var n=Kr(e,t);if(!n)return e+&quot;&quot;;var r=n[0],o=n[1],a=o-(zr=3*Math.max(-8,Math.min(8,Math.floor(o/3))))+1,i=r.length;return a===i?r:a>i?r+new Array(a-i+1).join(&quot;0&quot;):a>0?r.slice(0,a)+&quot;.&quot;+r.slice(a):&quot;0.&quot;+new Array(1-a).join(&quot;0&quot;)+Kr(e,Math.max(0,t+a-1))[0]},X:e=>Math.round(e).toString(16).toUpperCase(),x:e=>Math.round(e).toString(16)};function Yr(e){return e}var Zr,Qr,Jr,eo=Array.prototype.map,to=[&quot;y&quot;,&quot;z&quot;,&quot;a&quot;,&quot;f&quot;,&quot;p&quot;,&quot;n&quot;,&quot;µ&quot;,&quot;m&quot;,&quot;&quot;,&quot;k&quot;,&quot;M&quot;,&quot;G&quot;,&quot;T&quot;,&quot;P&quot;,&quot;E&quot;,&quot;Z&quot;,&quot;Y&quot;];function no(e){var t=e.domain;return e.ticks=function(e){var n=t();return function(e,t,n){var r,o,a,i,s=-1;if(n=+n,(e=+e)==(t=+t)&&n>0)return[e];if((r=t<e)&&(o=e,e=t,t=o),0===(i=Ln(e,t,n))||!isFinite(i))return[];if(i>0){let n=Math.round(e/i),r=Math.round(t/i);for(n*i<e&&++n,r*i>t&&--r,a=new Array(o=r-n+1);++s<o;)a[s]=(n+s)*i}else{i=-i;let n=Math.round(e*i),r=Math.round(t*i);for(n/i<e&&++n,r/i>t&&--r,a=new Array(o=r-n+1);++s<o;)a[s]=(n+s)/i}return r&&a.reverse(),a}(n[0],n[n.length-1],null==e?10:e)},e.tickFormat=function(e,n){var r=t();return function(e,t,n,r){var o,a=function(e,t,n){var r=Math.abs(t-e)/Math.max(0,n),o=Math.pow(10,Math.floor(Math.log(r)/Math.LN10)),a=r/o;return a>=En?o*=10:a>=Vn?o*=5:a>=Dn&&(o*=2),t<e?-o:o}(e,t,n);switch((r=Hr(null==r?&quot;,f&quot;:r)).type){case&quot;s&quot;:var i=Math.max(Math.abs(e),Math.abs(t));return null!=r.precision||isNaN(o=function(e,t){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor($r(t)/3)))-$r(Math.abs(e)))}(a,i))||(r.precision=o),Jr(r,i);case&quot;&quot;:case&quot;e&quot;:case&quot;g&quot;:case&quot;p&quot;:case&quot;r&quot;:null!=r.precision||isNaN(o=function(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,$r(t)-$r(e))+1}(a,Math.max(Math.abs(e),Math.abs(t))))||(r.precision=o-(&quot;e&quot;===r.type));break;case&quot;f&quot;:case&quot;%&quot;:null!=r.precision||isNaN(o=function(e){return Math.max(0,-$r(Math.abs(e)))}(a))||(r.precision=o-2*(&quot;%&quot;===r.type))}return Qr(r)}(r[0],r[r.length-1],null==e?10:e,n)},e.nice=function(n){null==n&&(n=10);var r,o,a=t(),i=0,s=a.length-1,l=a[i],c=a[s],u=10;for(c<l&&(o=l,l=c,c=o,o=i,i=s,s=o);u-- >0;){if((o=Ln(l,c,n))===r)return a[i]=l,a[s]=c,t(a);if(o>0)l=Math.floor(l/o)*o,c=Math.ceil(c/o)*o;else{if(!(o<0))break;l=Math.ceil(l*o)/o,c=Math.floor(c*o)/o}r=o}return e},e}function ro(){var e=function(){var e,t,n,r,o,a,i=Nr,s=Nr,l=Dr,c=Fr;function u(){var e,t,n,l=Math.min(i.length,s.length);return c!==Fr&&(e=i[0],t=i[l-1],e>t&&(n=e,e=t,t=n),c=function(n){return Math.max(e,Math.min(t,n))}),r=l>2?Gr:kr,o=a=null,d}function d(t){return null==t||isNaN(t=+t)?n:(o||(o=r(i.map(e),s,l)))(e(c(t)))}return d.invert=function(n){return c(t((a||(a=r(s,i.map(e),Or)))(n)))},d.domain=function(e){return arguments.length?(i=Array.from(e,Br),u()):i.slice()},d.range=function(e){return arguments.length?(s=Array.from(e),u()):s.slice()},d.rangeRound=function(e){return s=Array.from(e),l=Lr,u()},d.clamp=function(e){return arguments.length?(c=!!e||Fr,u()):c!==Fr},d.interpolate=function(e){return arguments.length?(l=e,u()):l},d.unknown=function(e){return arguments.length?(n=e,d):n},function(n,r){return e=n,t=r,u()}}()(Fr,Fr);return e.copy=function(){return t=e,ro().domain(t.domain()).range(t.range()).interpolate(t.interpolate()).clamp(t.clamp()).unknown(t.unknown());var t},Ur.apply(e,arguments),no(e)}Zr=function(e){var t,n,r=void 0===e.grouping||void 0===e.thousands?Yr:(t=eo.call(e.grouping,Number),n=e.thousands+&quot;&quot;,function(e,r){for(var o=e.length,a=[],i=0,s=t[0],l=0;o>0&&s>0&&(l+s+1>r&&(s=Math.max(1,r-l)),a.push(e.substring(o-=s,o+s)),!((l+=s+1)>r));)s=t[i=(i+1)%t.length];return a.reverse().join(n)}),o=void 0===e.currency?&quot;&quot;:e.currency[0]+&quot;&quot;,a=void 0===e.currency?&quot;&quot;:e.currency[1]+&quot;&quot;,i=void 0===e.decimal?&quot;.&quot;:e.decimal+&quot;&quot;,s=void 0===e.numerals?Yr:function(e){return function(t){return t.replace(/[0-9]/g,(function(t){return e[+t]}))}}(eo.call(e.numerals,String)),l=void 0===e.percent?&quot;%&quot;:e.percent+&quot;&quot;,c=void 0===e.minus?&quot;−&quot;:e.minus+&quot;&quot;,u=void 0===e.nan?&quot;NaN&quot;:e.nan+&quot;&quot;;function d(e){var t=(e=Hr(e)).fill,n=e.align,d=e.sign,p=e.symbol,f=e.zero,g=e.width,m=e.comma,h=e.precision,v=e.trim,T=e.type;&quot;n&quot;===T?(m=!0,T=&quot;g&quot;):Xr[T]||(void 0===h&&(h=12),v=!0,T=&quot;g&quot;),(f||&quot;0&quot;===t&&&quot;=&quot;===n)&&(f=!0,t=&quot;0&quot;,n=&quot;=&quot;);var y=&quot;$&quot;===p?o:&quot;#&quot;===p&&/[boxX]/.test(T)?&quot;0&quot;+T.toLowerCase():&quot;&quot;,b=&quot;$&quot;===p?a:/[%p]/.test(T)?l:&quot;&quot;,x=Xr[T],C=/[defgprs%]/.test(T);function S(e){var o,a,l,p=y,S=b;if(&quot;c&quot;===T)S=x(e)+S,e=&quot;&quot;;else{var A=(e=+e)<0||1/e<0;if(e=isNaN(e)?u:x(Math.abs(e),h),v&&(e=function(e){e:for(var t,n=e.length,r=1,o=-1;r<n;++r)switch(e[r]){case&quot;.&quot;:o=t=r;break;case&quot;0&quot;:0===o&&(o=r),t=r;break;default:if(!+e[r])break e;o>0&&(o=0)}return o>0?e.slice(0,o)+e.slice(t+1):e}(e)),A&&0==+e&&&quot;+&quot;!==d&&(A=!1),p=(A?&quot;(&quot;===d?d:c:&quot;-&quot;===d||&quot;(&quot;===d?&quot;&quot;:d)+p,S=(&quot;s&quot;===T?to[8+zr/3]:&quot;&quot;)+S+(A&&&quot;(&quot;===d?&quot;)&quot;:&quot;&quot;),C)for(o=-1,a=e.length;++o<a;)if(48>(l=e.charCodeAt(o))||l>57){S=(46===l?i+e.slice(o+1):e.slice(o))+S,e=e.slice(0,o);break}}m&&!f&&(e=r(e,1/0));var I=p.length+e.length+S.length,w=I<g?new Array(g-I+1).join(t):&quot;&quot;;switch(m&&f&&(e=r(w+e,w.length?g-S.length:1/0),w=&quot;&quot;),n){case&quot;<&quot;:e=p+e+S+w;break;case&quot;=&quot;:e=p+w+e+S;break;case&quot;^&quot;:e=w.slice(0,I=w.length>>1)+p+e+S+w.slice(I);break;default:e=w+p+e+S}return s(e)}return h=void 0===h?6:/[gprs]/.test(T)?Math.max(1,Math.min(21,h)):Math.max(0,Math.min(20,h)),S.toString=function(){return e+&quot;&quot;},S}return{format:d,formatPrefix:function(e,t){var n=d(((e=Hr(e)).type=&quot;f&quot;,e)),r=3*Math.max(-8,Math.min(8,Math.floor($r(t)/3))),o=Math.pow(10,-r),a=to[8+r/3];return function(e){return n(o*e)+a}}}}({thousands:&quot;,&quot;,grouping:[3],currency:[&quot;$&quot;,&quot;&quot;]}),Qr=Zr.format,Jr=Zr.formatPrefix;var oo=n(318);const ao=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],io=[1,0,0,0,1,0,0,0,1],so=1e-6,lo=1e-12,{vtkErrorMacro:co,vtkWarningMacro:uo}=Wt;let po=0;function fo(e){return()=>co(`vtkMath::${e} - NOT IMPLEMENTED`)}function go(e,t,n,r){let o;for(let a=0;a<t;a++)o=e[n*t+a],e[n*t+a]=e[r*t+a],e[r*t+a]=o}function mo(e,t,n,r){let o;for(let a=0;a<t;a++)o=e[a*t+n],e[a*t+n]=e[a*t+r],e[a*t+r]=o}function ho(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:3;const t=Array(e);for(let n=0;n<e;++n)t[n]=0;return t}function vo(e){return e/180*Math.PI}function To(e){return 180*e/Math.PI}const{round:yo,floor:bo,ceil:xo,min:Co,max:So}=Math;const Ao=fo(&quot;ceilLog2&quot;),Io=fo(&quot;factorial&quot;);function wo(e){let t=1;for(;t<e;)t*=2;return t}function Oo(e){return e===wo(e)}const Po=fo(&quot;gaussian&quot;);function Ro(e,t,n){return n[0]=e[0]+t[0],n[1]=e[1]+t[1],n[2]=e[2]+t[2],n}function Mo(e,t,n){return n[0]=e[0]-t[0],n[1]=e[1]-t[1],n[2]=e[2]-t[2],n}function Eo(e,t){return e[0]*=t,e[1]*=t,e[2]*=t,e}function Vo(e,t){return e[0]*=t,e[1]*=t,e}function Do(e,t,n,r){return r[0]=e[0]+t[0]*n,r[1]=e[1]+t[1]*n,r[2]=e[2]+t[2]*n,r}function Lo(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function Bo(e,t,n){const r=e[1]*t[2]-e[2]*t[1],o=e[2]*t[0]-e[0]*t[2],a=e[0]*t[1]-e[1]*t[0];return n[0]=r,n[1]=o,n[2]=a,n}function No(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:3;switch(t){case 1:return Math.abs(e);case 2:return Math.sqrt(e[0]*e[0]+e[1]*e[1]);case 3:return Math.sqrt(e[0]*e[0]+e[1]*e[1]+e[2]*e[2]);default:{let n=0;for(let r=0;r<t;r++)n+=e[r]*e[r];return Math.sqrt(n)}}}function Fo(e){const t=No(e);return 0!==t&&(e[0]/=t,e[1]/=t,e[2]/=t),t}function _o(e){const t=No(e,3);return 0!==t&&(e[0]/=t,e[1]/=t,e[2]/=t,e[3]/=t),t}function ko(e,t){return e[0]*t[0]+e[1]*t[1]}function Go(e,t){return(e[0]-t[0])*(e[0]-t[0])+(e[1]-t[1])*(e[1]-t[1])+(e[2]-t[2])*(e[2]-t[2])}function Uo(e){return Math.sqrt(e[0]*e[0]+e[1]*e[1])}function zo(e){const t=Uo(e);return 0!==t&&(e[0]/=t,e[1]/=t),t}function Wo(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return 2===t.length?t[0][0]*t[1][1]-t[1][0]*t[0][1]:4===t.length?t[0]*t[3]-t[1]*t[2]:Number.NaN}function Ho(e,t,n){const r=e[0]*t[0]+e[1]*t[1]+e[2]*t[2],o=e[3]*t[0]+e[4]*t[1]+e[5]*t[2],a=e[6]*t[0]+e[7]*t[1]+e[8]*t[2];n[0]=r,n[1]=o,n[2]=a}function jo(e,t,n){const r=[...e],o=[...t];for(let e=0;e<3;e++)n[e]=r[0]*o[e]+r[1]*o[e+3]+r[2]*o[e+6],n[e+3]=r[3]*o[e]+r[4]*o[e+3]+r[5]*o[e+6],n[e+6]=r[6]*o[e]+r[7]*o[e+3]+r[8]*o[e+6]}function Ko(e,t){let n;n=e[3],t[3]=e[1],t[1]=n,n=e[6],t[6]=e[2],t[2]=n,n=e[7],t[7]=e[5],t[5]=n,t[0]=e[0],t[4]=e[4],t[8]=e[8]}function $o(e){return e[0]*e[4]*e[8]+e[3]*e[7]*e[2]+e[6]*e[1]*e[5]-e[0]*e[7]*e[5]-e[3]*e[1]*e[8]-e[6]*e[4]*e[2]}function qo(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:so;return e.length===t.length&&e.every((function(e,r){return Math.abs(e-t[r])<=n}))}const Xo=qo;function Yo(e){for(let t=0;t<3;t++)e[3*t]=e[3*t+1]=e[3*t+2]=0,e[3*t+t]=1}function Zo(e,t){for(let n=0;n<e;n++){for(let r=0;r<e;r++)t[n*e+r]=0;t[n*e+n]=1}return t}function Qo(e,t){const n=e[0]*e[0],r=e[0]*e[1],o=e[0]*e[2],a=e[0]*e[3],i=e[1]*e[1],s=e[2]*e[2],l=e[3]*e[3],c=e[1]*e[2],u=e[1]*e[3],d=e[2]*e[3],p=i+s+l;let f=1/(n+p);const g=(n-p)*f;f*=2,t[0]=i*f+g,t[3]=(c+a)*f,t[6]=(u-o)*f,t[1]=(c-a)*f,t[4]=s*f+g,t[7]=(d+r)*f,t[2]=(u+o)*f,t[5]=(d-r)*f,t[8]=l*f+g}function Jo(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;if(!`${e}`.includes(&quot;e&quot;))return+`${Math.round(`${e}e+${t}`)}e-${t}`;const n=`${e}`.split(&quot;e&quot;);let r=&quot;&quot;;return+n[1]+t>0&&(r=&quot;+&quot;),+`${Math.round(`${+n[0]}e${r}${+n[1]+t}`)}e-${t}`}function ea(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[0,0,0],n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:0;return t[0]=Jo(e[0],n),t[1]=Jo(e[1],n),t[2]=Jo(e[2],n),t}function ta(e,t,n,r){let o,a,i,s,l,c,u,d,p,f,g,m,h,v,T,y;const b=ho(t),x=ho(t),C=(e,t,n)=>{v=e[t],h=e[n],e[t]=v-m*(h+v*f),e[n]=h+m*(v-h*f)};for(Zo(t,r),l=0;l<t;l++)b[l]=n[l]=e[l+l*t],x[l]=0;for(o=0;o<20;o++){for(g=0,l=0;l<t-1;l++)for(s=l+1;s<t;s++)g+=Math.abs(e[l*t+s]);if(0===g)break;for(u=o<3?.2*g/(t*t):0,l=0;l<t-1;l++)for(s=l+1;s<t;s++)if(v=100*Math.abs(e[l*t+s]),o>3&&Math.abs(n[l])+v===Math.abs(n[l])&&Math.abs(n[s])+v===Math.abs(n[s]))e[l*t+s]=0;else if(Math.abs(e[l*t+s])>u){for(h=n[s]-n[l],Math.abs(h)+v===Math.abs(h)?p=e[l*t+s]/h:(d=.5*h/e[l*t+s],p=1/(Math.abs(d)+Math.sqrt(1+d*d)),d<0&&(p=-p)),T=1/Math.sqrt(1+p*p),m=p*T,f=m/(1+T),h=p*e[l*t+s],x[l]-=h,x[s]+=h,n[l]-=h,n[s]+=h,e[l*t+s]=0,a=0;a<=l-1;a++)C(e,a*t+l,a*t+s);for(a=l+1;a<=s-1;a++)C(e,l*t+a,a*t+s);for(a=s+1;a<t;a++)C(e,l*t+a,s*t+a);for(a=0;a<t;a++)C(r,a*t+l,a*t+s)}for(l=0;l<t;l++)b[l]+=x[l],n[l]=b[l],x[l]=0}if(o>=20)return uo(&quot;vtkMath::Jacobi: Error extracting eigenfunctions&quot;),0;for(a=0;a<t-1;a++){for(i=a,y=n[i],o=a+1;o<t;o++)(n[o]>=y||Math.abs(n[o]-y)<lo)&&(i=o,y=n[i]);i!==a&&(n[i]=n[a],n[a]=y,mo(r,t,a,i))}const S=(t>>1)+(1&t);for(c=0,o=0;o<t*t;o++)r[o]>=0&&c++;if(c<S)for(o=0;o<t;o++)r[o*t+a]*=-1;return 1}function na(e,t){const n=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];n[0]=e[0]+e[4]+e[8],n[5]=e[0]-e[4]-e[8],n[10]=-e[0]+e[4]-e[8],n[15]=-e[0]-e[4]+e[8],n[1]=n[4]=e[7]-e[5],n[2]=n[8]=e[2]-e[6],n[3]=n[12]=e[3]-e[1],n[6]=n[9]=e[3]+e[1],n[7]=n[13]=e[2]+e[6],n[11]=n[14]=e[7]+e[5];const r=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];ta([...n],4,[0,0,0,0],r),t[0]=r[0],t[1]=r[4],t[2]=r[8],t[3]=r[12]}function ra(e,t){for(let n=0;n<9;n++)t[n]=e[n];const n=ho(3),r=ho(3);let o;for(let e=0;e<3;e++){const r=Math.abs(t[3*e]),a=Math.abs(t[3*e+1]),i=Math.abs(t[3*e+2]);o=a>r?a:r,o=i>o?i:o,n[e]=1,0!==o&&(n[e]/=o)}const a=Math.abs(t[0])*n[0],i=Math.abs(t[3])*n[1],s=Math.abs(t[6])*n[2];r[0]=0,o=a,i>=o&&(o=i,r[0]=1),s>=o&&(r[0]=2),0!==r[0]&&(mo(t,3,r[0],0),n[r[0]]=n[0]);const l=Math.abs(t[4])*n[1],c=Math.abs(t[7])*n[2];r[1]=1,o=l,c>=o&&(r[1]=2,mo(t,3,1,2)),r[2]=2;let u=0;if($o(t)<0){u=1;for(let e=0;e<9;e++)t[e]=-t[e]}const d=ho(4);if(na(t,d),Qo(d,t),u)for(let e=0;e<9;e++)t[e]=-t[e];1!==r[1]&&mo(t,3,r[1],1),0!==r[0]&&mo(t,3,r[0],0)}function oa(e,t,n){let r,o,a,i,s,l;if(ta([...e],3,t,n),t[0]!==t[1]||t[0]!==t[2]){for(Ko(n,n),r=0;r<3;r++)if(t[(r+1)%3]===t[(r+2)%3]){for(l=Math.abs(n[3*r]),i=0,o=1;o<3;o++)l<(s=Math.abs(n[3*r+o]))&&(l=s,i=o);i!==r&&(s=t[i],t[i]=t[r],t[r]=s,go(n,3,r,i)),n[3*i+i]<0&&(n[3*i]=-n[3*i],n[3*i+1]=-n[3*i+1],n[3*i+2]=-n[3*i+2]),o=(i+1)%3,a=(i+2)%3,n[3*o]=0,n[3*o+1]=0,n[3*o+2]=0,n[3*o+o]=1;const e=Bo([n[3*i],n[3*i+1],n[3*i+2]],[n[3*o],n[3*o+1],n[3*o+2]],[]);Fo(e);const c=Bo(e,[n[3*i],n[3*i+1],n[3*i+2]],[]);for(let t=0;t<3;t++)n[3*a+t]=e[t],n[3*o+t]=c[t];return void Ko(n,n)}for(l=Math.abs(n[0]),i=0,r=1;r<3;r++)l<(s=Math.abs(n[3*r]))&&(l=s,i=r);if(0!==i){const e=t[i];t[i]=t[0],t[0]=e,go(n,3,i,0)}if(Math.abs(n[4])<Math.abs(n[7])){const e=t[2];t[2]=t[1],t[1]=e,go(n,3,1,2)}for(r=0;r<2;r++)n[3*r+r]<0&&(n[3*r]=-n[3*r],n[3*r+1]=-n[3*r+1],n[3*r+2]=-n[3*r+2]);$o(n)<0&&(n[6]=-n[6],n[7]=-n[7],n[8]=-n[8]),Ko(n,n)}else Yo(n)}function aa(e,t,n){let r,o,a,i,s,l,c,u=0;const d=ho(n);for(r=0;r<n;r++){for(i=0,o=0;o<n;o++)(c=Math.abs(e[r*n+o]))>i&&(i=c);if(0===i)return uo(&quot;Unable to factor linear system&quot;),0;d[r]=1/i}for(o=0;o<n;o++){for(r=0;r<o;r++){for(s=e[r*n+o],a=0;a<r;a++)s-=e[r*n+a]*e[a*n+o];e[r*n+o]=s}for(i=0,r=o;r<n;r++){for(s=e[r*n+o],a=0;a<o;a++)s-=e[r*n+a]*e[a*n+o];e[r*n+o]=s,(l=d[r]*Math.abs(s))>=i&&(i=l,u=r)}if(o!==u){for(a=0;a<n;a++)l=e[u*n+a],e[u*n+a]=e[o*n+a],e[o*n+a]=l;d[u]=d[o]}if(t[o]=u,Math.abs(e[o*n+o])<=lo)return uo(&quot;Unable to factor linear system&quot;),0;if(o!==n-1)for(l=1/e[o*n+o],r=o+1;r<n;r++)e[r*n+o]*=l}return 1}function ia(e,t,n,r){let o,a,i,s,l;for(i=-1,o=0;o<r;o++){if(s=t[o],l=n[s],n[s]=n[o],i>=0)for(a=i;a<=o-1;a++)l-=e[o*r+a]*n[a];else 0!==l&&(i=o);n[o]=l}for(o=r-1;o>=0;o--){for(l=n[o],a=o+1;a<r;a++)l-=e[o*r+a]*n[a];n[o]=l/e[o*r+o]}}function sa(e,t,n){if(2===n){const n=ho(2),r=Wo(e[0],e[1],e[2],e[3]);return 0===r?0:(n[0]=(e[3]*t[0]-e[1]*t[1])/r,n[1]=(-e[2]*t[0]+e[0]*t[1])/r,t[0]=n[0],t[1]=n[1],1)}if(1===n)return 0===e[0]?0:(t[0]/=e[0],1);const r=ho(n);return 0===aa(e,r,n)?0:(ia(e,r,t,n),1)}function la(e,t,n){let r=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null;const o=(arguments.length>3&&void 0!==arguments[3]?arguments[3]:null)||ho(n),a=r||ho(n);if(0===aa(e,o,n))return null;for(let r=0;r<n;r++){for(let e=0;e<n;e++)a[e]=0;a[r]=1,ia(e,o,a,n);for(let e=0;e<n;e++)t[e*n+r]=a[e]}return t}function ca(e,t,n,r){if(e<n)return uo(&quot;Insufficient number of samples. Underdetermined.&quot;),0;let o,a,i;const s=ho(n*n),l=ho(n),c=ho(n*n);for(i=0;i<e;i++)for(o=0;o<n;o++)for(a=o;a<n;a++)s[o*n+a]+=t[i*n+o]*t[i*n+a];for(o=0;o<n;o++)for(a=0;a<o;a++)s[o*n+a]=s[a*n+o];for(ta(s,n,l,c),o=0;o<n;o++)r[o]=c[o*n+n-1];return 1}function ua(e,t){let n,r;const[o,a,i]=e,s=1/6;let l=o,c=o;a>l?l=a:a<c&&(c=a),i>l?l=i:i<c&&(c=i);const u=l;r=u>0?(l-c)/l:0,r>0?(n=o===l?s*(a-i)/(l-c):a===l?1/3+s*(i-o)/(l-c):2/3+s*(o-a)/(l-c),n<0&&(n+=1)):n=0,t[0]=n,t[1]=r,t[2]=u}function da(e,t){const[n,r,o]=e,a=1/3,i=1/6,s=2/3,l=5/6;let c,u,d;n>i&&n<=a?(u=1,c=(a-n)/i,d=0):n>a&&n<=.5?(u=1,d=(n-a)/i,c=0):n>.5&&n<=s?(d=1,u=(s-n)/i,c=0):n>s&&n<=l?(d=1,c=(n-s)/i,u=0):n>l&&n<=1?(c=1,d=(1-n)/i,u=0):(c=1,u=n/i,d=0),c=r*c+(1-r),u=r*u+(1-r),d=r*d+(1-r),c*=o,u*=o,d*=o,t[0]=c,t[1]=u,t[2]=d}function pa(e,t){const[n,r,o]=e;let a=(n+16)/116,i=r/500+a,s=a-o/200;a**3>.008856?a**=3:a=(a-16/116)/7.787,i**3>.008856?i**=3:i=(i-16/116)/7.787,s**3>.008856?s**=3:s=(s-16/116)/7.787,t[0]=.9505*i,t[1]=1*a,t[2]=1.089*s}function fa(e,t){const[n,r,o]=e;let a=n/.9505,i=r/1,s=o/1.089;a>.008856?a**=1/3:a=7.787*a+16/116,i>.008856?i**=1/3:i=7.787*i+16/116,s>.008856?s**=1/3:s=7.787*s+16/116,t[0]=116*i-16,t[1]=500*(a-i),t[2]=200*(i-s)}function ga(e,t){const[n,r,o]=e;let a=3.2406*n+-1.5372*r+-.4986*o,i=-.9689*n+1.8758*r+.0415*o,s=.0557*n+-.204*r+1.057*o;a>.0031308?a=1.055*a**(1/2.4)-.055:a*=12.92,i>.0031308?i=1.055*i**(1/2.4)-.055:i*=12.92,s>.0031308?s=1.055*s**(1/2.4)-.055:s*=12.92;let l=a;l<i&&(l=i),l<s&&(l=s),l>1&&(a/=l,i/=l,s/=l),a<0&&(a=0),i<0&&(i=0),s<0&&(s=0),t[0]=a,t[1]=i,t[2]=s}function ma(e,t){let[n,r,o]=e;n>.04045?n=((n+.055)/1.055)**2.4:n/=12.92,r>.04045?r=((r+.055)/1.055)**2.4:r/=12.92,o>.04045?o=((o+.055)/1.055)**2.4:o/=12.92,t[0]=.4124*n+.3576*r+.1805*o,t[1]=.2126*n+.7152*r+.0722*o,t[2]=.0193*n+.1192*r+.9505*o}function ha(e,t){const n=[0,0,0];ma(e,n),fa(n,t)}function va(e,t){const n=[0,0,0];pa(e,n),ga(n,t)}function Ta(e){return e[0]=1,e[1]=-1,e[2]=1,e[3]=-1,e[4]=1,e[5]=-1,e}function ya(e){return!(e[1]-e[0]<0)}function ba(e,t,n){return e<t?t:e>n?n:e}function xa(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[0,0,0];return r[0]=ba(e[0],t[0],n[0]),r[1]=ba(e[1],t[1],n[1]),r[2]=ba(e[2],t[2],n[2]),r}const Ca=fo(&quot;GetScalarTypeFittingRange&quot;),Sa=fo(&quot;GetAdjustedScalarRange&quot;);const Aa=e=>!Number.isFinite(e),{isFinite:Ia,isNaN:wa}=Number,Oa=wa;function Pa(){return[].concat([Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE])}function Ra(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:3;const n=new Array(t),r=new Array(t);for(let e=0;e<t;++e)n[e]=e,r[e]=e;for(let o=t-1;o>0;o--){let a=-1/0,i=0,s=0;for(let l=0;l<=o;++l){const c=n[l];for(let n=0;n<=o;++n){const o=r[n],u=Math.abs(e[c+t*o]);u>a&&(a=u,i=l,s=n)}}[n[o],n[i]]=[n[i],n[o]],[r[o],r[s]]=[r[s],r[o]]}const o=new Array(t*t).fill(0);for(let a=0;a<t;++a){const i=n[a]+t*r[a];o[i]=e[i]<0?-1:1}return o}function Ma(e){const t=Math.floor(255*e);return t>15?t.toString(16):`0${t.toString(16)}`}function Ea(e){return Math.round(255*e)}var Va,Da={Pi:()=>Math.PI,ldexp:function(e,t){return t>1023?e*2**1023*2**(t-1023):t<-1074?5e-324*e*2**(t+1074):e*2**t},radiansFromDegrees:vo,degreesFromRadians:To,round:yo,floor:bo,ceil:xo,ceilLog2:Ao,min:Co,max:So,arrayMin:function(e){let t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,n=1/0;for(let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,o=e.length;r<o;r+=t)e[r]<n&&(n=e[r]);return n},arrayMax:function(e){let t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,n=-1/0;for(let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,o=e.length;r<o;r+=t)n<e[r]&&(n=e[r]);return n},arrayRange:function(e){let t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,n=1/0,r=-1/0;for(let o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,a=e.length;o<a;o+=t)e[o]<n&&(n=e[o]),r<e[o]&&(r=e[o]);return[n,r]},isPowerOfTwo:Oo,nearestPowerOfTwo:wo,factorial:Io,binomial:function(e,t){let n=1;for(let r=1;r<=t;++r)n*=(e-r+1)/r;return Math.floor(n)},beginCombination:function(e,t){if(e<t)return 0;const n=ho(t);for(let e=0;e<t;++e)n[e]=e;return n},nextCombination:function(e,t,n){let r=0;for(let o=t-1;o>=0;--o)if(n[o]<e-t+o){let e=n[o]+1;for(;o<t;)n[o++]=e++;r=1;break}return r},randomSeed:function(e){oo(`${e}`,{global:!0}),po=e},getSeed:function(){return po},random:function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return e+((arguments.length>1&&void 0!==arguments[1]?arguments[1]:1)-e)*Math.random()},gaussian:Po,add:Ro,subtract:Mo,multiplyScalar:Eo,multiplyScalar2D:Vo,multiplyAccumulate:Do,multiplyAccumulate2D:function(e,t,n,r){return r[0]=e[0]+t[0]*n,r[1]=e[1]+t[1]*n,r},dot:Lo,outer:function(e,t,n){n[0]=e[0]*t[0],n[1]=e[0]*t[1],n[2]=e[0]*t[2],n[3]=e[1]*t[0],n[4]=e[1]*t[1],n[5]=e[1]*t[2],n[6]=e[2]*t[0],n[7]=e[2]*t[1],n[8]=e[2]*t[2]},cross:Bo,norm:No,normalize:Fo,perpendiculars:function(e,t,n,r){const o=e[0]*e[0],a=e[1]*e[1],i=e[2]*e[2],s=Math.sqrt(o+a+i);let l,c,u;o>a&&o>i?(l=0,c=1,u=2):a>i?(l=1,c=2,u=0):(l=2,c=0,u=1);const d=e[l]/s,p=e[c]/s,f=e[u]/s,g=Math.sqrt(d*d+f*f);if(0!==r){const e=Math.sin(r),o=Math.cos(r);t&&(t[l]=(f*o-d*p*e)/g,t[c]=e*g,t[u]=(-d*o-p*f*e)/g),n&&(n[l]=(-f*e-d*p*o)/g,n[c]=o*g,n[u]=(d*e-p*f*o)/g)}else t&&(t[l]=f/g,t[c]=0,t[u]=-d/g),n&&(n[l]=-d*p/g,n[c]=g,n[u]=-p*f/g)},projectVector:function(e,t,n){const r=Lo(t,t);if(0===r)return n[0]=0,n[1]=0,n[2]=0,!1;const o=Lo(e,t)/r;for(let e=0;e<3;e++)n[e]=t[e];return Eo(n,o),!0},projectVector2D:function(e,t,n){const r=ko(t,t);if(0===r)return n[0]=0,n[1]=0,!1;const o=ko(e,t)/r;for(let e=0;e<2;e++)n[e]=t[e];return Vo(n,o),!0},distance2BetweenPoints:Go,angleBetweenVectors:function(e,t){const n=[0,0,0];return Bo(e,t,n),Math.atan2(No(n),Lo(e,t))},gaussianAmplitude:function(e,t,n){const r=Math.abs(e-n);return 1/Math.sqrt(2*Math.PI*t)*Math.exp(-(r**2)/(2*t))},gaussianWeight:function(e,t,n){const r=Math.abs(e-n);return Math.exp(-(r**2)/(2*t))},dot2D:ko,outer2D:function(e,t,n){n[0]=e[0]*t[0],n[1]=e[0]*t[1],n[2]=e[1]*t[0],n[3]=e[1]*t[1]},norm2D:Uo,normalize2D:zo,determinant2x2:Wo,LUFactor3x3:function(e,t){let n,r,o;const a=[0,0,0];for(let t=0;t<3;t++)o=Math.abs(e[3*t]),(r=Math.abs(e[3*t+1]))>o&&(o=r),(r=Math.abs(e[3*t+2]))>o&&(o=r),a[t]=1/o;o=a[0]*Math.abs(e[0]),n=0,(r=a[1]*Math.abs(e[3]))>=o&&(o=r,n=1),(r=a[2]*Math.abs(e[6]))>=o&&(n=2),0!==n&&(go(e,3,n,0),a[n]=a[0]),t[0]=n,e[3]/=e[0],e[6]/=e[0],e[4]-=e[3]*e[1],e[7]-=e[6]*e[1],o=a[1]*Math.abs(e[4]),n=1,(r=a[2]*Math.abs(e[7]))>=o&&(n=2,go(e,3,1,2),a[2]=a[1]),t[1]=n,e[7]/=e[4],e[5]-=e[3]*e[2],e[8]-=e[6]*e[2]+e[7]*e[5],t[2]=2},LUSolve3x3:function(e,t,n){let r=n[t[0]];n[t[0]]=n[0],n[0]=r,r=n[t[1]],n[t[1]]=n[1],n[1]=r-e[3]*n[0],r=n[t[2]],n[t[2]]=n[2],n[2]=r-e[6]*n[0]-e[7]*n[1],n[2]/=e[8],n[1]=(n[1]-e[5]*n[2])/e[4],n[0]=(n[0]-e[1]*n[1]-e[2]*n[2])/e[0]},linearSolve3x3:function(e,t,n){const r=e[0],o=e[1],a=e[2],i=e[3],s=e[4],l=e[5],c=e[6],u=e[7],d=e[8],p=+Wo(s,u,l,d),f=-Wo(i,c,l,d),g=+Wo(i,c,s,u),m=-Wo(o,u,a,d),h=+Wo(r,c,a,d),v=-Wo(r,c,o,u),T=+Wo(o,s,a,l),y=-Wo(r,i,a,l),b=+Wo(r,i,o,s),x=r*p+o*f+a*g,C=p*t[0]+m*t[1]+T*t[2],S=f*t[0]+h*t[1]+y*t[2],A=g*t[0]+v*t[1]+b*t[2];n[0]=C/x,n[1]=S/x,n[2]=A/x},multiply3x3_vect3:Ho,multiply3x3_mat3:jo,multiplyMatrix:function(e,t,n,r,o,a,i){r!==o&&co(&quot;Number of columns of A must match number of rows of B.&quot;);const s=[...e],l=[...t];for(let e=0;e<n;e++)for(let t=0;t<a;t++){i[e*a+t]=0;for(let n=0;n<r;n++)i[e*a+t]+=s[e*r+n]*l[t+a*n]}},transpose3x3:Ko,invert3x3:function(e,t){const n=e[0],r=e[1],o=e[2],a=e[3],i=e[4],s=e[5],l=e[6],c=e[7],u=e[8],d=+Wo(i,c,s,u),p=-Wo(a,l,s,u),f=+Wo(a,l,i,c),g=-Wo(r,c,o,u),m=+Wo(n,l,o,u),h=-Wo(n,l,r,c),v=+Wo(r,i,o,s),T=-Wo(n,a,o,s),y=+Wo(n,a,r,i),b=n*d+r*p+o*f;0===b&&uo(&quot;Matrix has 0 determinant&quot;),t[0]=d/b,t[3]=p/b,t[6]=f/b,t[1]=g/b,t[4]=m/b,t[7]=h/b,t[2]=v/b,t[5]=T/b,t[8]=y/b},identity3x3:Yo,identity:Zo,isIdentity:function(e){return Xo(e,ao,arguments.length>1&&void 0!==arguments[1]?arguments[1]:so)},isIdentity3x3:function(e){return Xo(e,io,arguments.length>1&&void 0!==arguments[1]?arguments[1]:so)},determinant3x3:$o,quaternionToMatrix3x3:Qo,areEquals:qo,areMatricesEqual:Xo,roundNumber:Jo,roundVector:ea,matrix3x3ToQuaternion:na,multiplyQuaternion:function(e,t,n){const r=e[0]*t[0],o=e[0]*t[1],a=e[0]*t[2],i=e[0]*t[3],s=e[1]*t[0],l=e[1]*t[1],c=e[1]*t[2],u=e[1]*t[3],d=e[2]*t[0],p=e[2]*t[1],f=e[2]*t[2],g=e[2]*t[3],m=e[3]*t[0],h=e[3]*t[1],v=e[3]*t[2],T=e[3]*t[3];n[0]=r-l-f-T,n[1]=o+s+g-v,n[2]=a-u+d+h,n[3]=i+c-p+m},orthogonalize3x3:ra,diagonalize3x3:oa,singularValueDecomposition3x3:function(e,t,n,r){let o;const a=[...e],i=$o(a);if(i<0)for(o=0;o<9;o++)a[o]=-a[o];ra(a,t),Ko(a,a),jo(a,t,r),oa(r,n,r),jo(t,r,t),Ko(r,r),i<0&&(n[0]=-n[0],n[1]=-n[1],n[2]=-n[2])},solveLinearSystem:sa,invertMatrix:la,luFactorLinearSystem:aa,luSolveLinearSystem:ia,estimateMatrixCondition:function(e,t){let n=+Number.MAX_VALUE,r=-Number.MAX_VALUE;for(let n=0;n<t;n++)for(let o=n;o<t;o++)Math.abs(e[n*t+o])>r&&(r=Math.abs(e[n*t+o]));for(let r=0;r<t;r++)Math.abs(e[r*t+r])<n&&(n=Math.abs(e[r*t+r]));return 0===n?Number.MAX_VALUE:r/n},jacobi:function(e,t,n){return ta(e,3,t,n)},jacobiN:ta,solveHomogeneousLeastSquares:ca,solveLeastSquares:function(e,t,n,r,o,a){let i=!(arguments.length>6&&void 0!==arguments[6])||arguments[6];if(e<n||e<o)return uo(&quot;Insufficient number of samples. Underdetermined.&quot;),0;const s=ho(o);let l,c,u,d,p=1,f=0,g=0;if(i){for(u=0;u<o;u++)s[u]=1;for(c=0;c<e;c++)for(u=0;u<o;u++)Math.abs(r[c*o+u])>lo&&(p=0,s[u]=0);if(p&&1===o)return uo(&quot;Detected homogeneous system (Y=0), calling SolveHomogeneousLeastSquares()&quot;),ca(e,t,n,a);if(p)g=1;else for(u=0;u<o;u++)s[u]&&(g=1)}g&&(l=ho(n),f=ca(e,t,n,l));const m=ho(n*n),h=ho(n*n),v=ho(n*o);for(d=0;d<e;d++)for(c=0;c<n;c++){for(u=c;u<n;u++)m[c*n+u]+=t[d*n+c]*t[d*n+u];for(u=0;u<o;u++)v[c*o+u]+=t[d*n+c]*r[d*o+u]}for(c=0;c<n;c++)for(u=0;u<c;u++)m[c*n+u]=m[u*n+c];const T=la(m,h,n);if(T)for(c=0;c<n;c++)for(u=0;u<o;u++)for(a[c*o+u]=0,d=0;d<n;d++)a[c*o+u]+=h[c*n+d]*v[d*o+u];if(g)for(u=0;u<o;u++)if(s[u])for(c=0;c<n;c++)a[c*o+u]=l[c*o];return g?f&&T:T},hex2float:function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[0,.5,1];switch(e.length){case 3:return t[0]=17*parseInt(e[0],16)/255,t[1]=17*parseInt(e[1],16)/255,t[2]=17*parseInt(e[2],16)/255,t;case 4:return t[0]=17*parseInt(e[1],16)/255,t[1]=17*parseInt(e[2],16)/255,t[2]=17*parseInt(e[3],16)/255,t;case 6:return t[0]=parseInt(e.substr(0,2),16)/255,t[1]=parseInt(e.substr(2,2),16)/255,t[2]=parseInt(e.substr(4,2),16)/255,t;case 7:return t[0]=parseInt(e.substr(1,2),16)/255,t[1]=parseInt(e.substr(3,2),16)/255,t[2]=parseInt(e.substr(5,2),16)/255,t;case 9:return t[0]=parseInt(e.substr(1,2),16)/255,t[1]=parseInt(e.substr(3,2),16)/255,t[2]=parseInt(e.substr(5,2),16)/255,t[3]=parseInt(e.substr(7,2),16)/255,t;default:return t}},rgb2hsv:ua,hsv2rgb:da,lab2xyz:pa,xyz2lab:fa,xyz2rgb:ga,rgb2xyz:ma,rgb2lab:ha,lab2rgb:va,uninitializeBounds:Ta,areBoundsInitialized:ya,computeBoundsFromPoints:function(e,t,n){return n[0]=Math.min(e[0],t[0]),n[1]=Math.max(e[0],t[0]),n[2]=Math.min(e[1],t[1]),n[3]=Math.max(e[1],t[1]),n[4]=Math.min(e[2],t[2]),n[5]=Math.max(e[2],t[2]),n},clampValue:ba,clampVector:xa,clampAndNormalizeValue:function(e,t){let n=0;return t[0]!==t[1]&&(n=e<t[0]?t[0]:e>t[1]?t[1]:e,n=(n-t[0])/(t[1]-t[0])),n},getScalarTypeFittingRange:Ca,getAdjustedScalarRange:Sa,extentIsWithinOtherExtent:function(e,t){if(!e||!t)return 0;for(let n=0;n<6;n+=2)if(e[n]<t[n]||e[n]>t[n+1]||e[n+1]<t[n]||e[n+1]>t[n+1])return 0;return 1},boundsIsWithinOtherBounds:function(e,t,n){if(!e||!t)return 0;for(let r=0;r<6;r+=2)if(e[r]+n[r/2]<t[r]||e[r]-n[r/2]>t[r+1]||e[r+1]+n[r/2]<t[r]||e[r+1]-n[r/2]>t[r+1])return 0;return 1},pointIsWithinBounds:function(e,t,n){if(!e||!t||!n)return 0;for(let r=0;r<3;r++)if(e[r]+n[r]<t[2*r]||e[r]-n[r]>t[2*r+1])return 0;return 1},solve3PointCircle:function(e,t,n,r){const o=ho(3),a=ho(3),i=ho(3),s=ho(3),l=ho(3),c=ho(3);for(let r=0;r<3;++r)o[r]=e[r]-t[r],a[r]=t[r]-n[r],i[r]=n[r]-e[r],s[r]=-o[r],l[r]=-a[r],c[r]=-i[r];const u=No(s),d=No(l),p=No(i),f=ho(3);Bo(o,a,f);const g=No(f),m=u*d*p/(2*g),h=2*g*g,v=d*d*Lo(o,c)/h,T=p*p*Lo(s,a)/h,y=u*u*Lo(i,l)/h;for(let o=0;o<3;++o)r[o]=v*e[o]+T*t[o]+y*n[o];return m},inf:1/0,negInf:-1/0,isInf:Aa,isNan:wa,isNaN:wa,isFinite:Ia,createUninitializedBounds:Pa,getMajorAxisIndex:function(e){let t=-1,n=-1;for(let r=0;r<e.length;r++){const o=Math.abs(e[r]);o>t&&(n=r,t=o)}return n},getSparseOrthogonalMatrix:Ra,floatToHex2:Ma,floatRGB2HexCode:function(e){return`${arguments.length>1&&void 0!==arguments[1]?arguments[1]:&quot;#&quot;}${e.map(Ma).join(&quot;&quot;)}`},float2CssRGBA:function(e){return 3===e.length?`rgb(${e.map(Ea).join(&quot;, &quot;)})`:`rgba(${Ea(e[0]||0)}, ${Ea(e[1]||0)}, ${Ea(e[2]||0)}, ${e[3]||0})`}};function La(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3];return e[0]=n[0]*r+n[4]*o+n[8]*a+n[12]*i,e[1]=n[1]*r+n[5]*o+n[9]*a+n[13]*i,e[2]=n[2]*r+n[6]*o+n[10]*a+n[14]*i,e[3]=n[3]*r+n[7]*o+n[11]*a+n[15]*i,e}function Ba(){var e=new s(4);return s!=Float32Array&&(e[0]=0,e[1]=0,e[2]=0),e[3]=1,e}function Na(e,t,n){n*=.5;var r=Math.sin(n);return e[0]=r*t[0],e[1]=r*t[1],e[2]=r*t[2],e[3]=Math.cos(n),e}function Fa(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=n[0],l=n[1],c=n[2],u=n[3];return e[0]=r*u+i*s+o*c-a*l,e[1]=o*u+i*l+a*s-r*c,e[2]=a*u+i*c+r*l-o*s,e[3]=i*u-r*s-o*l-a*c,e}Va=new s(4),s!=Float32Array&&(Va[0]=0,Va[1]=0,Va[2]=0,Va[3]=0);var _a=function(e,t,n,r){var o=new s(4);return o[0]=e,o[1]=t,o[2]=n,o[3]=r,o};fn(),mn(1,0,0),mn(0,1,0),Ba(),Ba(),se();const ka={};function Ga(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ka,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;transform&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkImplicitFunction&quot;),e.functionValue=n=>{if(!t.transform)return e.evaluateFunction(n);const r=[];return t.transform.transformPoint(n,r),e.evaluateFunction(r)},e.evaluateFunction=e=>{Wt.vtkErrorMacro(&quot;not implemented&quot;)}}(e,t)}var Ua={newInstance:Wt.newInstance(Ga,&quot;vtkImplicitFunction&quot;),extend:Ga};const za=1e-6,Wa=&quot;coincide&quot;,Ha=&quot;disjoint&quot;;function ja(e,t,n){const r=n[0]*(e[0]-t[0])+n[1]*(e[1]-t[1])+n[2]*(e[2]-t[2]);return Math.abs(r)}function Ka(e,t,n,r){const o=[];Mo(e,t,o);const a=Lo(n,o);r[0]=e[0]-a*n[0],r[1]=e[1]-a*n[1],r[2]=e[2]-a*n[2]}function $a(e,t,n){const r=Lo(e,t);let o=Lo(t,t);return 0===o&&(o=1),n[0]=e[0]-r*t[0]/o,n[1]=e[1]-r*t[1]/o,n[2]=e[2]-r*t[2]/o,n}function qa(e,t,n,r){const o=[];Mo(e,t,o);const a=Lo(n,o),i=Lo(n,n);0!==i?(r[0]=e[0]-a*n[0]/i,r[1]=e[1]-a*n[1]/i,r[2]=e[2]-a*n[2]/i):(r[0]=e[0],r[1]=e[1],r[2]=e[2])}function Xa(e,t,n,r){const o={intersection:!1,betweenPoints:!1,t:Number.MAX_VALUE,x:[]},a=[],i=[];Mo(t,e,a),Mo(n,e,i);const s=Lo(r,i),l=Lo(r,a);let c,u;return c=l<0?-l:l,u=s<0?-s*za:s*za,c<=u||(o.t=s/l,o.x[0]=e[0]+o.t*a[0],o.x[1]=e[1]+o.t*a[1],o.x[2]=e[2]+o.t*a[2],o.intersection=!0,o.betweenPoints=o.t>=0&&o.t<=1),o}function Ya(e,t,n,r){const o={intersection:!1,l0:[],l1:[],error:null},a=[];Bo(t,r,a);const i=a.map((e=>Math.abs(e)));if(i[0]+i[1]+i[2]<za){const r=[];return Mo(e,n,r),0===Lo(t,r)?o.error=Wa:o.error=Ha,o}let s;s=i[0]>i[1]&&i[0]>i[2]?&quot;x&quot;:i[1]>i[2]?&quot;y&quot;:&quot;z&quot;;const l=[],c=-Lo(t,e),u=-Lo(r,n);switch(s){case&quot;x&quot;:l[0]=0,l[1]=(u*t[2]-c*r[2])/a[0],l[2]=(c*r[1]-u*t[1])/a[0];break;case&quot;y&quot;:l[0]=(c*r[2]-u*t[2])/a[1],l[1]=0,l[2]=(u*t[0]-c*r[0])/a[1];break;case&quot;z&quot;:l[0]=(u*t[1]-c*r[1])/a[2],l[1]=(c*r[0]-u*t[0])/a[2],l[2]=0}return o.l0=l,Ro(l,a,o.l1),o.intersection=!0,o}const Za={evaluate:function(e,t,n){return e[0]*(n[0]-t[0])+e[1]*(n[1]-t[1])+e[2]*(n[2]-t[2])},distanceToPlane:ja,projectPoint:Ka,projectVector:$a,generalizedProjectPoint:qa,intersectWithLine:Xa,intersectWithPlane:Ya,DISJOINT:Ha,COINCIDE:Wa},Qa={normal:[0,0,1],origin:[0,0,0]};function Ja(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Qa,n),Ua.extend(e,t,n),Wt.setGetArray(e,t,[&quot;normal&quot;,&quot;origin&quot;],3),function(e,t){t.classHierarchy.push(&quot;vtkPlane&quot;),e.distanceToPlane=e=>ja(e,t.origin,t.normal),e.projectPoint=(e,n)=>{Ka(e,t.origin,t.normal,n)},e.projectVector=(e,n)=>$a(e,t.normal,n),e.push=e=>{if(0!==e)for(let n=0;n<3;n++)t.origin[n]+=e*t.normal[n]},e.generalizedProjectPoint=(e,n)=>{qa(e,t.origin,t.normal,n)},e.evaluateFunction=(e,n,r)=>Array.isArray(e)?t.normal[0]*(e[0]-t.origin[0])+t.normal[1]*(e[1]-t.origin[1])+t.normal[2]*(e[2]-t.origin[2]):t.normal[0]*(e-t.origin[0])+t.normal[1]*(n-t.origin[1])+t.normal[2]*(r-t.origin[2]),e.evaluateGradient=e=>[t.normal[0],t.normal[1],t.normal[2]],e.intersectWithLine=(e,n)=>Xa(e,n,t.origin,t.normal),e.intersectWithPlane=(e,n)=>Ya(e,n,t.origin,t.normal)}(e,t)}var ei={newInstance:Wt.newInstance(Ja,&quot;vtkPlane&quot;),extend:Ja,...Za};const ti=[Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE];function ni(e,t){return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]&&e[3]===t[3]&&e[4]===t[4]&&e[5]===t[5]}function ri(e){return e?.length>=6&&e[0]<=e[1]&&e[2]<=e[3]&&e[4]<=e[5]}function oi(e,t){return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[4]=t[4],e[5]=t[5],e}function ai(e){return oi(e,ti)}function ii(e,t,n,r){const[o,a,i,s,l,c]=e;return e[0]=o<t?o:t,e[1]=a>t?a:t,e[2]=i<n?i:n,e[3]=s>n?s:n,e[4]=l<r?l:r,e[5]=c>r?c:r,e}function si(e,t){if(0===t.length)return e;if(Array.isArray(t[0]))for(let n=0;n<t.length;++n)ii(e,...t[n]);else for(let n=0;n<t.length;n+=3)ii(e,...t.slice(n,n+3));return e}function li(e,t,n,r,o,a,i){const[s,l,c,u,d,p]=e;return void 0===i?(e[0]=Math.min(t[0],s),e[1]=Math.max(t[1],l),e[2]=Math.min(t[2],c),e[3]=Math.max(t[3],u),e[4]=Math.min(t[4],d),e[5]=Math.max(t[5],p)):(e[0]=Math.min(t,s),e[1]=Math.max(n,l),e[2]=Math.min(r,c),e[3]=Math.max(o,u),e[4]=Math.min(a,d),e[5]=Math.max(i,p)),e}function ci(e,t,n,r){const[o,a,i,s,l,c]=e;return e[0]=t,e[1]=t>a?t:a,e[2]=n,e[3]=n>s?n:s,e[4]=r,e[5]=r>c?r:c,o!==t||i!==n||l!==r}function ui(e,t,n,r){const[o,a,i,s,l,c]=e;return e[0]=t<o?t:o,e[1]=t,e[2]=n<i?n:i,e[3]=n,e[4]=r<l?r:l,e[5]=r,a!==t||s!==n||c!==r}function di(e,t){return null==t?function(e){const t=[0,0,0];let n=-1,r=0,o=0;for(let a=0;a<3;++a)o=e[2*a+1]-e[2*a],o>r&&(r=o,n=a),t[a]=o>0?1:0;if(n<0)return di(e,.5);for(let n=0;n<3;++n)if(!t[n]){const t=.005*r;e[2*n]-=t,e[2*n+1]+=t}return e}(e):(e[0]-=t,e[1]+=t,e[2]-=t,e[3]+=t,e[4]-=t,e[5]+=t,e)}function pi(e,t,n,r){return!!ri(e)&&(t>=0?(e[0]*=t,e[1]*=t):(e[0]=t*e[1],e[1]=t*e[0]),n>=0?(e[2]*=n,e[3]*=n):(e[2]=n*e[3],e[3]=n*e[2]),r>=0?(e[4]*=r,e[5]*=r):(e[4]=r*e[5],e[5]=r*e[4]),!0)}function fi(e){return[.5*(e[0]+e[1]),.5*(e[2]+e[3]),.5*(e[4]+e[5])]}function gi(e,t){return e[2*t+1]-e[2*t]}function mi(e){return[gi(e,0),gi(e,1),gi(e,2)]}function hi(e){return e.slice(0,2)}function vi(e){return e.slice(2,4)}function Ti(e){return e.slice(4,6)}function yi(e){const t=mi(e);return t[0]>t[1]?t[0]>t[2]?t[0]:t[2]:t[1]>t[2]?t[1]:t[2]}function bi(e){if(ri(e)){const t=mi(e);return t[0]*t[0]+t[1]*t[1]+t[2]*t[2]}return null}function xi(e){const t=bi(e);return null!==t?Math.sqrt(t):null}function Ci(e){return[e[0],e[2],e[4]]}function Si(e){return[e[1],e[3],e[5]]}function Ai(e,t){return e<=0&&t>=0||e>=0&&t<=0}function Ii(e,t){return t[0]=[e[0],e[2],e[4]],t[1]=[e[0],e[2],e[5]],t[2]=[e[0],e[3],e[4]],t[3]=[e[0],e[3],e[5]],t[4]=[e[1],e[2],e[4]],t[5]=[e[1],e[2],e[5]],t[6]=[e[1],e[3],e[4]],t[7]=[e[1],e[3],e[5]],t}function wi(e,t,n){return t[0]=e[0],t[1]=e[2],t[2]=e[4],n[0]=e[1],n[1]=e[3],n[2]=e[5],t}function Oi(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[];const r=Ii(e,[]);for(let e=0;e<r.length;++e)In(r[e],r[e],t);return ai(n),si(n,r)}function Pi(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return t[0]=.5*(e[1]-e[0]),t[1]=.5*(e[3]-e[2]),t[2]=.5*(e[5]-e[4]),t}function Ri(e,t,n,r){const o=[].concat(ti),a=e.getData();for(let e=0;e<a.length;e+=3){const i=[a[e],a[e+1],a[e+2]],s=Lo(i,t);o[0]=Math.min(s,o[0]),o[1]=Math.max(s,o[1]);const l=Lo(i,n);o[2]=Math.min(l,o[2]),o[3]=Math.max(l,o[3]);const c=Lo(i,r);o[4]=Math.min(c,o[4]),o[5]=Math.max(c,o[5])}return o}function Mi(e,t,n,r,o){let a=!0;const i=[];let s=0;const l=[],c=[0,0,0];for(let n=0;n<3;n++)t[n]<e[2*n]?(i[n]=1,c[n]=e[2*n],a=!1):t[n]>e[2*n+1]?(i[n]=0,c[n]=e[2*n+1],a=!1):i[n]=2;if(a)return r[0]=t[0],r[1]=t[1],r[2]=t[2],o[0]=0,1;for(let e=0;e<3;e++)2!==i[e]&&0!==n[e]?l[e]=(c[e]-t[e])/n[e]:l[e]=-1;for(let e=0;e<3;e++)l[s]<l[e]&&(s=e);if(l[s]>1||l[s]<0)return 0;o[0]=l[s];for(let o=0;o<3;o++)if(s!==o){if(r[o]=t[o]+l[s]*n[o],r[o]<e[2*o]||r[o]>e[2*o+1])return 0}else r[o]=c[o];return 1}function Ei(e,t,n){const r=[];let o=0,a=1,i=1;for(let s=4;s<=5;++s){r[2]=e[s];for(let s=2;s<=3;++s){r[1]=e[s];for(let s=0;s<=1;++s)if(r[0]=e[s],o=ei.evaluate(n,t,r),i&&(a=o>=0?1:-1,i=0),0===o||a>0&&o<0||a<0&&o>0)return 1}}return 0}function Vi(e,t){if(!ri(e)||!ri(t))return!1;const n=[0,0,0,0,0,0];let r;for(let o=0;o<3;o++)if(r=!1,t[2*o]>=e[2*o]&&t[2*o]<=e[2*o+1]?(r=!0,n[2*o]=t[2*o]):e[2*o]>=t[2*o]&&e[2*o]<=t[2*o+1]&&(r=!0,n[2*o]=e[2*o]),t[2*o+1]>=e[2*o]&&t[2*o+1]<=e[2*o+1]?(r=!0,n[2*o+1]=t[2*o+1]):e[2*o+1]>=t[2*o]&&e[2*o+1]<=t[2*o+1]&&(r=!0,n[2*o+1]=e[2*o+1]),!r)return!1;return e[0]=n[0],e[1]=n[1],e[2]=n[2],e[3]=n[3],e[4]=n[4],e[5]=n[5],!0}function Di(e,t){if(!ri(e)||!ri(t))return!1;for(let n=0;n<3;n++)if(!(t[2*n]>=e[2*n]&&t[2*n]<=e[2*n+1]||e[2*n]>=t[2*n]&&e[2*n]<=t[2*n+1]||t[2*n+1]>=e[2*n]&&t[2*n+1]<=e[2*n+1]||e[2*n+1]>=t[2*n]&&e[2*n+1]<=t[2*n+1]))return!1;return!0}function Li(e,t,n,r){return!(t<e[0]||t>e[1]||n<e[2]||n>e[3]||r<e[4]||r>e[5])}function Bi(e,t,n){const r=[[0,1,2,3,4,5,6,7],[0,1,4,5,2,3,6,7],[0,2,4,6,1,3,5,7]],o=[0,0,0,0,0,0,0,0];let a=0;for(let r=0;r<2;r++)for(let i=2;i<4;i++)for(let s=4;s<6;s++){const l=[e[r],e[i],e[s]];o[a++]=ei.evaluate(n,t,l)}let i=2;for(;i--&&!(Ai(o[r[i][0]],o[r[i][4]])&&Ai(o[r[i][1]],o[r[i][5]])&&Ai(o[r[i][2]],o[r[i][6]])&&Ai(o[r[i][3]],o[r[i][7]])););if(i<0)return!1;const s=Math.sign(n[i]),l=Math.abs((e[2*i+1]-e[2*i])*n[i]);let c=s>0?1:0;for(let e=0;e<4;e++){if(0===l)continue;const t=Math.abs(o[r[i][e]])/l;s>0&&t<c&&(c=t),s<0&&t>c&&(c=t)}const u=(1-c)*e[2*i]+c*e[2*i+1];return s>0?e[2*i]=u:e[2*i+1]=u,!0}function Ni(e,t){for(let e=0;e<3;++e)t[e]=t[e]<1?1:t[e];let n=t[0]*t[1]*t[2];for(;n>e;){for(let e=0;e<3;++e)t[e]=t[e]>1?t[e]-1:1;n=t[0]*t[1]*t[2]}}function Fi(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[];t=t<=0?1:t;let o=0;const a=[0,0,0];let i=-1,s=0;const l=mi(e),c=l[0]+l[1]+l[2],u=c*(.001/3);for(let e=0;e<3;++e)l[e]>s&&(i=e,s=l[e]),l[e]>u?(a[e]=1,o++):a[e]=0;const d=Ci(e),p=Si(e);if(o<1)return n[0]=1,n[1]=1,n[2]=1,r[0]=d[0]-.5,r[1]=p[0]+.5,r[2]=d[1]-.5,r[3]=p[1]+.5,r[4]=d[2]-.5,r[5]=p[2]+.5,1;let f=t;f/=a[0]?l[0]/c:1,f/=a[1]?l[1]/c:1,f/=a[2]?l[2]/c:1,f**=1/o;for(let e=0;e<3;++e)n[e]=a[e]?Math.floor(f*l[e]/c):1,n[e]=n[e]<1?1:n[e];Ni(t,n);const g=.5*l[i]/n[i];for(let e=0;e<3;++e)a[e]?(r[2*e]=d[e],r[2*e+1]=p[e]):(r[2*e]=d[e]-g,r[2*e+1]=p[e]+g);return n[0]*n[1]*n[2]}function _i(e,t){if(e[0]>=t[0]&&e[0]<=t[1]&&e[1]>=t[2]&&e[1]<=t[3]&&e[2]>=t[4]&&e[2]<=t[5])return 0;const n=[0,0,0];return e[0]<t[0]?n[0]=t[0]-e[0]:e[0]>t[1]&&(n[0]=e[0]-t[1]),e[1]<t[2]?n[1]=t[2]-e[1]:e[1]>t[3]&&(n[1]=e[1]-t[3]),e[2]<t[4]?n[2]=t[4]-e[2]:e[2]>t[5]&&(n[2]=e[2]-t[5]),Lo(n,n)}class ki{constructor(e){this.bounds=e,this.bounds||(this.bounds=new Float64Array(ti))}getBounds(){return this.bounds}equals(e){return ni(this.bounds,e)}isValid(){return ri(this.bounds)}setBounds(e){return oi(this.bounds,e)}reset(){return ai(this.bounds)}addPoint(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return ii(this.bounds,...t)}addPoints(e){return si(this.bounds,e)}addBounds(e,t,n,r,o,a){return li(this.bounds,e,t,n,r,o,a)}setMinPoint(e,t,n){return ci(this.bounds,e,t,n)}setMaxPoint(e,t,n){return ui(this.bounds,e,t,n)}inflate(e){return di(this.bounds,e)}scale(e,t,n){return pi(this.bounds,e,t,n)}getCenter(){return fi(this.bounds)}getLength(e){return gi(this.bounds,e)}getLengths(){return mi(this.bounds)}getMaxLength(){return yi(this.bounds)}getDiagonalLength(){return xi(this.bounds)}getDiagonalLength2(){return bi(this.bounds)}getMinPoint(){return Ci(this.bounds)}getMaxPoint(){return Si(this.bounds)}getXRange(){return hi(this.bounds)}getYRange(){return vi(this.bounds)}getZRange(){return Ti(this.bounds)}getCorners(e){return Ii(this.bounds,e)}computeCornerPoints(e,t){return wi(this.bounds,e,t)}computeLocalBounds(e,t,n){return Ri(this.bounds,e,t,n)}transformBounds(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return Oi(this.bounds,e,t)}computeScale3(e){return Pi(this.bounds,e)}cutWithPlane(e,t){return Bi(this.bounds,e,t)}intersectBox(e,t,n,r){return Mi(this.bounds,e,t,n,r)}intersectPlane(e,t){return Ei(this.bounds,e,t)}intersect(e){return Vi(this.bounds,e)}intersects(e){return Di(this.bounds,e)}containsPoint(e,t,n){return Li(this.bounds,e,t,n)}contains(e){return Di(this.bounds,e)}computeDivisions(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[];return Fi(this.bounds,e,t,n)}distance2ToBounds(e){return _i(e,this.bounds)}}var Gi={newInstance:function(e){const t=e&&e.bounds;return new ki(t)},equals:ni,isValid:ri,setBounds:oi,reset:ai,addPoint:ii,addPoints:si,addBounds:li,setMinPoint:ci,setMaxPoint:ui,inflate:di,scale:pi,scaleAboutCenter:function(e,t,n,r){if(!ri(e))return!1;const o=fi(e);return e[0]-=o[0],e[1]-=o[0],e[2]-=o[1],e[3]-=o[1],e[4]-=o[2],e[5]-=o[2],pi(e,t,n,r),e[0]+=o[0],e[1]+=o[0],e[2]+=o[1],e[3]+=o[1],e[4]+=o[2],e[5]+=o[2],!0},getCenter:fi,getLength:gi,getLengths:mi,getMaxLength:yi,getDiagonalLength:xi,getDiagonalLength2:bi,getMinPoint:Ci,getMaxPoint:Si,getXRange:hi,getYRange:vi,getZRange:Ti,getCorners:Ii,computeCornerPoints:wi,computeLocalBounds:Ri,transformBounds:Oi,computeScale3:Pi,cutWithPlane:Bi,intersectBox:Mi,intersectPlane:Ei,intersect:Vi,intersects:Di,containsPoint:Li,contains:function(e,t){return!!Di(e,t)&&!!Li(e,...Ci(t))&&!!Li(e,...Si(t))},computeDivisions:Fi,clampDivisions:Ni,distance2ToBounds:_i,INIT_BOUNDS:ti},Ui={CoordinateSystem:{DISPLAY:0,WORLD:1}};const{CoordinateSystem:zi}=Ui;function Wi(e){return()=>Wt.vtkErrorMacro(`vtkProp::${e} - NOT IMPLEMENTED`)}const Hi={allocatedRenderTime:10,coordinateSystem:zi.WORLD,dragable:!0,estimatedRenderTime:0,paths:null,pickable:!0,renderTimeMultiplier:1,savedEstimatedRenderTime:0,textures:[],useBounds:!0,visibility:!0};function ji(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Hi,n),Wt.obj(e,t),Wt.get(e,t,[&quot;estimatedRenderTime&quot;,&quot;allocatedRenderTime&quot;]),Wt.setGet(e,t,[&quot;_parentProp&quot;,&quot;coordinateSystem&quot;,&quot;dragable&quot;,&quot;pickable&quot;,&quot;renderTimeMultiplier&quot;,&quot;useBounds&quot;,&quot;visibility&quot;]),Wt.moveToProtected(e,t,[&quot;parentProp&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkProp&quot;),e.getMTime=()=>{let e=t.mtime;for(let n=0;n<t.textures.length;++n){const r=t.textures[n].getMTime();r>e&&(e=r)}return e},e.processSelectorPixelBuffers=(e,t)=>{},e.getNestedProps=()=>null,e.getActors=()=>[],e.getActors2D=()=>[],e.getVolumes=()=>[],e.pick=Wi(&quot;pick&quot;),e.hasKey=Wi(&quot;hasKey&quot;),e.getNestedVisibility=()=>t.visibility&&(!t._parentProp||t._parentProp.getNestedVisibility()),e.getNestedPickable=()=>t.pickable&&(!t._parentProp||t._parentProp.getNestedPickable()),e.getNestedDragable=()=>t.dragable&&(!t._parentProp||t._parentProp.getNestedDragable()),e.getRedrawMTime=()=>t.mtime,e.setEstimatedRenderTime=e=>{t.estimatedRenderTime=e,t.savedEstimatedRenderTime=e},e.restoreEstimatedRenderTime=()=>{t.estimatedRenderTime=t.savedEstimatedRenderTime},e.addEstimatedRenderTime=e=>{t.estimatedRenderTime+=e},e.setAllocatedRenderTime=e=>{t.allocatedRenderTime=e,t.savedEstimatedRenderTime=t.estimatedRenderTime,t.estimatedRenderTime=0},e.getSupportsSelection=()=>!1,e.getTextures=()=>t.textures,e.hasTexture=e=>-1!==t.textures.indexOf(e),e.addTexture=n=>{n&&!e.hasTexture(n)&&(t.textures=t.textures.concat(n),e.modified())},e.removeTexture=n=>{const r=t.textures.filter((e=>e!==n));t.textures.length!==r.length&&(t.textures=r,e.modified())},e.removeAllTextures=()=>{t.textures=[],e.modified()},e.setCoordinateSystemToWorld=()=>e.setCoordinateSystem(zi.WORLD),e.setCoordinateSystemToDisplay=()=>e.setCoordinateSystem(zi.DISPLAY)}(e,t)}var Ki={newInstance:Wt.newInstance(ji,&quot;vtkProp&quot;),extend:ji,...Ui};const $i={origin:[0,0,0],position:[0,0,0],orientation:[0,0,0],rotation:null,scale:[1,1,1],bounds:[...Gi.INIT_BOUNDS],properties:[],userMatrix:null,userMatrixMTime:null,cachedProp3D:null,isIdentity:!0,matrixMTime:null};function qi(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,$i,n),Ki.extend(e,t,n),t.matrixMTime={},Wt.obj(t.matrixMTime),Wt.get(e,t,[&quot;isIdentity&quot;]),Wt.getArray(e,t,[&quot;orientation&quot;]),Wt.setGetArray(e,t,[&quot;origin&quot;,&quot;position&quot;,&quot;scale&quot;],3),Wt.setGet(e,t,[&quot;properties&quot;]),t.matrix=m(new Float64Array(16)),t.rotation=m(new Float64Array(16)),t.userMatrix=m(new Float64Array(16)),t.transform=null,function(e,t){t.classHierarchy.push(&quot;vtkProp3D&quot;),e.addPosition=n=>{t.position=t.position.map(((e,t)=>e+n[t])),e.modified()},e.getOrientationWXYZ=()=>{const e=Ba();F(e,t.rotation);const n=new Float64Array(3),r=function(e,t){var n=2*Math.acos(t[3]),r=Math.sin(n/2);return r>i?(e[0]=t[0]/r,e[1]=t[1]/r,e[2]=t[2]/r):(e[0]=1,e[1]=0,e[2]=0),n}(n,e);return[To(r),n[0],n[1],n[2]]},e.getOrientationQuaternion=function(){return F(arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],t.rotation)},e.rotateX=n=>{0!==n&&(A(t.rotation,t.rotation,vo(n)),e.modified())},e.rotateY=n=>{0!==n&&(I(t.rotation,t.rotation,vo(n)),e.modified())},e.rotateZ=n=>{0!==n&&(w(t.rotation,t.rotation,vo(n)),e.modified())},e.rotateWXYZ=(n,r,o,a)=>{if(0===n||0===r&&0===o&&0===a)return;const i=vo(n),s=Ba();Na(s,[r,o,a],i);const l=new Float64Array(16);G(l,s),b(t.rotation,t.rotation,l),e.modified()},e.rotateQuaternion=n=>{if(Math.abs(n[3])>=.999999)return;const r=G(new Float64Array(16),n);b(t.rotation,t.rotation,r),e.modified()},e.setOrientation=(n,r,o)=>(n!==t.orientation[0]||r!==t.orientation[1]||o!==t.orientation[2])&&(t.orientation=[n,r,o],m(t.rotation),e.rotateZ(o),e.rotateX(n),e.rotateY(r),e.modified(),!0),e.setOrientationFromQuaternion=n=>{const r=u();return G(r,n),!Xo(r,t.rotation)&&(t.rotation=r,e.modified(),!0)},e.setUserMatrix=n=>!Xo(t.userMatrix,n)&&(p(t.userMatrix,n),e.modified(),!0),e.getMatrix=()=>(e.computeMatrix(),t.matrix),e.computeMatrix=()=>{if(e.getMTime()>t.matrixMTime.getMTime()){m(t.matrix),t.userMatrix&&b(t.matrix,t.matrix,t.userMatrix),x(t.matrix,t.matrix,t.origin),x(t.matrix,t.matrix,t.position),b(t.matrix,t.matrix,t.rotation),C(t.matrix,t.matrix,t.scale),x(t.matrix,t.matrix,[-t.origin[0],-t.origin[1],-t.origin[2]]),h(t.matrix,t.matrix),t.isIdentity=!0;for(let e=0;e<4;++e)for(let n=0;n<4;++n)(e===n?1:0)!==t.matrix[e+4*n]&&(t.isIdentity=!1);t.matrixMTime.modified()}},e.getBoundsByReference=()=>{if(null===t.mapper)return t.bounds;const n=t.mapper.getBounds();if(!n||6!==n.length)return n;if(n[0]>n[1])return t.mapperBounds=n,t.bounds=[...Gi.INIT_BOUNDS],t.boundsMTime.modified(),n;if(!t.mapperBounds||!n.every(((e,r)=>n[r]===t.mapperBounds[r]))||e.getMTime()>t.boundsMTime.getMTime()){Wt.vtkDebugMacro(&quot;Recomputing bounds...&quot;),t.mapperBounds=n,e.computeMatrix();const r=new Float64Array(16);h(r,t.matrix),Gi.transformBounds(n,r,t.bounds),t.boundsMTime.modified()}return t.bounds},e.getBounds=()=>{const t=e.getBoundsByReference();try{return[...t]}catch{return t}},e.getCenter=()=>Gi.getCenter(t.bounds),e.getLength=()=>Gi.getLength(t.bounds),e.getXRange=()=>Gi.getXRange(t.bounds),e.getYRange=()=>Gi.getYRange(t.bounds),e.getZRange=()=>Gi.getZRange(t.bounds),e.getUserMatrix=()=>t.userMatrix,e.onModified((function(){e.computeMatrix()})),e.getProperty=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return null==t.properties[n]&&(t.properties[n]=e.makeProperty?.()),t.properties[n]},e.getProperties=()=>(0===t.properties.length&&(t.properties[0]=e.makeProperty?.()),t.properties),e.setProperty=(e,n)=>{const r=Number.isInteger(e),[o,a]=r?[e,n]:[0,e];return t.properties[o]!==a&&(t.properties[o]=a,!0)},e.getMTime=()=>{let e=t.mtime;return t.properties.forEach((t=>{if(null!==t){const n=t.getMTime();e=n>e?n:e}})),e}}(e,t)}var Xi={newInstance:Wt.newInstance(qi,&quot;vtkProp3D&quot;),extend:qi};const Yi={FLAT:0,GOURAUD:1,PHONG:2},Zi={POINTS:0,WIREFRAME:1,SURFACE:2};var Qi={Shading:Yi,Representation:Zi,Interpolation:Yi};const{Representation:Ji,Interpolation:es}=Qi;function ts(e){return()=>Wt.vtkErrorMacro(`vtkProperty::${e} - NOT IMPLEMENTED`)}const ns={color:[1,1,1],ambientColor:[1,1,1],diffuseColor:[1,1,1],specularColor:[1,1,1],edgeColor:[0,0,0],ambient:0,diffuse:1,metallic:0,roughness:.6,normalStrength:1,emission:1,baseIOR:1.45,specular:0,specularPower:1,opacity:1,interpolation:es.GOURAUD,representation:Ji.SURFACE,edgeVisibility:!1,backfaceCulling:!1,frontfaceCulling:!1,pointSize:1,lineWidth:1,lighting:!0,shading:!1,materialName:null,ORMTexture:null,RMTexture:null};function rs(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ns,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;lighting&quot;,&quot;interpolation&quot;,&quot;ambient&quot;,&quot;diffuse&quot;,&quot;metallic&quot;,&quot;roughness&quot;,&quot;normalStrength&quot;,&quot;emission&quot;,&quot;baseIOR&quot;,&quot;specular&quot;,&quot;specularPower&quot;,&quot;opacity&quot;,&quot;edgeVisibility&quot;,&quot;lineWidth&quot;,&quot;pointSize&quot;,&quot;backfaceCulling&quot;,&quot;frontfaceCulling&quot;,&quot;representation&quot;,&quot;diffuseTexture&quot;,&quot;metallicTexture&quot;,&quot;roughnessTexture&quot;,&quot;normalTexture&quot;,&quot;ambientOcclusionTexture&quot;,&quot;emissionTexture&quot;,&quot;ORMTexture&quot;,&quot;RMTexture&quot;]),Wt.setGetArray(e,t,[&quot;ambientColor&quot;,&quot;specularColor&quot;,&quot;diffuseColor&quot;,&quot;edgeColor&quot;],3),function(e,t){t.classHierarchy.push(&quot;vtkProperty&quot;),e.setColor=(n,r,o)=>{Array.isArray(n)?t.color[0]===n[0]&&t.color[1]===n[1]&&t.color[2]===n[2]||(t.color[0]=n[0],t.color[1]=n[1],t.color[2]=n[2],e.modified()):t.color[0]===n&&t.color[1]===r&&t.color[2]===o||(t.color[0]=n,t.color[1]=r,t.color[2]=o,e.modified()),e.setDiffuseColor(t.color),e.setAmbientColor(t.color),e.setSpecularColor(t.color)},e.computeCompositeColor=ts(&quot;ComputeCompositeColor&quot;),e.getColor=()=>{let e=0;t.ambient+t.diffuse+t.specular>0&&(e=1/(t.ambient+t.diffuse+t.specular));for(let n=0;n<3;n++)t.color[n]=e*(t.ambient*t.ambientColor[n]+t.diffuse*t.diffuseColor[n]+t.specular*t.specularColor[n]);return[].concat(t.color)},e.setSpecularPower=n=>{const r=1/Math.max(1,n);t.roughness===r&&t.specularPower===n||(t.specularPower=n,t.roughness=r,e.modified())},e.addShaderVariable=ts(&quot;AddShaderVariable&quot;),e.setInterpolationToFlat=()=>e.setInterpolation(es.FLAT),e.setInterpolationToGouraud=()=>e.setInterpolation(es.GOURAUD),e.setInterpolationToPhong=()=>e.setInterpolation(es.PHONG),e.getInterpolationAsString=()=>Wt.enumToString(es,t.interpolation),e.setRepresentationToWireframe=()=>e.setRepresentation(Ji.WIREFRAME),e.setRepresentationToSurface=()=>e.setRepresentation(Ji.SURFACE),e.setRepresentationToPoints=()=>e.setRepresentation(Ji.POINTS),e.getRepresentationAsString=()=>Wt.enumToString(Ji,t.representation)}(e,t)}var os={newInstance:Wt.newInstance(rs,&quot;vtkProperty&quot;),extend:rs,...Qi};const as={mapper:null,backfaceProperty:null,forceOpaque:!1,forceTranslucent:!1};function is(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,as,n),Xi.extend(e,t,n),t.boundsMTime={},Wt.obj(t.boundsMTime),Wt.setGet(e,t,[&quot;backfaceProperty&quot;,&quot;forceOpaque&quot;,&quot;forceTranslucent&quot;,&quot;mapper&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkActor&quot;);const n={...e};e.getActors=()=>[e],e.getIsOpaque=()=>{if(t.forceOpaque)return!0;if(t.forceTranslucent)return!1;t.properties[0]||e.getProperty();let n=t.properties[0].getOpacity()>=1;return n=n&&(!t.texture||!t.texture.isTranslucent()),n=n&&(!t.mapper||t.mapper.getIsOpaque()),n},e.hasTranslucentPolygonalGeometry=()=>null!==t.mapper&&(t.properties[0]||e.getProperty(),!e.getIsOpaque()),e.makeProperty=os.newInstance,e.getMTime=()=>{let e=n.getMTime();if(null!==t.backfaceProperty){const n=t.backfaceProperty.getMTime();e=n>e?n:e}return e},e.getRedrawMTime=()=>{let e=t.mtime;if(null!==t.mapper){let n=t.mapper.getMTime();e=n>e?n:e,null!==t.mapper.getInput()&&(t.mapper.getInputAlgorithm().update(),n=t.mapper.getInput().getMTime(),e=n>e?n:e)}return e},e.getSupportsSelection=()=>!!t.mapper&&t.mapper.getSupportsSelection(),e.processSelectorPixelBuffers=(e,n)=>{t.mapper&&t.mapper.processSelectorPixelBuffers&&t.mapper.processSelectorPixelBuffers(e,n)}}(e,t)}var ss={newInstance:Wt.newInstance(is,&quot;vtkActor&quot;),extend:is};const ls={Int8Array:1,Uint8Array:1,Uint8ClampedArray:1,Int16Array:2,Uint16Array:2,Int32Array:4,Uint32Array:4,Float32Array:4,Float64Array:8},cs={VOID:&quot;&quot;,CHAR:&quot;Int8Array&quot;,SIGNED_CHAR:&quot;Int8Array&quot;,UNSIGNED_CHAR:&quot;Uint8Array&quot;,UNSIGNED_CHAR_CLAMPED:&quot;Uint8ClampedArray&quot;,SHORT:&quot;Int16Array&quot;,UNSIGNED_SHORT:&quot;Uint16Array&quot;,INT:&quot;Int32Array&quot;,UNSIGNED_INT:&quot;Uint32Array&quot;,FLOAT:&quot;Float32Array&quot;,DOUBLE:&quot;Float64Array&quot;};var us={DefaultDataType:cs.FLOAT,DataTypeByteSize:ls,VtkDataTypes:cs};const{vtkErrorMacro:ds}=Ht,{DefaultDataType:ps}=us;function fs(e,t,n){const r=e.length;let o,a,i=Number.MAX_VALUE,s=-Number.MAX_VALUE;for(a=t;a<r;a+=n)if(!Number.isNaN(e[a])){i=e[a],s=i;break}for(;a<r;a+=n)o=e[a],o<i?i=o:o>s&&(s=o);return{min:i,max:s}}function gs(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1;if(t<0&&n>1){const t=e.length/n,r=new Float64Array(t);for(let o=0,a=0;o<t;++o){for(let t=a+n;a<t;++a)r[o]+=e[a]*e[a];r[o]**=.5}return fs(r,0,1)}return fs(e,t<0?0:t,n)}function ms(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;const n=e||[];for(;n.length<=t;)n.push(null);return n}function hs(e){return Object.prototype.toString.call(e).slice(8,-1)}const vs={computeRange:gs,createRangeHelper:function(){let e=Number.MAX_VALUE,t=-Number.MAX_VALUE,n=0,r=0;return{add(o){e>o&&(e=o),t<o&&(t=o),n++,r+=o},get(){return{min:e,max:t,count:n,sum:r,mean:r/n}},getRange(){return{min:e,max:t}}}},fastComputeRange:fs,getDataType:hs,getMaxNorm:function(e){const t=e.getNumberOfComponents();let n=0;const r=new Array(t);for(let o=0;o<e.getNumberOfTuples();++o){e.getTuple(o,r);const a=No(r,t);a>n&&(n=a)}return n}},Ts={name:&quot;&quot;,numberOfComponents:1,dataType:ps,rangeTuple:[0,0]};function ys(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};if(Object.assign(t,Ts,n),Array.isArray(n.values)&&void 0===n.dataType&&console.warn(&quot;vtkDataArray.newInstance: no dataType provided, converting to Float32Array&quot;),!t.empty&&!t.values&&!t.size)throw new TypeError(&quot;Cannot create vtkDataArray object without: size > 0, values&quot;);if(t.values?Array.isArray(t.values)&&(t.values=it(t.dataType,t.values)):t.values=at(t.dataType,t.size),t.values&&(t.size=t.size??t.values.length,t.dataType=hs(t.values)),ht(e,t),xt(e,t,[&quot;name&quot;,&quot;numberOfComponents&quot;]),t.size%t.numberOfComponents!=0)throw new RangeError(&quot;model.size is not a multiple of model.numberOfComponents&quot;);!function(e,t){function n(n){if(n<0)return!1;const r=e.getNumberOfComponents(),o=t.values.length/(r>0?r:1);if(n===o)return!0;if(n>o){const e=t.values;return t.values=at(t.dataType,(n+o)*r),t.values.set(e),!0}return t.size>n*r&&(t.size=n*r,e.dataChange()),!0}t.classHierarchy.push(&quot;vtkDataArray&quot;),e.dataChange=()=>{t.ranges=null,e.modified()},e.allocate=t=>{n(e.getNumberOfTuples()+t)},e.resize=r=>{n(r);const o=r*e.getNumberOfComponents();return t.size!==o&&(t.size=o,e.dataChange(),!0)},e.initialize=()=>(e.resize(0),e),e.getElementComponentSize=()=>t.values.BYTES_PER_ELEMENT,e.getComponent=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;return t.values[e*t.numberOfComponents+n]},e.setComponent=(n,r,o)=>{o!==t.values[n*t.numberOfComponents+r]&&(t.values[n*t.numberOfComponents+r]=o,e.dataChange())},e.getValue=n=>{const r=n/t.numberOfComponents,o=n%t.numberOfComponents;return e.getComponent(r,o)},e.setValue=(n,r)=>{const o=n/t.numberOfComponents,a=n%t.numberOfComponents;e.setComponent(o,a,r)},e.getData=()=>t.size===t.values.length?t.values:t.values.subarray(0,t.size),e.getRange=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:-1,r=n;r<0&&(r=1===t.numberOfComponents?0:t.numberOfComponents);let o=null;return t.ranges||(t.ranges=ms(t.ranges,t.numberOfComponents)),o=t.ranges[r],o?(t.rangeTuple[0]=o.min,t.rangeTuple[1]=o.max,t.rangeTuple):(o=gs(e.getData(),n,t.numberOfComponents),t.ranges[r]=o,t.rangeTuple[0]=o.min,t.rangeTuple[1]=o.max,t.rangeTuple)},e.setRange=(e,n)=>{t.ranges||(t.ranges=ms(t.ranges,t.numberOfComponents));const r={min:e.min,max:e.max};return t.ranges[n]=r,t.rangeTuple[0]=r.min,t.rangeTuple[1]=r.max,t.rangeTuple},e.getRanges=function(){if(arguments.length>0&&void 0!==arguments[0]&&!arguments[0])return structuredClone(t.ranges);const n=[];for(let r=0;r<t.numberOfComponents;r++){const[t,o]=e.getRange(r),a={min:t,max:o};n.push(a)}if(t.numberOfComponents>1){const[t,r]=e.getRange(-1),o={min:t,max:r};n.push(o)}return n},e.setTuple=(e,n)=>{const r=e*t.numberOfComponents;for(let e=0;e<t.numberOfComponents;e++)t.values[r+e]=n[e]},e.setTuples=(e,n)=>{let r=e*t.numberOfComponents;const o=Math.min(n.length,t.size-r);for(let e=0;e<o;)t.values[r++]=n[e++]},e.insertTuple=(r,o)=>(t.size<=r*t.numberOfComponents&&(t.size=(r+1)*t.numberOfComponents,n(r+1)),e.setTuple(r,o),r),e.insertTuples=(r,o)=>{const a=r+o.length/t.numberOfComponents;return t.size<a*t.numberOfComponents&&(t.size=a*t.numberOfComponents,n(a)),e.setTuples(r,o),a},e.insertNextTuple=n=>{const r=t.size/t.numberOfComponents;return e.insertTuple(r,n)},e.insertNextTuples=n=>{const r=t.size/t.numberOfComponents;return e.insertTuples(r,n)},e.findTuple=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1e-6;for(let r=0;r<t.size;r+=t.numberOfComponents)if(Math.abs(e[0]-t.values[r])<=n){let o=!0;for(let a=1;a<t.numberOfComponents;++a)if(Math.abs(e[a]-t.values[r+a])>n){o=!1;break}if(o)return r/t.numberOfComponents}return-1},e.getTuple=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];const r=t.numberOfComponents||1,o=e*r;switch(r){case 4:n[3]=t.values[o+3];case 3:n[2]=t.values[o+2];case 2:n[1]=t.values[o+1];case 1:n[0]=t.values[o];break;default:for(let e=r-1;e>=0;--e)n[e]=t.values[o+e]}return n},e.getTuples=(n,r)=>{const o=(n??0)*t.numberOfComponents,a=(r??e.getNumberOfTuples())*t.numberOfComponents,i=e.getData().subarray(o,a);return i.length>0?i:null},e.getTupleLocation=function(){return(arguments.length>0&&void 0!==arguments[0]?arguments[0]:1)*t.numberOfComponents},e.getNumberOfComponents=()=>t.numberOfComponents,e.getNumberOfValues=()=>t.size,e.getNumberOfTuples=()=>t.size/t.numberOfComponents,e.getDataType=()=>t.dataType,e.newClone=()=>bs({empty:!0,name:t.name,dataType:t.dataType,numberOfComponents:t.numberOfComponents}),e.getName=()=>(t.name||(e.modified(),t.name=`vtkDataArray${e.getMTime()}`),t.name),e.setData=(n,r)=>{t.values=n,t.size=n.length,t.dataType=hs(n),r&&(t.numberOfComponents=r),t.size%t.numberOfComponents!=0&&(t.numberOfComponents=1),e.dataChange()},e.getState=()=>{if(t.deleted)return null;const n={...t,vtkClass:e.getClassName()};n.values=Array.from(n.values),delete n.buffer,Object.keys(n).forEach((e=>{n[e]||delete n[e]}));const r={};return Object.keys(n).sort().forEach((e=>{r[e]=n[e]})),r.mtime&&delete r.mtime,r},e.deepCopy=n=>{const r=e.getDataType(),o=t.values;e.shallowCopy(n),t.ranges=structuredClone(n.getRanges()),o?.length>=n.getNumberOfValues()&&r===n.getDataType()?(o.set(n.getData()),t.values=o,e.dataChange()):e.setData(n.getData().slice())},e.interpolateTuple=(n,r,o,a,i,s)=>{const l=t.numberOfComponents||1;l===r.getNumberOfComponents()&&l===a.getNumberOfComponents()||ds(&quot;numberOfComponents must match&quot;);const c=r.getTuple(o),u=a.getTuple(i),d=[];switch(d.length=l,l){case 4:d[3]=c[3]+(u[3]-c[3])*s;case 3:d[2]=c[2]+(u[2]-c[2])*s;case 2:d[1]=c[1]+(u[1]-c[1])*s;case 1:d[0]=c[0]+(u[0]-c[0])*s;break;default:for(let e=0;e<l;e++)d[e]=c[e]+(u[e]-c[e])*s}return e.insertTuple(n,d)}}(e,t)}const bs=Mt(ys,&quot;vtkDataArray&quot;);var xs={newInstance:bs,extend:ys,...vs,...us};const Cs={clippingPlanes:[]};var Ss=function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Cs,n),Wt.obj(e,t),Wt.algo(e,t,1,0),t.clippingPlanes||(t.clippingPlanes=[]),function(e,t){t.classHierarchy.push(&quot;vtkAbstractMapper&quot;),e.update=()=>{e.getInputData()},e.addClippingPlane=n=>!!n.isA(&quot;vtkPlane&quot;)&&!t.clippingPlanes.includes(n)&&(t.clippingPlanes.push(n),e.modified(),!0),e.getNumberOfClippingPlanes=()=>t.clippingPlanes.length,e.removeAllClippingPlanes=()=>0!==t.clippingPlanes.length&&(t.clippingPlanes.length=0,e.modified(),!0),e.removeClippingPlane=n=>{const r=t.clippingPlanes.indexOf(n);return-1!==r&&(t.clippingPlanes.splice(r,1),e.modified(),!0)},e.getClippingPlanes=()=>t.clippingPlanes,e.setClippingPlanes=t=>{if(t)if(Array.isArray(t)){const n=t.length;for(let r=0;r<n&&r<6;r++)e.addClippingPlane(t[r])}else e.addClippingPlane(t)},e.getClippingPlaneInDataCoords=(e,n,r)=>{const o=t.clippingPlanes,a=e;if(o){const e=o.length;if(n>=0&&n<e){const e=o[n],t=e.getNormal(),i=e.getOrigin(),s=t[0],l=t[1],c=t[2],u=-(s*i[0]+l*i[1]+c*i[2]);return r[0]=s*a[0]+l*a[4]+c*a[8]+u*a[12],r[1]=s*a[1]+l*a[5]+c*a[9]+u*a[13],r[2]=s*a[2]+l*a[6]+c*a[10]+u*a[14],void(r[3]=s*a[3]+l*a[7]+c*a[11]+u*a[15])}}Wt.vtkErrorMacro(`Clipping plane index ${n} is out of range.`)}}(e,t)},As=function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,(e=>({bounds:[...Gi.INIT_BOUNDS],center:[0,0,0],viewSpecificProperties:{},...e}))(n)),Ss(e,t,n),Wt.setGet(e,t,[&quot;viewSpecificProperties&quot;]),function(e,t){e.getBounds=()=>(Wt.vtkErrorMacro(&quot;vtkAbstractMapper3D.getBounds - NOT IMPLEMENTED&quot;),Pa()),e.getCenter=()=>{const n=e.getBounds();return t.center=Gi.isValid(n)?Gi.getCenter(n):null,t.center?.slice()},e.getLength=()=>{const t=e.getBounds();return Gi.getDiagonalLength(t)}}(e,t)};const{vtkErrorMacro:Is,vtkWarningMacro:ws}=Wt,Os={arrays:[],copyFieldFlags:[],doCopyAllOn:!0,doCopyAllOff:!1};function Ps(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Os,n),Wt.obj(e,t),function(e,t){t.classHierarchy.push(&quot;vtkFieldData&quot;);const n=e.getState;t.arrays&&(t.arrays=t.arrays.map((e=>({data:ze(e.data)})))),e.initialize=()=>{e.initializeFields(),e.copyAllOn(),e.clearFieldFlags()},e.initializeFields=()=>{t.arrays=[],t.copyFieldFlags={},e.modified()},e.copyStructure=n=>{e.initializeFields(),t.copyFieldFlags=n.getCopyFieldFlags().map((e=>e)),t.arrays=n.getArrays().map((e=>({data:e})))},e.getNumberOfArrays=()=>t.arrays.length,e.getNumberOfActiveArrays=()=>t.arrays.length,e.addArray=n=>{const r=n.getName(),{array:o,index:a}=e.getArrayWithIndex(r);return null!=o?(t.arrays[a]={data:n},a):(t.arrays=[].concat(t.arrays,{data:n}),t.arrays.length-1)},e.removeAllArrays=()=>{t.arrays=[]},e.removeArray=n=>{const r=t.arrays.findIndex((e=>e.data.getName()===n));return e.removeArrayByIndex(r)},e.removeArrayByIndex=e=>-1!==e&&e<t.arrays.length&&(t.arrays.splice(e,1),!0),e.getArrays=()=>t.arrays.map((e=>e.data)),e.getArray=t=>&quot;number&quot;==typeof t?e.getArrayByIndex(t):e.getArrayByName(t),e.getArrayByName=e=>t.arrays.reduce(((t,n,r)=>n.data.getName()===e?n.data:t),null),e.getArrayWithIndex=e=>{const n=t.arrays.findIndex((t=>t.data.getName()===e));return{array:-1!==n?t.arrays[n].data:null,index:n}},e.getArrayByIndex=e=>e>=0&&e<t.arrays.length?t.arrays[e].data:null,e.hasArray=t=>e.getArrayWithIndex(t).index>=0,e.getArrayName=e=>{const n=t.arrays[e];return n?n.data.getName():&quot;&quot;},e.getCopyFieldFlags=()=>t.copyFieldFlags,e.getFlag=e=>t.copyFieldFlags[e],e.passData=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:-1,o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:-1;n.getArrays().forEach((a=>{const i=e.getFlag(a.getName());if(!1!==i&&(!t.doCopyAllOff||!0===i)&&a){let t=e.getArrayByName(a.getName());if(t)if(a.getNumberOfComponents()===t.getNumberOfComponents())if(r>-1&&r<a.getNumberOfTuples()){const e=o>-1?o:r;t.insertTuple(e,a.getTuple(r))}else t.insertTuples(0,a.getTuples());else Is(&quot;Unhandled case in passData&quot;);else if(r<0||r>a.getNumberOfTuples())e.addArray(a),n.getAttributes(a).forEach((t=>{e.setAttribute(a,t)}));else{const i=a.getNumberOfComponents();let s=a.getNumberOfValues();const l=o>-1?o:r;s<=l*i&&(s=(l+1)*i),t=xs.newInstance({name:a.getName(),dataType:a.getDataType(),numberOfComponents:i,values:Wt.newTypedArray(a.getDataType(),s),size:0}),t.insertTuple(l,a.getTuple(r)),e.addArray(t),n.getAttributes(a).forEach((n=>{e.setAttribute(t,n)}))}}}))},e.interpolateData=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:-1,o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:-1,a=arguments.length>3&&void 0!==arguments[3]?arguments[3]:-1,i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:.5;n.getArrays().forEach((s=>{const l=e.getFlag(s.getName());if(!1!==l&&(!t.doCopyAllOff||!0===l)&&s){let t=e.getArrayByName(s.getName());if(t)if(s.getNumberOfComponents()===t.getNumberOfComponents())if(r>-1&&r<s.getNumberOfTuples()){const e=a>-1?a:r;t.interpolateTuple(e,s,r,s,o,i),ws(&quot;Unexpected case in interpolateData&quot;)}else t.insertTuples(s.getTuples());else Is(&quot;Unhandled case in interpolateData&quot;);else if(r<0||o<0||r>s.getNumberOfTuples())e.addArray(s),n.getAttributes(s).forEach((t=>{e.setAttribute(s,t)}));else{const l=s.getNumberOfComponents();let c=s.getNumberOfValues();const u=a>-1?a:r;c<=u*l&&(c=(u+1)*l),t=xs.newInstance({name:s.getName(),dataType:s.getDataType(),numberOfComponents:l,values:Wt.newTypedArray(s.getDataType(),c),size:0}),t.interpolateTuple(u,s,r,s,o,i),e.addArray(t),n.getAttributes(s).forEach((n=>{e.setAttribute(t,n)}))}}}))},e.copyFieldOn=e=>{t.copyFieldFlags[e]=!0},e.copyFieldOff=e=>{t.copyFieldFlags[e]=!1},e.copyAllOn=()=>{t.doCopyAllOn&&!t.doCopyAllOff||(t.doCopyAllOn=!0,t.doCopyAllOff=!1,e.modified())},e.copyAllOff=()=>{!t.doCopyAllOn&&t.doCopyAllOff||(t.doCopyAllOn=!1,t.doCopyAllOff=!0,e.modified())},e.clearFieldFlags=()=>{t.copyFieldFlags={}},e.deepCopy=e=>{t.arrays=e.getArrays().map((e=>{const t=e.newClone();return t.deepCopy(e),{data:t}}))},e.copyFlags=e=>e.getCopyFieldFlags().map((e=>e)),e.reset=()=>t.arrays.forEach((e=>e.data.reset())),e.getMTime=()=>t.arrays.reduce(((e,t)=>t.data.getMTime()>e?t.data.getMTime():e),t.mtime),e.getNumberOfComponents=()=>t.arrays.reduce(((e,t)=>e+t.data.getNumberOfComponents()),0),e.getNumberOfTuples=()=>t.arrays.length>0?t.arrays[0].getNumberOfTuples():0,e.getState=()=>{const e=n();return e&&(e.arrays=t.arrays.map((e=>({data:e.data.getState()})))),e}}(e,t)}var Rs={newInstance:Wt.newInstance(Ps,&quot;vtkFieldData&quot;),extend:Ps};const Ms={DEFAULT:0,SINGLE:1,DOUBLE:2};var Es={AttributeCopyOperations:{COPYTUPLE:0,INTERPOLATE:1,PASSDATA:2,ALLCOPY:3},AttributeLimitTypes:{MAX:0,EXACT:1,NOLIMIT:2},AttributeTypes:{SCALARS:0,VECTORS:1,NORMALS:2,TCOORDS:3,TENSORS:4,GLOBALIDS:5,PEDIGREEIDS:6,EDGEFLAG:7,NUM_ATTRIBUTES:8},CellGhostTypes:{DUPLICATECELL:1,HIGHCONNECTIVITYCELL:2,LOWCONNECTIVITYCELL:4,REFINEDCELL:8,EXTERIORCELL:16,HIDDENCELL:32},DesiredOutputPrecision:Ms,PointGhostTypes:{DUPLICATEPOINT:1,HIDDENPOINT:2},ghostArrayName:&quot;vtkGhostType&quot;};const{AttributeTypes:Vs,AttributeCopyOperations:Ds}=Es,{vtkWarningMacro:Ls}=Wt,Bs={activeScalars:-1,activeVectors:-1,activeTensors:-1,activeNormals:-1,activeTCoords:-1,activeGlobalIds:-1,activePedigreeIds:-1};function Ns(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Bs,n),Rs.extend(e,t,n),Wt.setGet(e,t,[&quot;activeScalars&quot;,&quot;activeNormals&quot;,&quot;activeTCoords&quot;,&quot;activeVectors&quot;,&quot;activeTensors&quot;,&quot;activeGlobalIds&quot;,&quot;activePedigreeIds&quot;]),t.arrays||(t.arrays={}),function(e,t){const n=[&quot;Scalars&quot;,&quot;Vectors&quot;,&quot;Normals&quot;,&quot;TCoords&quot;,&quot;Tensors&quot;,&quot;GlobalIds&quot;,&quot;PedigreeIds&quot;];function r(e){let t=n.find((t=>Vs[t.toUpperCase()]===e||&quot;number&quot;!=typeof e&&t.toLowerCase()===e.toLowerCase()));return void 0===t&&(t=null),t}t.classHierarchy.push(&quot;vtkDataSetAttributes&quot;);const o={...e};e.checkNumberOfComponents=e=>!0,e.setAttribute=(n,o)=>{const a=r(o);if(n&&&quot;PEDIGREEIDS&quot;===a.toUpperCase()&&!n.isA(&quot;vtkDataArray&quot;))return Ls(`Cannot set attribute ${a}. The attribute must be a vtkDataArray.`),-1;if(n&&!e.checkNumberOfComponents(n,a))return Ls(`Cannot set attribute ${a}. Incorrect number of components.`),-1;let i=t[`active${a}`];if(i>=0&&i<t.arrays.length){if(t.arrays[i]===n)return i;e.removeArrayByIndex(i)}return n?(i=e.addArray(n),t[`active${a}`]=i):t[`active${a}`]=-1,e.modified(),t[`active${a}`]},e.getAttributes=t=>n.filter((n=>e[`get${n}`]()===t)),e.setActiveAttributeByName=(t,n)=>e.setActiveAttributeByIndex(e.getArrayWithIndex(t).index,n),e.setActiveAttributeByIndex=(n,o)=>{const a=r(o);if(n>=0&&n<t.arrays.length){if(&quot;PEDIGREEIDS&quot;!==a.toUpperCase()){const t=e.getArrayByIndex(n);if(!t.isA(&quot;vtkDataArray&quot;))return Ls(`Cannot set attribute ${a}. Only vtkDataArray subclasses can be set as active attributes.`),-1;if(!e.checkNumberOfComponents(t,a))return Ls(`Cannot set attribute ${a}. Incorrect number of components.`),-1}return t[`active${a}`]=n,e.modified(),n}return-1===n&&(t[`active${a}`]=n,e.modified()),-1},e.getActiveAttribute=t=>{const n=r(t);return e[`get${n}`]()},e.removeAllArrays=()=>{n.forEach((e=>{t[`active${e}`]=-1})),o.removeAllArrays()},e.removeArrayByIndex=e=>(-1!==e&&n.forEach((n=>{e===t[`active${n}`]?t[`active${n}`]=-1:e<t[`active${n}`]&&(t[`active${n}`]-=1)})),o.removeArrayByIndex(e)),n.forEach((n=>{const r=`active${n}`;e[`get${n}`]=()=>e.getArrayByIndex(t[r]),e[`set${n}`]=t=>e.setAttribute(t,n),e[`setActive${n}`]=t=>e.setActiveAttributeByIndex(e.getArrayWithIndex(t).index,n),e[`copy${n}Off`]=()=>{const e=n.toUpperCase();t.copyAttributeFlags[Ds.PASSDATA][Vs[e]]=!1},e[`copy${n}On`]=()=>{const e=n.toUpperCase();t.copyAttributeFlags[Ds.PASSDATA][Vs[e]]=!0}})),e.initializeAttributeCopyFlags=()=>{t.copyAttributeFlags=[],Object.keys(Ds).filter((e=>&quot;ALLCOPY&quot;!==e)).forEach((e=>{t.copyAttributeFlags[Ds[e]]=Object.keys(Vs).filter((e=>&quot;NUM_ATTRIBUTES&quot;!==e)).reduce(((e,t)=>(e[Vs[t]]=!0,e)),[])})),t.copyAttributeFlags[Ds.COPYTUPLE][Vs.GLOBALIDS]=!1,t.copyAttributeFlags[Ds.INTERPOLATE][Vs.GLOBALIDS]=!1,t.copyAttributeFlags[Ds.COPYTUPLE][Vs.PEDIGREEIDS]=!1},e.initialize=Wt.chain(e.initialize,e.initializeAttributeCopyFlags),t.dataArrays&&Object.keys(t.dataArrays).length&&Object.keys(t.dataArrays).forEach((n=>{t.dataArrays[n].ref||&quot;vtkDataArray&quot;!==t.dataArrays[n].type||e.addArray(xs.newInstance(t.dataArrays[n]))}));const a=e.shallowCopy;e.shallowCopy=(e,n)=>{a(e,n),t.arrays=e.getArrays().map((e=>{const t=e.newClone();return t.shallowCopy(e,n),{data:t}}))},e.initializeAttributeCopyFlags()}(e,t)}var Fs={newInstance:Wt.newInstance(Ns,&quot;vtkDataSetAttributes&quot;),extend:Ns,...Es};const _s=[&quot;pointData&quot;,&quot;cellData&quot;,&quot;fieldData&quot;],ks={};function Gs(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ks,n),Wt.obj(e,t),Wt.setGet(e,t,_s),Wt.getArray(e,t,[&quot;bounds&quot;],6),function(e,t){t.classHierarchy.push(&quot;vtkDataSet&quot;),_s.forEach((e=>{t[e]?t[e]=ze(t[e]):t[e]=Fs.newInstance()})),e.computeBounds=()=>{if(t.modifiedTime&&t.computeTime&&t.modifiedTime>t.computeTime||!t.computeTime){const n=e.getPoints();n?.getNumberOfPoints()?Gi.setBounds(t.bounds,n.getBoundsByReference()):t.bounds=Da.createUninitializedBounds(),t.computeTime=Wt.getCurrentGlobalMTime()}},e.getLength2=()=>{const t=e.getBoundsByReference();return t&&6===t.length?Gi.getDiagonalLength2(t):0},e.getLength=()=>Math.sqrt(e.getLength2()),e.getCenter=()=>{const t=e.getBoundsByReference();return t&&6===t.length?Gi.getCenter(t):[0,0,0]},e.getCellBounds=t=>{const n=e.getCell(t);return n?n.getBounds():Da.createUninitializedBounds()},e.getBounds=Wt.chain((()=>e.computeBounds),e.getBounds),e.getBoundsByReference=Wt.chain((()=>e.computeBounds),e.getBoundsByReference);const n=e.shallowCopy;e.shallowCopy=function(e){n(e,arguments.length>1&&void 0!==arguments[1]&&arguments[1]),_s.forEach((n=>{t[n]=Fs.newInstance(),t[n].shallowCopy(e.getReferenceByName(n))}))};const r=e.getMTime;e.getMTime=()=>_s.reduce(((e,n)=>Math.max(e,t[n]?.getMTime()??e)),r()),e.initialize=()=>(_s.forEach((e=>t[e]?.initialize())),e)}(e,t)}var Us={newInstance:Wt.newInstance(Gs,&quot;vtkDataSet&quot;),extend:Gs,FieldDataTypes:{UNIFORM:0,DATA_OBJECT_FIELD:0,COORDINATE:1,POINT_DATA:1,POINT:2,POINT_FIELD_DATA:2,CELL:3,CELL_FIELD_DATA:3,VERTEX:4,VERTEX_FIELD_DATA:4,EDGE:5,EDGE_FIELD_DATA:5,ROW:6,ROW_DATA:6},FieldAssociations:{FIELD_ASSOCIATION_POINTS:0,FIELD_ASSOCIATION_CELLS:1,FIELD_ASSOCIATION_NONE:2,FIELD_ASSOCIATION_POINTS_THEN_CELLS:3,FIELD_ASSOCIATION_VERTICES:4,FIELD_ASSOCIATION_EDGES:5,FIELD_ASSOCIATION_ROWS:6,NUMBER_OF_ASSOCIATIONS:7}};const zs={UNCHANGED:0,SINGLE_POINT:1,X_LINE:2,Y_LINE:3,Z_LINE:4,XY_PLANE:5,YZ_PLANE:6,XZ_PLANE:7,XYZ_GRID:8,EMPTY:9};var Ws={StructuredType:zs};const{StructuredType:Hs}=Ws;var js={getDataDescriptionFromExtent:function(e){let t=0;for(let n=0;n<3;++n)e[2*n]<e[2*n+1]&&t++;return e[0]>e[1]||e[2]>e[3]||e[4]>e[5]?Hs.EMPTY:3===t?Hs.XYZ_GRID:2===t?e[0]===e[1]?Hs.YZ_PLANE:e[2]===e[3]?Hs.XZ_PLANE:Hs.XY_PLANE:1===t?e[0]<e[1]?Hs.X_LINE:e[2]<e[3]?Hs.Y_LINE:Hs.Z_LINE:Hs.SINGLE_POINT},...Ws};const{vtkErrorMacro:Ks}=Wt,$s={direction:null,indexToWorld:null,worldToIndex:null,spacing:[1,1,1],origin:[0,0,0],extent:[0,-1,0,-1,0,-1],dataDescription:zs.EMPTY};function qs(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,$s,n),Us.extend(e,t,n),t.direction?Array.isArray(t.direction)&&(t.direction=new Float64Array(t.direction.slice(0,9))):t.direction=fe(new Float64Array(9)),t.indexToWorld=new Float64Array(16),t.worldToIndex=new Float64Array(16),Wt.get(e,t,[&quot;indexToWorld&quot;,&quot;worldToIndex&quot;]),Wt.setGetArray(e,t,[&quot;origin&quot;,&quot;spacing&quot;],3),Wt.setGetArray(e,t,[&quot;direction&quot;],9),Wt.getArray(e,t,[&quot;extent&quot;],6),function(e,t){t.classHierarchy.push(&quot;vtkImageData&quot;),e.setExtent=function(){if(t.deleted)return Ks(&quot;instance deleted - cannot call any method&quot;),!1;for(var n=arguments.length,r=new Array(n),o=0;o<n;o++)r[o]=arguments[o];const a=1===r.length?r[0]:r;if(6!==a.length)return!1;const i=t.extent.some(((e,t)=>e!==a[t]));return i&&(t.extent=a.slice(),t.dataDescription=js.getDataDescriptionFromExtent(t.extent),e.modified()),i},e.setDimensions=function(){let n,r,o;if(t.deleted)Ks(&quot;instance deleted - cannot call any method&quot;);else{if(1===arguments.length){const e=arguments.length<=0?void 0:arguments[0];n=e[0],r=e[1],o=e[2]}else{if(3!==arguments.length)return void Ks(&quot;Bad dimension specification&quot;);n=arguments.length<=0?void 0:arguments[0],r=arguments.length<=1?void 0:arguments[1],o=arguments.length<=2?void 0:arguments[2]}e.setExtent(0,n-1,0,r-1,0,o-1)}},e.getDimensions=()=>[t.extent[1]-t.extent[0]+1,t.extent[3]-t.extent[2]+1,t.extent[5]-t.extent[4]+1],e.getNumberOfCells=()=>{const t=e.getDimensions();let n=1;for(let e=0;e<3;e++){if(0===t[e])return 0;t[e]>1&&(n*=t[e]-1)}return n},e.getNumberOfPoints=()=>{const t=e.getDimensions();return t[0]*t[1]*t[2]},e.getPoint=n=>{const r=e.getDimensions();if(0===r[0]||0===r[1]||0===r[2])return Ks(&quot;Requesting a point from an empty image.&quot;),null;const o=new Float64Array(3);switch(t.dataDescription){case zs.EMPTY:return null;case zs.SINGLE_POINT:break;case zs.X_LINE:o[0]=n;break;case zs.Y_LINE:o[1]=n;break;case zs.Z_LINE:o[2]=n;break;case zs.XY_PLANE:o[0]=n%r[0],o[1]=n/r[0];break;case zs.YZ_PLANE:o[1]=n%r[1],o[2]=n/r[1];break;case zs.XZ_PLANE:o[0]=n%r[0],o[2]=n/r[0];break;case zs.XYZ_GRID:o[0]=n%r[0],o[1]=n/r[0]%r[1],o[2]=n/(r[0]*r[1]);break;default:Ks(&quot;Invalid dataDescription&quot;)}const a=[0,0,0];return e.indexToWorld(o,a),a},e.getBounds=()=>e.extentToBounds(e.getSpatialExtent()),e.extentToBounds=e=>Gi.transformBounds(e,t.indexToWorld),e.getSpatialExtent=()=>Gi.inflate([...t.extent],.5),e.computeTransforms=()=>{O(t.indexToWorld,t.origin),t.indexToWorld[0]=t.direction[0],t.indexToWorld[1]=t.direction[1],t.indexToWorld[2]=t.direction[2],t.indexToWorld[4]=t.direction[3],t.indexToWorld[5]=t.direction[4],t.indexToWorld[6]=t.direction[5],t.indexToWorld[8]=t.direction[6],t.indexToWorld[9]=t.direction[7],t.indexToWorld[10]=t.direction[8],C(t.indexToWorld,t.indexToWorld,t.spacing),v(t.worldToIndex,t.indexToWorld)},e.indexToWorld=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return In(n,e,t.indexToWorld),n},e.indexToWorldVec3=e.indexToWorld,e.worldToIndex=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return In(n,e,t.worldToIndex),n},e.worldToIndexVec3=e.worldToIndex,e.indexToWorldBounds=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return Gi.transformBounds(e,t.indexToWorld,n)},e.worldToIndexBounds=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return Gi.transformBounds(e,t.worldToIndex,n)},t._onOriginChanged=e.computeTransforms,t._onDirectionChanged=e.computeTransforms,t._onSpacingChanged=e.computeTransforms,e.computeTransforms(),e.getCenter=()=>Gi.getCenter(e.getBounds()),e.computeHistogram=function(t){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;const r=[0,0,0,0,0,0];e.worldToIndexBounds(t,r);const o=[0,0,0],a=[0,0,0];Gi.computeCornerPoints(r,o,a),ea(o,o),ea(a,a);const i=e.getDimensions();xa(o,[0,0,0],[i[0]-1,i[1]-1,i[2]-1],o),xa(a,[0,0,0],[i[0]-1,i[1]-1,i[2]-1],a);const s=i[0],l=i[0]*i[1],c=e.getPointData().getScalars().getData();let u=-1/0,d=1/0,p=0,f=0,g=0;for(let e=o[2];e<=a[2];e++)for(let t=o[1];t<=a[1];t++){let i=o[0]+t*s+e*l;for(let s=o[0];s<=a[0];s++){if(!n||n([s,t,e],r)){const e=c[i];e>u&&(u=e),e<d&&(d=e),p+=e*e,f+=e,g+=1}++i}}const m=g>0?f/g:0,h=g?Math.abs(p/g-m*m):0;return{minimum:d,maximum:u,average:m,variance:h,sigma:Math.sqrt(h),count:g}},e.computeIncrements=function(e){const t=[];let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;for(let r=0;r<3;++r)t[r]=n,n*=e[2*r+1]-e[2*r]+1;return t},e.computeOffsetIndex=t=>{let[n,r,o]=t;const a=e.getExtent(),i=e.getPointData().getScalars().getNumberOfComponents(),s=e.computeIncrements(a,i);return Math.floor((Math.round(n)-a[0])*s[0]+(Math.round(r)-a[2])*s[1]+(Math.round(o)-a[4])*s[2])},e.getOffsetIndexFromWorld=t=>{const n=e.getExtent(),r=e.worldToIndex(t);for(let e=0;e<3;++e)if(r[e]<n[2*e]||r[e]>n[2*e+1])return Ks(`GetScalarPointer: Pixel ${r} is not in memory. Current extent = ${n}`),NaN;return e.computeOffsetIndex(r)},e.getScalarValueFromWorld=function(t){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;const r=e.getPointData().getScalars().getNumberOfComponents();if(n<0||n>=r)return Ks(`GetScalarPointer: Scalar Component ${n} is not within bounds. Current Scalar numberOfComponents: ${r}`),NaN;const o=e.getOffsetIndexFromWorld(t);return Number.isNaN(o)?o:e.getPointData().getScalars().getComponent(o,n)};const n=e.initialize;e.initialize=()=>(e.set({direction:fe(t.direction),spacing:[1,1,1],origin:[0,0,0],extent:[0,-1,0,-1,0,-1],dataDescription:zs.EMPTY}),n())}(e,t)}var Xs={newInstance:Wt.newInstance(qs,&quot;vtkImageData&quot;),extend:qs};const Ys={LUMINANCE:1,LUMINANCE_ALPHA:2,RGB:3,RGBA:4};var Zs={VectorMode:{MAGNITUDE:0,COMPONENT:1,RGBCOLORS:2},ScalarMappingTarget:Ys,Scale:{LINEAR:0,LOG10:1}},Qs={ColorMode:{DEFAULT:0,MAP_SCALARS:1,DIRECT_SCALARS:2},GetArray:{BY_ID:0,BY_NAME:1},ScalarMode:{DEFAULT:0,USE_POINT_DATA:1,USE_CELL_DATA:2,USE_POINT_FIELD_DATA:3,USE_CELL_FIELD_DATA:4,USE_FIELD_DATA:5}};const{ScalarMappingTarget:Js,Scale:el,VectorMode:tl}=Zs,{VtkDataTypes:nl}=xs,{ColorMode:rl}=Qs,{vtkErrorMacro:ol}=Wt;function al(e){return e}function il(e){return Math.floor(255*e+.5)}const sl={alpha:1,vectorComponent:0,vectorSize:-1,vectorMode:tl.COMPONENT,mappingRange:null,annotationArray:null,annotatedValueMap:null,indexedLookup:!1,scale:el.LINEAR};function ll(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,sl,n),Wt.obj(e,t),t.mappingRange=[0,255],t.annotationArray=[],t.annotatedValueMap=[],Wt.setGet(e,t,[&quot;vectorSize&quot;,&quot;vectorComponent&quot;,&quot;vectorMode&quot;,&quot;alpha&quot;,&quot;indexedLookup&quot;]),Wt.setArray(e,t,[&quot;mappingRange&quot;],2),Wt.getArray(e,t,[&quot;mappingRange&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkScalarsToColors&quot;),e.setVectorModeToMagnitude=()=>e.setVectorMode(tl.MAGNITUDE),e.setVectorModeToComponent=()=>e.setVectorMode(tl.COMPONENT),e.setVectorModeToRGBColors=()=>e.setVectorMode(tl.RGBCOLORS),e.build=()=>{},e.isOpaque=()=>!0,e.setAnnotations=(n,r)=>{if(!(n&&!r||!n&&r))if(n&&r&&n.length!==r.length)ol(&quot;Values and annotations do not have the same number of tuples so ignoring&quot;);else{if(t.annotationArray=[],r&&n){const e=r.length;for(let o=0;o<e;o++)t.annotationArray.push({value:n[o],annotation:String(r[o])})}e.updateAnnotatedValueMap(),e.modified()}},e.setAnnotation=(n,r)=>{let o=e.checkForAnnotatedValue(n),a=!1;return o>=0?t.annotationArray[o].annotation!==r&&(t.annotationArray[o].annotation=r,a=!0):(t.annotationArray.push({value:n,annotation:r}),o=t.annotationArray.length-1,a=!0),a&&(e.updateAnnotatedValueMap(),e.modified()),o},e.getNumberOfAnnotatedValues=()=>t.annotationArray.length,e.getAnnotatedValue=e=>e<0||e>=t.annotationArray.length?null:t.annotationArray[e].value,e.getAnnotation=e=>void 0===t.annotationArray[e]?null:t.annotationArray[e].annotation,e.getAnnotatedValueIndex=n=>t.annotationArray.length?e.checkForAnnotatedValue(n):-1,e.removeAnnotation=n=>{const r=e.checkForAnnotatedValue(n),o=r>=0;return o&&(t.annotationArray.splice(r,1),e.updateAnnotatedValueMap(),e.modified()),o},e.resetAnnotations=()=>{t.annotationArray=[],t.annotatedValueMap=[],e.modified()},e.getAnnotationColor=(n,r)=>{if(t.indexedLookup){const t=e.getAnnotatedValueIndex(n);e.getIndexedColor(t,r)}else e.getColor(parseFloat(n),r),r[3]=1},e.checkForAnnotatedValue=t=>e.getAnnotatedValueIndexInternal(t),e.getAnnotatedValueIndexInternal=e=>{if(void 0!==t.annotatedValueMap[e]){const n=t.annotationArray.length;return t.annotatedValueMap[e]%n}return-1},e.getIndexedColor=(e,t)=>{t[0]=0,t[1]=0,t[2]=0,t[3]=0},e.updateAnnotatedValueMap=()=>{t.annotatedValueMap=[];const e=t.annotationArray.length;for(let n=0;n<e;n++)t.annotatedValueMap[t.annotationArray[n].value]=n},e.mapScalars=(t,n,r)=>{const o=t.getNumberOfComponents();let a=null;if(n===rl.DEFAULT&&(t.getDataType()===nl.UNSIGNED_CHAR||t.getDataType()===nl.UNSIGNED_CHAR_CLAMPED)||n===rl.DIRECT_SCALARS&&t)a=e.convertToRGBA(t,o,t.getNumberOfTuples());else{const n={type:&quot;vtkDataArray&quot;,name:&quot;temp&quot;,numberOfComponents:4,dataType:nl.UNSIGNED_CHAR},i=Wt.newTypedArray(n.dataType,4*t.getNumberOfTuples());n.values=i,n.size=i.length,a=xs.newInstance(n);let s=r;s<0&&o>1?e.mapVectorsThroughTable(t,a,Js.RGBA,-1,-1):(s<0&&(s=0),s>=o&&(s=o-1),e.mapScalarsThroughTable(t,a,Js.RGBA,s))}return a},e.mapVectorsToMagnitude=(e,t,n)=>{const r=e.getNumberOfTuples(),o=e.getNumberOfComponents(),a=t.getData(),i=e.getData();for(let e=0;e<r;e++){let t=0;for(let r=0;r<n;r++)t+=i[e*o+r]*i[e*o+r];a[e]=Math.sqrt(t)}},e.mapVectorsThroughTable=(t,n,r,o,a)=>{let i=e.getVectorMode(),s=a,l=o;const c=t.getNumberOfComponents();i===tl.COMPONENT?(-1===l&&(l=e.getVectorComponent()),l<0&&(l=0),l>=c&&(l=c-1)):(-1===s&&(s=e.getVectorSize()),s<=0?(l=0,s=c):(l<0&&(l=0),l>=c&&(l=c-1),l+s>c&&(s=c-l)),i!==tl.MAGNITUDE||1!==c&&1!==s||(i=tl.COMPONENT));let u=0;switch(l>0&&(u=l),i){case tl.COMPONENT:e.mapScalarsThroughTable(t,n,r,u);break;case tl.RGBCOLORS:break;case tl.MAGNITUDE:default:{const o=xs.newInstance({numberOfComponents:1,values:new Float32Array(t.getNumberOfTuples())});e.mapVectorsToMagnitude(t,o,s),e.mapScalarsThroughTable(o,n,r,0);break}}},e.luminanceToRGBA=(e,t,n,r)=>{const o=r(n),a=t.getData(),i=e.getData(),s=a.length;let l=0;for(let e=0;e<s;e+=1){const t=r(a[e]);i[4*l]=t,i[4*l+1]=t,i[4*l+2]=t,i[4*l+3]=o,l++}},e.luminanceAlphaToRGBA=(e,t,n,r)=>{const o=t.getData(),a=e.getData(),i=o.length;let s=0;for(let e=0;e<i;e+=2){const t=r(o[e]);a[s]=t,a[s+1]=t,a[s+2]=t,a[s+3]=r(o[e+1])*n,s+=4}},e.rGBToRGBA=(e,t,n,r)=>{const o=il(n),a=t.getData(),i=e.getData(),s=a.length;let l=0;for(let e=0;e<s;e+=3)i[4*l]=r(a[e]),i[4*l+1]=r(a[e+1]),i[4*l+2]=r(a[e+2]),i[4*l+3]=o,l++},e.rGBAToRGBA=(e,t,n,r)=>{const o=t.getData(),a=e.getData(),i=o.length;let s=0;for(let e=0;e<i;e+=4)a[4*s]=r(o[e]),a[4*s+1]=r(o[e+1]),a[4*s+2]=r(o[e+2]),a[4*s+3]=r(o[e+3])*n,s++},e.convertToRGBA=(n,r,o)=>{let{alpha:a}=t;if(4===r&&a>=1&&n.getDataType()===nl.UNSIGNED_CHAR)return n;const i=xs.newInstance({numberOfComponents:4,empty:!0,size:4*o,dataType:nl.UNSIGNED_CHAR});if(o<=0)return i;a=a>0?a:0,a=a<1?a:1;let s=al;switch(n.getDataType()!==nl.FLOAT&&n.getDataType()!==nl.DOUBLE||(s=il),r){case 1:e.luminanceToRGBA(i,n,a,s);break;case 2:e.luminanceAlphaToRGBA(i,n,s);break;case 3:e.rGBToRGBA(i,n,a,s);break;case 4:e.rGBAToRGBA(i,n,a,s);break;default:return ol(&quot;Cannot convert colors&quot;),null}return i},e.usingLogScale=()=>!1,e.getNumberOfAvailableColors=()=>16777216,e.setRange=(t,n)=>e.setMappingRange(t,n),e.getRange=()=>e.getMappingRange(),e.areScalarsOpaque=(n,r,o)=>{if(!n)return e.isOpaque();const a=n.getNumberOfComponents();return(r!==rl.DEFAULT||n.getDataType()!==nl.UNSIGNED_CHAR)&&r!==rl.DIRECT_SCALARS||(3===a||1===a?t.alpha>=1:255===n.getRange(a-1)[0])}}(e,t)}var cl={newInstance:Wt.newInstance(ll,&quot;vtkScalarsToColors&quot;),extend:ll,...Zs};const{vtkErrorMacro:ul}=Wt,dl={numberOfColors:256,hueRange:[0,.66667],saturationRange:[1,1],valueRange:[1,1],alphaRange:[1,1],nanColor:[.5,0,0,1],belowRangeColor:[0,0,0,1],aboveRangeColor:[1,1,1,1],useAboveRangeColor:!1,useBelowRangeColor:!1,alpha:1};function pl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,dl,n),cl.extend(e,t,n),t.table||(t.table=[]),t.buildTime={},Wt.obj(t.buildTime),t.opaqueFlagBuildTime={},Wt.obj(t.opaqueFlagBuildTime,{mtime:0}),t.insertTime={},Wt.obj(t.insertTime,{mtime:0}),Wt.get(e,t,[&quot;buildTime&quot;]),Wt.setGet(e,t,[&quot;numberOfColors&quot;,&quot;useAboveRangeColor&quot;,&quot;useBelowRangeColor&quot;]),Wt.setArray(e,t,[&quot;alphaRange&quot;,&quot;hueRange&quot;,&quot;saturationRange&quot;,&quot;valueRange&quot;],2),Wt.setArray(e,t,[&quot;nanColor&quot;,&quot;belowRangeColor&quot;,&quot;aboveRangeColor&quot;],4),Wt.getArray(e,t,[&quot;hueRange&quot;,&quot;saturationRange&quot;,&quot;valueRange&quot;,&quot;alphaRange&quot;,&quot;nanColor&quot;,&quot;belowRangeColor&quot;,&quot;aboveRangeColor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkLookupTable&quot;),e.isOpaque=()=>{if(t.opaqueFlagBuildTime.getMTime()<e.getMTime()){let e=!0;t.nanColor[3]<1&&(e=0),t.useBelowRangeColor&&t.belowRangeColor[3]<1&&(e=0),t.useAboveRangeColor&&t.aboveRangeColor[3]<1&&(e=0);for(let n=3;n<t.table.length&&e;n+=4)t.table[n]<255&&(e=!1);t.opaqueFlag=e,t.opaqueFlagBuildTime.modified()}return t.opaqueFlag},e.usingLogScale=()=>!1,e.getNumberOfAvailableColors=()=>t.table.length/4-3,e.linearIndexLookup=(e,t)=>{let n=0;const r=Number(e);return r<t.range[0]?n=t.maxIndex+0+1.5:r>t.range[1]?n=t.maxIndex+1+1.5:(n=(r+t.shift)*t.scale,n=n<t.maxIndex?n:t.maxIndex),Math.floor(n)},e.linearLookup=(t,n,r)=>{let o=0;o=Oa(t)?Math.floor(r.maxIndex+1.5+2):e.linearIndexLookup(t,r);const a=4*o;return n.slice(a,a+4)},e.indexedLookupFunction=(n,r,o)=>{let a=e.getAnnotatedValueIndexInternal(n);-1===a&&(a=t.numberOfColors+2);const i=4*a;return[r[i],r[i+1],r[i+2],r[i+3]]},e.lookupShiftAndScale=(e,t)=>{t.shift=-e[0],t.scale=Number.MAX_VALUE,e[1]>e[0]&&(t.scale=(t.maxIndex+1)/(e[1]-e[0]))},e.mapScalarsThroughTable=(n,r,o,a)=>{let i=e.linearLookup;t.indexedLookup&&(i=e.indexedLookupFunction);const s=e.getMappingRange(),l={maxIndex:e.getNumberOfColors()-1,range:s,shift:0,scale:0};e.lookupShiftAndScale(s,l);const c=e.getAlpha(),u=n.getNumberOfTuples(),d=n.getNumberOfComponents(),p=r.getData(),f=n.getData();if(c>=1){if(o===Ys.RGBA)for(let e=0;e<u;e++){const n=i(f[e*d+a],t.table,l);p[4*e]=n[0],p[4*e+1]=n[1],p[4*e+2]=n[2],p[4*e+3]=n[3]}}else if(o===Ys.RGBA)for(let e=0;e<u;e++){const n=i(f[e*d+a],t.table,l);p[4*e]=n[0],p[4*e+1]=n[1],p[4*e+2]=n[2],p[4*e+3]=Math.floor(n[3]*c+.5)}},e.forceBuild=()=>{let n=0,r=0,o=0,a=0;const i=t.numberOfColors-1;i&&(n=(t.hueRange[1]-t.hueRange[0])/i,r=(t.saturationRange[1]-t.saturationRange[0])/i,o=(t.valueRange[1]-t.valueRange[0])/i,a=(t.alphaRange[1]-t.alphaRange[0])/i),t.table.length=4*i+16;const s=[],l=[];for(let e=0;e<=i;e++)s[0]=t.hueRange[0]+e*n,s[1]=t.saturationRange[0]+e*r,s[2]=t.valueRange[0]+e*o,da(s,l),l[3]=t.alphaRange[0]+e*a,t.table[4*e]=255*l[0]+.5,t.table[4*e+1]=255*l[1]+.5,t.table[4*e+2]=255*l[2]+.5,t.table[4*e+3]=255*l[3]+.5;e.buildSpecialColors(),t.buildTime.modified()},e.setTable=n=>{if(Array.isArray(n)){const r=n[0].length;t.numberOfColors=n.length;const o=4-r;let a=0;for(let e=0;e<t.numberOfColors;e++)t.table[4*e]=255,t.table[4*e+1]=255,t.table[4*e+2]=255,t.table[4*e+3]=255;for(let e=0;e<n.length;e++){const i=n[e];for(let e=0;e<r;e++)t.table[a++]=i[e];a+=o}return e.buildSpecialColors(),t.insertTime.modified(),e.modified(),!0}if(4!==n.getNumberOfComponents())return ul(&quot;Expected 4 components for RGBA colors&quot;),!1;if(n.getDataType()!==cs.UNSIGNED_CHAR)return ul(&quot;Expected unsigned char values for RGBA colors&quot;),!1;t.numberOfColors=n.getNumberOfTuples();const r=n.getData();t.table.length=r.length;for(let e=0;e<r.length;e++)t.table[e]=r[e];return e.buildSpecialColors(),t.insertTime.modified(),e.modified(),!0},e.buildSpecialColors=()=>{const{numberOfColors:e}=t,n=t.table;let r=4*(e+0);t.useBelowRangeColor||0===e?(n[r]=255*t.belowRangeColor[0]+.5,n[r+1]=255*t.belowRangeColor[1]+.5,n[r+2]=255*t.belowRangeColor[2]+.5,n[r+3]=255*t.belowRangeColor[3]+.5):(n[r]=n[0],n[r+1]=n[1],n[r+2]=n[2],n[r+3]=n[3]),r=4*(e+1),t.useAboveRangeColor||0===e?(n[r]=255*t.aboveRangeColor[0]+.5,n[r+1]=255*t.aboveRangeColor[1]+.5,n[r+2]=255*t.aboveRangeColor[2]+.5,n[r+3]=255*t.aboveRangeColor[3]+.5):(n[r]=n[4*(e-1)+0],n[r+1]=n[4*(e-1)+1],n[r+2]=n[4*(e-1)+2],n[r+3]=n[4*(e-1)+3]),r=4*(e+2),n[r]=255*t.nanColor[0]+.5,n[r+1]=255*t.nanColor[1]+.5,n[r+2]=255*t.nanColor[2]+.5,n[r+3]=255*t.nanColor[3]+.5},e.build=()=>{(t.table.length<1||e.getMTime()>t.buildTime.getMTime()&&t.insertTime.getMTime()<=t.buildTime.getMTime())&&e.forceBuild()},t.table.length>0&&(e.buildSpecialColors(),t.insertTime.modified())}(e,t)}var fl={newInstance:Wt.newInstance(pl,&quot;vtkLookupTable&quot;),extend:pl};const gl={Off:0,PolygonOffset:1};let ml=gl.PolygonOffset,hl=gl.Off;const vl=[&quot;VTK_RESOLVE_OFF&quot;,&quot;VTK_RESOLVE_POLYGON_OFFSET&quot;];function Tl(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;const t=hl===e;return hl=e,t}var yl={Resolve:gl,getResolveCoincidentTopologyAsString:function(){return vl[hl]},getResolveCoincidentTopologyPolygonOffsetFaces:function(){return ml},getResolveCoincidentTopology:function(){return hl},setResolveCoincidentTopology:Tl,setResolveCoincidentTopologyPolygonOffsetFaces:function(e){const t=ml===e;return ml=e,t},setResolveCoincidentTopologyToDefault:function(){return Tl(gl.Off)},setResolveCoincidentTopologyToOff:function(){return Tl(gl.Off)},setResolveCoincidentTopologyToPolygonOffset:function(){return Tl(gl.PolygonOffset)}};function bl(e,t,n){n.forEach((n=>{e[`get${n.method}`]=()=>t[n.key],e[`set${n.method}`]=Wt.objectSetterMap.object(e,t,{name:n.key,params:[&quot;factor&quot;,&quot;offset&quot;]})}))}const xl=[&quot;Polygon&quot;,&quot;Line&quot;,&quot;Point&quot;],Cl={modified:()=>{}};bl(Cl,{Polygon:{factor:2,offset:0},Line:{factor:1,offset:-1},Point:{factor:0,offset:-2}},xl.map((e=>({key:e,method:`ResolveCoincidentTopology${e}OffsetParameters`}))));var Sl={implementCoincidentTopologyMethods:function(e,t){void 0===t.resolveCoincidentTopology&&(t.resolveCoincidentTopology=!1),Wt.setGet(e,t,[&quot;resolveCoincidentTopology&quot;]),t.topologyOffset={Polygon:{factor:0,offset:0},Line:{factor:0,offset:0},Point:{factor:0,offset:0}},Object.keys(yl).forEach((t=>{e[t]=yl[t]})),Object.keys(Cl).filter((e=>&quot;modified&quot;!==e)).forEach((t=>{e[t]=Cl[t]})),bl(e,t.topologyOffset,xl.map((e=>({key:e,method:`RelativeCoincidentTopology${e}OffsetParameters`})))),e.getCoincidentTopologyPolygonOffsetParameters=()=>{const t=Cl.getResolveCoincidentTopologyPolygonOffsetParameters(),n=e.getRelativeCoincidentTopologyPolygonOffsetParameters();return{factor:t.factor+n.factor,offset:t.offset+n.offset}},e.getCoincidentTopologyLineOffsetParameters=()=>{const t=Cl.getResolveCoincidentTopologyLineOffsetParameters(),n=e.getRelativeCoincidentTopologyLineOffsetParameters();return{factor:t.factor+n.factor,offset:t.offset+n.offset}},e.getCoincidentTopologyPointOffsetParameter=()=>{const t=Cl.getResolveCoincidentTopologyPointOffsetParameters(),n=e.getRelativeCoincidentTopologyPointOffsetParameters();return{factor:t.factor+n.factor,offset:t.offset+n.offset}}},staticOffsetAPI:Cl,otherStaticMethods:yl,CATEGORIES:xl,Resolve:gl};const Al={MIN_KNOWN_PASS:0,ACTOR_PASS:0,COMPOSITE_INDEX_PASS:1,ID_LOW24:2,ID_HIGH24:3,MAX_KNOWN_PASS:3};var Il={PassTypes:Al};const{FieldAssociations:wl}=Us,{staticOffsetAPI:Ol,otherStaticMethods:Pl}=Sl,{ColorMode:Rl,ScalarMode:Ml,GetArray:El}=Qs,{VectorMode:Vl}=Zs,{VtkDataTypes:Dl}=xs;function Ll(e){return()=>Wt.vtkErrorMacro(`vtkMapper::${e} - NOT IMPLEMENTED`)}function Bl(e,t){const n=e[1]%2==0?1:-1;if(e[0]+=n,e[0]>=t[0]||e[0]<0){const r=e[2]%2==0?1:-1;e[0]-=n,e[1]+=r,(e[1]>=t[1]||e[1]<0)&&(e[1]-=r,e[2]++)}}function Nl(e,t,n){const r=Math.floor(t),o=r%(2*n[0]);let a,i;o<n[0]?(e[0]=o,a=1,i=e[0]===n[0]-1):(e[0]=2*n[0]-1-o,a=-1,i=0===e[0]);const s=Math.floor(r/n[0]),l=s%(2*n[1]);let c,u;l<n[1]?(e[1]=l,c=1,u=e[1]===n[1]-1):(e[1]=2*n[1]-1-l,c=-1,u=0===e[1]),e[2]=Math.floor(s/n[1]);const d=t-r;i?u?e[2]+=d:e[1]+=c*d:e[0]+=a*d,e[0]=(e[0]+.5)/n[0],e[1]=(e[1]+.5)/n[1],e[2]=(e[2]+.5)/n[2]}const Fl=new WeakMap;const _l={colorMapColors:null,areScalarsMappedFromCells:!1,static:!1,lookupTable:null,scalarVisibility:!0,scalarRange:[0,1],useLookupTableScalarRange:!1,colorMode:0,scalarMode:0,arrayAccessMode:1,renderTime:0,colorByArrayName:null,fieldDataTupleId:-1,populateSelectionSettings:!0,selectionWebGLIdsToVTKIds:null,interpolateScalarsBeforeMapping:!1,colorCoordinates:null,colorTextureMap:null,numberOfColorsInRange:0,forceCompileOnly:0,useInvertibleColors:!1,invertibleScalars:null,customShaderAttributes:[]};function kl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,_l,n),As(e,t,n),Wt.get(e,t,[&quot;areScalarsMappedFromCells&quot;,&quot;colorCoordinates&quot;,&quot;colorMapColors&quot;,&quot;colorTextureMap&quot;,&quot;numberOfColorsInRange&quot;,&quot;selectionWebGLIdsToVTKIds&quot;]),Wt.setGet(e,t,[&quot;colorByArrayName&quot;,&quot;arrayAccessMode&quot;,&quot;colorMode&quot;,&quot;fieldDataTupleId&quot;,&quot;interpolateScalarsBeforeMapping&quot;,&quot;lookupTable&quot;,&quot;populateSelectionSettings&quot;,&quot;renderTime&quot;,&quot;scalarMode&quot;,&quot;scalarVisibility&quot;,&quot;static&quot;,&quot;useLookupTableScalarRange&quot;,&quot;customShaderAttributes&quot;]),Wt.setGetArray(e,t,[&quot;scalarRange&quot;],2),Sl.implementCoincidentTopologyMethods(e,t),function(e,t){t.classHierarchy.push(&quot;vtkMapper&quot;),e.getBounds=()=>{const n=e.getInputData();return n?(t.static||e.update(),t.bounds=n.getBounds()):t.bounds=Pa(),t.bounds},e.setForceCompileOnly=e=>{t.forceCompileOnly=e},e.setSelectionWebGLIdsToVTKIds=e=>{t.selectionWebGLIdsToVTKIds=e},e.createDefaultLookupTable=()=>{t.lookupTable=fl.newInstance()},e.getColorModeAsString=()=>Wt.enumToString(Rl,t.colorMode),e.setColorModeToDefault=()=>e.setColorMode(0),e.setColorModeToMapScalars=()=>e.setColorMode(1),e.setColorModeToDirectScalars=()=>e.setColorMode(2),e.getScalarModeAsString=()=>Wt.enumToString(Ml,t.scalarMode),e.setScalarModeToDefault=()=>e.setScalarMode(0),e.setScalarModeToUsePointData=()=>e.setScalarMode(1),e.setScalarModeToUseCellData=()=>e.setScalarMode(2),e.setScalarModeToUsePointFieldData=()=>e.setScalarMode(3),e.setScalarModeToUseCellFieldData=()=>e.setScalarMode(4),e.setScalarModeToUseFieldData=()=>e.setScalarMode(5),e.getAbstractScalars=(e,n,r,o,a)=>{if(!e||!t.scalarVisibility)return{scalars:null,cellFlag:!1};let i=null,s=!1;if(n===Ml.DEFAULT)i=e.getPointData().getScalars(),i||(i=e.getCellData().getScalars(),s=!0);else if(n===Ml.USE_POINT_DATA)i=e.getPointData().getScalars();else if(n===Ml.USE_CELL_DATA)i=e.getCellData().getScalars(),s=!0;else if(n===Ml.USE_POINT_FIELD_DATA){const t=e.getPointData();i=r===El.BY_ID?t.getArrayByIndex(o):t.getArrayByName(a)}else if(n===Ml.USE_CELL_FIELD_DATA){const t=e.getCellData();s=!0,i=r===El.BY_ID?t.getArrayByIndex(o):t.getArrayByName(a)}else if(n===Ml.USE_FIELD_DATA){const t=e.getFieldData();i=r===El.BY_ID?t.getArrayByIndex(o):t.getArrayByName(a)}return{scalars:i,cellFlag:s}},e.mapScalars=(n,r)=>{const{scalars:o,cellFlag:a}=e.getAbstractScalars(n,t.scalarMode,t.arrayAccessMode,t.arrayId,t.colorByArrayName);if(t.areScalarsMappedFromCells=a,!o)return t.colorCoordinates=null,t.colorTextureMap=null,void(t.colorMapColors=null);const i=`${e.getMTime()}${o.getMTime()}${r}`;if(t.colorBuildString!==i){if(t.useLookupTableScalarRange||e.getLookupTable().setRange(t.scalarRange[0],t.scalarRange[1]),e.canUseTextureMapForColoring(o,a))t.mapScalarsToTexture(o,a,r);else{t.colorCoordinates=null,t.colorTextureMap=null;const n=e.getLookupTable();n&&(n.build(),t.colorMapColors=n.mapScalars(o,t.colorMode,t.fieldDataTupleId))}t.colorBuildString=`${e.getMTime()}${o.getMTime()}${r}`}},t.mapScalarsToTexture=(n,r,o)=>{const a=t.lookupTable.getRange(),i=t.lookupTable.usingLogScale(),s=t.lookupTable.getAlpha(),l=i?[Math.log10(a[0]),Math.log10(a[1])]:a;if(t.colorMapColors=null,null==t.colorTextureMap||e.getMTime()>t.colorTextureMap.getMTime()||t.lookupTable.getMTime()>t.colorTextureMap.getMTime()||t.lookupTable.getAlpha()!==o){t.lookupTable.setAlpha(o),t.colorTextureMap=null,t.lookupTable.build();const e=t.lookupTable.getNumberOfAvailableColors(),n=2048,a=2,d=r?n**3-3:4094;t.numberOfColorsInRange=Math.min(Math.max(e,a),d);const p=t.numberOfColorsInRange+3,f=t.numberOfColorsInRange+2,g=r?[Math.min(Math.ceil(p/n**0),n),Math.min(Math.ceil(p/n**1),n),Math.min(Math.ceil(p/n**2),n)]:[f,2,1],m=g[0]*g[1]*g[2],h=new Float64Array(m);h.fill(NaN);const v=t.numberOfColorsInRange,T=v+2,y=[0,0,0],b=l[0],x=l[1]-l[0];for(let e=0;e<T;++e){const t=b+x*(e-1)/(v-1),n=i?10**t:t;h[(u=g,(c=y)[0]+u[0]*(c[1]+u[1]*c[2]))]=n,Bl(y,g)}const C=xs.newInstance({numberOfComponents:1,values:h}),S=t.lookupTable.mapScalars(C,t.colorMode,0);t.colorTextureMap=Xs.newInstance(),t.colorTextureMap.setDimensions(g),t.colorTextureMap.getPointData().setScalars(S),t.lookupTable.setAlpha(s)}var c,u;const d=t.lookupTable.getVectorMode()===Vl.MAGNITUDE&&n.getNumberOfComponents()>1?-1:t.lookupTable.getVectorComponent();t.colorCoordinates=function(e,t,n,r,o,a,i){const s=new Array(arguments.length);for(let e=0;e<arguments.length;++e){const t=arguments[e];s[e]=t.getMTime?.()??t}const l=s.join(&quot;/&quot;),c=Fl.get(e);if(c&&c.stringHash===l)return c.textureCoordinates;const u=(n[1]-n[0])/(o-1),[d,p]=[n[0]-u,n[1]+u],f=d-.5*u,g=1/(p-d+u),m=d,h=(o+1)/(p-d),v=e.getData(),T=e.getNumberOfTuples(),y=e.getNumberOfComponents(),b=t<0||t>=y,x=a[2]<=1?2:3,C=xs.newInstance({numberOfComponents:x,values:new Float32Array(T*x)}),S=C.getData(),A=[0,0,0];Nl(A,o+2,a);let I=0,w=0;const O=[.5,.5,.5];for(let e=0;e<T;++e){let e;if(b){let t=0;for(let e=0;e<y;++e){const n=Number(v[I+e]);t+=n*n}e=Math.sqrt(t)}else e=Number(v[I+t]);if(r&&(e=Math.log10(e)),I+=y,Oa(e))O[0]=A[0],O[1]=A[1],O[2]=A[2];else if(i){let t=(e-m)*h;t<1?t=0:t>o&&(t=o+1),Nl(O,t,a)}else{O[1]=.49;const t=(e-f)*g;O[0]=t>1e3?1e3:t<-1e3?-1e3:t}for(let e=0;e<x;++e)S[w++]=O[e]}return Fl.set(e,{stringHash:l,textureCoordinates:C}),C}(n,d,l,i,t.numberOfColorsInRange,t.colorTextureMap.getDimensions(),r)},e.getIsOpaque=()=>{const n=e.getInputData(),r=e.getAbstractScalars(n,t.scalarMode,t.arrayAccessMode,t.arrayId,t.colorByArrayName).scalars;if(!t.scalarVisibility||null==r)return!0;const o=e.getLookupTable();return!o||(o.build(),o.areScalarsOpaque(r,t.colorMode,-1))},e.canUseTextureMapForColoring=(e,n)=>!((!n||t.colorMode===Rl.DIRECT_SCALARS)&&(!t.interpolateScalarsBeforeMapping||t.lookupTable&&t.lookupTable.getIndexedLookup()||!e||t.colorMode===Rl.DEFAULT&&e.getDataType()===Dl.UNSIGNED_CHAR||t.colorMode===Rl.DIRECT_SCALARS)),e.clearColorArrays=()=>{t.colorMapColors=null,t.colorCoordinates=null,t.colorTextureMap=null},e.getLookupTable=()=>(t.lookupTable||e.createDefaultLookupTable(),t.lookupTable),e.getMTime=()=>{let e=t.mtime;if(null!==t.lookupTable){const n=t.lookupTable.getMTime();e=n>e?n:e}return e},e.getPrimitiveCount=()=>{const t=e.getInputData();return{points:t.getPoints().getNumberOfValues()/3,verts:t.getVerts().getNumberOfValues()-t.getVerts().getNumberOfCells(),lines:t.getLines().getNumberOfValues()-2*t.getLines().getNumberOfCells(),triangles:t.getPolys().getNumberOfValues()-3*t.getPolys().getNumberOfCells()}},e.acquireInvertibleLookupTable=Ll(&quot;AcquireInvertibleLookupTable&quot;),e.valueToColor=Ll(&quot;ValueToColor&quot;),e.colorToValue=Ll(&quot;ColorToValue&quot;),e.useInvertibleColorFor=Ll(&quot;UseInvertibleColorFor&quot;),e.clearInvertibleColor=Ll(&quot;ClearInvertibleColor&quot;),e.processSelectorPixelBuffers=(e,n)=>{if(!e||!t.selectionWebGLIdsToVTKIds||!t.populateSelectionSettings)return;const r=e.getRawPixelBuffer(Al.ID_LOW24),o=e.getRawPixelBuffer(Al.ID_HIGH24),a=e.getCurrentPass(),i=e.getFieldAssociation();let s=null;i===wl.FIELD_ASSOCIATION_POINTS?s=t.selectionWebGLIdsToVTKIds.points:i===wl.FIELD_ASSOCIATION_CELLS&&(s=t.selectionWebGLIdsToVTKIds.cells),s&&n.forEach((t=>{if(a===Al.ID_LOW24){let n=0;o&&(n+=o[t],n*=256),n+=r[t+2],n*=256,n+=r[t+1],n*=256,n+=r[t];const a=s[n],i=e.getPixelBuffer(Al.ID_LOW24);i[t]=255&a,i[t+1]=(65280&a)>>8,i[t+2]=(16711680&a)>>16}else if(a===Al.ID_HIGH24&&o){let n=0;n+=o[t],n*=256,n+=r[t+2],n*=256,n+=r[t+1],n*=256,n+=r[t];const a=s[n];e.getPixelBuffer(Al.ID_HIGH24)[t]=(4278190080&a)>>24}}))}}(e,t)}var Gl={newInstance:Wt.newInstance(kl,&quot;vtkMapper&quot;),extend:kl,...Ol,...Pl,...Qs};const{isVtkObject:Ul}=Wt;function zl(e){let t=0;return e.filter(((e,n)=>n===t&&(t+=e+1,!0)))}function Wl(e){let t=0;for(let n=0;n<e.length;)n+=e[n]+1,t++;return t}const Hl={extractCellSizes:zl,getNumberOfCells:Wl};function jl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};xs.extend(e,t,function(e){return{empty:!0,numberOfComponents:1,dataType:cs.UNSIGNED_INT,...e}}(n)),function(e,t){t.classHierarchy.push(&quot;vtkCellArray&quot;);const n={...e};e.getNumberOfCells=n=>void 0===t.numberOfCells||n?(t.cellSizes?t.numberOfCells=t.cellSizes.length:t.numberOfCells=Wl(e.getData()),t.numberOfCells):t.numberOfCells,e.getCellSizes=n=>void 0===t.cellSizes||n?(t.cellSizes=zl(e.getData()),t.cellSizes):t.cellSizes,e.resize=r=>{const o=e.getNumberOfTuples();n.resize(r);const a=e.getNumberOfTuples();a<o&&(0===a?(t.numberOfCells=0,t.cellSizes=[]):(t.numberOfCells=void 0,t.cellSizes=void 0))},e.setData=e=>{n.setData(e,1),t.numberOfCells=void 0,t.cellSizes=void 0},e.getCell=e=>{let n=e;const r=t.values[n++];return t.values.subarray(n,n+r)},e.insertNextCell=n=>{let r;r=Ul(n)?n.getPointsIds():n;const o=e.getNumberOfCells();return e.insertNextTuples([r.length,...r]),++t.numberOfCells,null!=t.cellSizes&&t.cellSizes.push(r.length),o},e.getMaxCellSize=()=>e.getCellSizes().reduce(((e,t)=>Math.max(e,t)),0)}(e,t)}var Kl={newInstance:Wt.newInstance(jl,&quot;vtkCellArray&quot;),extend:jl,...Hl};const{vtkErrorMacro:$l}=Wt,ql={empty:!0,numberOfComponents:3,dataType:cs.FLOAT,bounds:[1,-1,1,-1,1,-1]};function Xl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ql,n),xs.extend(e,t,n),Wt.getArray(e,t,[&quot;bounds&quot;],6),function(e,t){let n=0;t.classHierarchy.push(&quot;vtkPoints&quot;),e.getNumberOfPoints=e.getNumberOfTuples,e.setNumberOfPoints=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:3;e.getNumberOfPoints()!==n&&(t.size=n*r,t.values=Wt.newTypedArray(t.dataType,t.size),e.setNumberOfComponents(r),e.modified())},e.setPoint=function(t){for(var n=arguments.length,r=new Array(n>1?n-1:0),o=1;o<n;o++)r[o-1]=arguments[o];e.setTuple(t,r)},e.getPoint=e.getTuple,e.findPoint=e.findTuple,e.insertNextPoint=(t,n,r)=>e.insertNextTuple([t,n,r]),e.insertPoint=(t,n)=>e.insertTuple(t,n);const r=e.getBounds;e.getBounds=()=>(n<t.mtime&&e.computeBounds(),r());const o=e.getBoundsByReference;e.getBoundsByReference=()=>(n<t.mtime&&e.computeBounds(),o()),e.computeBounds=()=>{if(3===e.getNumberOfComponents()){const n=e.getRange(0);t.bounds[0]=n[0],t.bounds[1]=n[1];const r=e.getRange(1);t.bounds[2]=r[0],t.bounds[3]=r[1];const o=e.getRange(2);t.bounds[4]=o[0],t.bounds[5]=o[1]}else if(2===e.getNumberOfComponents()){const n=e.getRange(0);t.bounds[0]=n[0],t.bounds[1]=n[1];const r=e.getRange(1);t.bounds[2]=r[0],t.bounds[3]=r[1],t.bounds[4]=0,t.bounds[5]=0}else $l(`getBounds called on an array with components of ${e.getNumberOfComponents()}`),Ta(t.bounds);n=Wt.getCurrentGlobalMTime()},e.setNumberOfComponents(t.numberOfComponents<2?3:t.numberOfComponents)}(e,t)}var Yl={newInstance:Wt.newInstance(Xl,&quot;vtkPoints&quot;),extend:Xl};const Zl={bounds:[-1,-1,-1,-1,-1,-1],pointsIds:[]};function Ql(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Zl,n),Wt.obj(e,t),t.points||(t.points=Yl.newInstance()),Wt.get(e,t,[&quot;points&quot;,&quot;pointsIds&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkCell&quot;),e.initialize=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(n){t.pointsIds=n;let r=t.points.getData();r.length!==3*t.pointsIds.length&&(r=Wt.newTypedArray(e.getDataType(),3*t.pointsIds.length));const o=e.getData();t.pointsIds.forEach(((e,t)=>{let n=3*e,a=3*t;r[a]=o[n],r[++a]=o[++n],r[++a]=o[++n]})),t.points.setData(r)}else{t.points=e,t.pointsIds=new Array(e.getNumberOfPoints());for(let n=e.getNumberOfPoints()-1;n>=0;--n)t.pointsIds[n]=n}},e.getBounds=()=>t.points.getBounds(),e.getLength2=()=>{const t=Gi.getLengths(e.getBounds());return t[0]*t[0]+t[1]*t[1]+t[2]*t[2]},e.getParametricDistance=e=>{let t,n=0;for(let r=0;r<3;r++)t=e[r]<0?-e[r]:e[r]>1?e[r]-1:0,t>n&&(n=t);return n},e.getNumberOfPoints=()=>t.points.getNumberOfPoints(),e.deepCopy=e=>{e.initialize(t.points,t.pointsIds)},e.getCellDimension=()=>{},e.intersectWithLine=(e,t,n,r,o,a,i)=>{},e.evaluatePosition=(e,t,n,r,o,a)=>{Wt.vtkErrorMacro(&quot;vtkCell.evaluatePosition is not implemented.&quot;)}}(e,t)}var Jl={newInstance:Wt.newInstance(Ql,&quot;vtkCell&quot;),extend:Ql};const ec={array:null,maxId:0,extend:0};function tc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ec,n),Wt.obj(e,t),function(e,t){t.classHierarchy.push(&quot;vtkCellLinks&quot;),e.buildLinks=n=>{const r=n.getPoints().getNumberOfPoints(),o=n.getNumberOfCells(),a=new Uint32Array(r);if(n.isA(&quot;vtkPolyData&quot;)){for(let t=0;t<o;++t){const{cellPointIds:r}=n.getCellPoints(t);r.forEach((t=>{e.incrementLinkCount(t)}))}e.allocateLinks(r),t.maxId=r-1;for(let t=0;t<o;++t){const{cellPointIds:r}=n.getCellPoints(t);r.forEach((n=>{e.insertCellReference(n,a[n]++,t)}))}}else{for(let t=0;t<o;t++)Jl.newInstance().getPointsIds().forEach((t=>{e.incrementLinkCount(t)}));e.allocateLinks(r),t.maxId=r-1;for(let t=0;t<o;++t)Jl.newInstance().getPointsIds().forEach((n=>{e.insertCellReference(n,a[n]++,t)}))}},e.allocate=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1e3;t.array=Array(e).fill().map((()=>({ncells:0,cells:null}))),t.extend=n,t.maxId=-1},e.initialize=()=>{t.array=null},e.getLink=e=>t.array[e],e.getNcells=e=>t.array[e].ncells,e.getCells=e=>t.array[e].cells,e.insertNextPoint=e=>{t.array.push({ncells:e,cells:Array(e)}),++t.maxId},e.insertNextCellReference=(e,n)=>{t.array[e].cells[t.array[e].ncells++]=n},e.deletePoint=e=>{t.array[e].ncells=0,t.array[e].cells=null},e.removeCellReference=(e,n)=>{t.array[n].cells=t.array[n].cells.filter((t=>t!==e)),t.array[n].ncells=t.array[n].cells.length},e.addCellReference=(e,n)=>{t.array[n].cells[t.array[n].ncells++]=e},e.resizeCellList=(e,n)=>{t.array[e].cells.length=n},e.squeeze=()=>{!function(e,t){let n=t;for(t>=e.array.length&&(n+=e.array.length);n>e.array.length;)e.array.push({ncells:0,cells:null});e.array.length=n}(t,t.maxId+1)},e.reset=()=>{t.maxId=-1},e.deepCopy=e=>{t.array=[...e.array],t.extend=e.extend,t.maxId=e.maxId},e.incrementLinkCount=e=>{++t.array[e].ncells},e.allocateLinks=e=>{for(let n=0;n<e;++n)t.array[n].cells=new Array(t.array[n].ncells)},e.insertCellReference=(e,n,r)=>{t.array[e].cells[n]=r}}(e,t)}var nc={newInstance:Wt.newInstance(tc,&quot;vtkCellLinks&quot;),extend:tc};const rc=0,oc=1,ac=2,ic=3,sc=4,lc=5,cc=6,uc=7,dc=9,pc=21,fc=41,gc=42,mc=[&quot;vtkEmptyCell&quot;,&quot;vtkVertex&quot;,&quot;vtkPolyVertex&quot;,&quot;vtkLine&quot;,&quot;vtkPolyLine&quot;,&quot;vtkTriangle&quot;,&quot;vtkTriangleStrip&quot;,&quot;vtkPolygon&quot;,&quot;vtkPixel&quot;,&quot;vtkQuad&quot;,&quot;vtkTetra&quot;,&quot;vtkVoxel&quot;,&quot;vtkHexahedron&quot;,&quot;vtkWedge&quot;,&quot;vtkPyramid&quot;,&quot;vtkPentagonalPrism&quot;,&quot;vtkHexagonalPrism&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;vtkQuadraticEdge&quot;,&quot;vtkQuadraticTriangle&quot;,&quot;vtkQuadraticQuad&quot;,&quot;vtkQuadraticTetra&quot;,&quot;vtkQuadraticHexahedron&quot;,&quot;vtkQuadraticWedge&quot;,&quot;vtkQuadraticPyramid&quot;,&quot;vtkBiQuadraticQuad&quot;,&quot;vtkTriQuadraticHexahedron&quot;,&quot;vtkQuadraticLinearQuad&quot;,&quot;vtkQuadraticLinearWedge&quot;,&quot;vtkBiQuadraticQuadraticWedge&quot;,&quot;vtkBiQuadraticQuadraticHexahedron&quot;,&quot;vtkBiQuadraticTriangle&quot;,&quot;vtkCubicLine&quot;,&quot;vtkQuadraticPolygon&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;vtkConvexPointSet&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;vtkParametricCurve&quot;,&quot;vtkParametricSurface&quot;,&quot;vtkParametricTriSurface&quot;,&quot;vtkParametricQuadSurface&quot;,&quot;vtkParametricTetraRegion&quot;,&quot;vtkParametricHexRegion&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;vtkHigherOrderEdge&quot;,&quot;vtkHigherOrderTriangle&quot;,&quot;vtkHigherOrderQuad&quot;,&quot;vtkHigherOrderPolygon&quot;,&quot;vtkHigherOrderTetrahedron&quot;,&quot;vtkHigherOrderWedge&quot;,&quot;vtkHigherOrderPyramid&quot;,&quot;vtkHigherOrderHexahedron&quot;],hc={getClassNameFromTypeId:function(e){return e<mc.length?mc[e]:&quot;UnknownClass&quot;},getTypeIdFromClassName:function(e){return mc.findIndex(e)},isLinear:function(e){return e<pc||e===fc||e===gc},hasSubCells:function(e){return e===cc||e===sc||e===ac}},vc={size:0,maxId:-1,extend:1e3};function Tc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,vc,n),Wt.obj(e,t),Wt.get(e,t,[&quot;size&quot;,&quot;maxId&quot;,&quot;extend&quot;]),Wt.getArray(e,t,[&quot;typeArray&quot;,&quot;locationArray&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkCellTypes&quot;),e.allocate=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:512,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1e3;t.size=e>0?e:1,t.extend=n>0?n:1,t.maxId=-1,t.typeArray=new Uint8Array(e),t.locationArray=new Uint32Array(e)},e.insertCell=(e,n,r)=>{t.typeArray[e]=n,t.locationArray[e]=r,e>t.maxId&&(t.maxId=e)},e.insertNextCell=(n,r)=>(e.insertCell(++t.maxId,n,r),t.maxId),e.setCellTypes=(e,n,r)=>{t.size=e,t.typeArray=n,t.locationArray=r,t.maxId=e-1},e.getCellLocation=e=>t.locationArray[e],e.deleteCell=e=>{t.typeArray[e]=rc},e.getNumberOfTypes=()=>t.maxId+1,e.isType=t=>{const n=e.getNumberOfTypes();for(let r=0;r<n;++r)if(t===e.getCellType(r))return!0;return!1},e.insertNextType=t=>e.insertNextCell(t,-1),e.getCellType=e=>t.typeArray[e],e.reset=()=>{t.maxId=-1},e.deepCopy=n=>{e.allocate(n.getSize(),n.getExtend()),t.typeArray.set(n.getTypeArray()),t.locationArray.set(n.getLocationArray()),t.maxId=n.getMaxId()}}(e,t)}var yc={newInstance:Wt.newInstance(Tc,&quot;vtkCellTypes&quot;),extend:Tc,...hc};const bc={NO_INTERSECTION:0,YES_INTERSECTION:1,ON_LINE:2};var xc={IntersectionState:bc};const{IntersectionState:Cc}=xc;function Sc(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:null;const o={t:Number.MIN_VALUE,distance:0},a=[];let i;a[0]=n[0]-t[0],a[1]=n[1]-t[1],a[2]=n[2]-t[2];const s=a[0]*(e[0]-t[0])+a[1]*(e[1]-t[1])+a[2]*(e[2]-t[2]),l=Lo(a,a);let c=1e-5*s;return 0!==l&&(o.t=s/l),c<0&&(c=-c),-c<l&&l<c||l<=0||o.t<0?i=t:o.t>1?i=n:(i=a,a[0]=t[0]+o.t*a[0],a[1]=t[1]+o.t*a[1],a[2]=t[2]+o.t*a[2]),r&&(r[0]=i[0],r[1]=i[1],r[2]=i[2]),o.distance=Go(i,e),o}function Ac(e,t,n,r,o,a){const i=[],s=[],l=[];o[0]=0,a[0]=0,Mo(t,e,i),Mo(r,n,s),Mo(n,e,l);const c=[Lo(i,i),-Lo(i,s),-Lo(i,s),Lo(s,s)],u=[];if(u[0]=Lo(i,l),u[1]=-Lo(s,l),0===sa(c,u,2)){let i=Number.MAX_VALUE;const s=[e,t,n,r],l=[n,n,e,e],c=[r,r,t,t];let u;a[0],a[0],o[0],o[0],o[0],o[0],a[0],a[0];for(let e=0;e<4;e++)u=Sc(s[e],l[e],c[e]),u.distance<i&&(i=u.distance,u.t);return Cc.ON_LINE}return o[0]=u[0],a[0]=u[1],o[0]>=0&&o[0]<=1&&a[0]>=0&&a[0]<=1?Cc.YES_INTERSECTION:Cc.NO_INTERSECTION}const Ic={distanceToLine:Sc,intersection:Ac},wc={orientations:null};function Oc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,wc,n),Jl.extend(e,t,n),Wt.setGet(e,t,[&quot;orientations&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkLine&quot;),e.getCellDimension=()=>1,e.intersectWithLine=(e,n,r,o,a)=>{const i={intersect:0,t:Number.MAX_VALUE,subId:0,betweenPoints:null};a[1]=0,a[2]=0;const s=[],l=[],c=[];t.points.getPoint(0,l),t.points.getPoint(1,c);const u=[],d=[],p=Ac(e,n,l,c,u,d);var f;if(i.t=u[0],i.betweenPoints=(f=i.t)>=0&&f<=1,a[0]=d[0],p===Cc.YES_INTERSECTION){for(let t=0;t<3;t++)o[t]=l[t]+a[0]*(c[t]-l[t]),s[t]=e[t]+i.t*(n[t]-e[t]);if(Go(o,s)<=r*r)return i.intersect=1,i}else{let t;if(i.t<0)return t=Sc(e,l,c,o),t.distance<=r*r?(i.t=0,i.intersect=1,i.betweenPoints=!0,i):i;if(i.t>1)return t=Sc(n,l,c,o),t.distance<=r*r?(i.t=1,i.intersect=1,i.betweenPoints=!0,i):i;if(a[0]<0)return a[0]=0,t=Sc(l,e,n,o),i.t=t.t,t.distance<=r*r?(i.intersect=1,i):i;if(a[0]>1)return a[0]=1,t=Sc(c,e,n,o),i.t=t.t,t.distance<=r*r?(i.intersect=1,i):i}return i},e.evaluateLocation=(e,n,r)=>{const o=[],a=[];t.points.getPoint(0,o),t.points.getPoint(1,a);for(let t=0;t<3;t++)n[t]=o[t]+e[0]*(a[t]-o[t]);r[0]=1-e[0],r[1]=e[0]},e.evaluateOrientation=(e,n,r)=>!!t.orientations&&(function(e,t,n,r){var o,a,s,l,c,u=t[0],d=t[1],p=t[2],f=t[3],g=n[0],m=n[1],h=n[2],v=n[3];(a=u*g+d*m+p*h+f*v)<0&&(a=-a,g=-g,m=-m,h=-h,v=-v),1-a>i?(o=Math.acos(a),s=Math.sin(o),l=Math.sin((1-r)*o)/s,c=Math.sin(r*o)/s):(l=1-r,c=r),e[0]=l*u+c*g,e[1]=l*d+c*m,e[2]=l*p+c*h,e[3]=l*f+c*v}(n,t.orientations[0],t.orientations[1],e[0]),r[0]=1-e[0],r[1]=e[0],!0)}(e,t)}var Pc={newInstance:Wt.newInstance(Oc,&quot;vtkLine&quot;),extend:Oc,...Ic,...xc};const Rc={};function Mc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Rc,n),Us.extend(e,t,n),Wt.setGet(e,t,[&quot;points&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkPointSet&quot;),t.points?t.points=ze(t.points):t.points=Yl.newInstance(),e.getNumberOfPoints=()=>t.points.getNumberOfPoints(),e.getBounds=()=>t.points.getBounds(),e.computeBounds=()=>{e.getBounds()};const n=e.shallowCopy;e.shallowCopy=function(e){n(e,arguments.length>1&&void 0!==arguments[1]&&arguments[1]),t.points=Yl.newInstance(),t.points.shallowCopy(e.getPoints())};const r=e.getMTime;e.getMTime=()=>{const e=r();return Math.max(e,t.points?.getMTime()??e)};const o=e.initialize;e.initialize=()=>(t.points?.initialize(),o())}(e,t)}var Ec={newInstance:Wt.newInstance(Mc,&quot;vtkPointSet&quot;),extend:Mc};const Vc={orientations:null,distanceFunction:function(e,t){var n=t[0]-e[0],r=t[1]-e[1],o=t[2]-e[2];return Math.hypot(n,r,o)}};function Dc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Vc,n),Jl.extend(e,t,n),Wt.setGet(e,t,[&quot;orientations&quot;,&quot;distanceFunction&quot;]),t.distancesTime={},Wt.obj(t.distancesTime,{mtime:0}),function(e,t){t.classHierarchy.push(&quot;vtkPolyLine&quot;);const n=Pc.newInstance();n.getPoints().setNumberOfPoints(2),e.getCellDimension=()=>1,e.intersectWithLine=(r,o,a,i,s,l,c)=>{const u={intersect:0,t:Number.MAX_VALUE,subId:0,betweenPoints:null},d=e.getNumberOfPoints()-1;let p=Number.MAX_VALUE;for(let e=0;e<d;e++){const d=[0,0,0];n.getPoints().getData().set(t.points.getData().subarray(3*e,3*(e+2)));const f=n.intersectWithLine(a,i,s,l,c);if(1===f.intersect&&f.t<=u.t+s&&f.t>=r&&f.t<=o){u.intersect=1;const t=n.getParametricDistance(d);if(t<p||t===p&&f.t<u.t){u.subId=e,u.t=f.t,p=t;for(let e=0;e<3;e++)l[e],d[e]}}}return u},e.evaluateLocation=(e,r,o,a)=>(n.getPoints().getData().set(t.points.getData().subarray(3*e,3*(e+2))),n.evaluateLocation(r,o,a)),e.evaluateOrientation=(e,r,o,a)=>(t.orientations?n.setOrientations([t.orientations[e],t.orientations[e+1]]):n.setOrientations(null),n.evaluateOrientation(r,o,a)),e.getDistancesToFirstPoint=()=>{const n=t.distancesTime.getMTime();if(n<t.points.getMTime()||n<e.getMTime()){const n=e.getNumberOfPoints();if(t.distances?t.distances.length=n:t.distances=new Array(n),n>0){const e=new Array(3),a=new Array(3);let i=0;t.distances[0]=i,t.points.getPoint(0,e);for(let s=1;s<n;++s)t.points.getPoint(s,a),i+=t.distanceFunction(e,a),t.distances[s]=i,o=a,(r=e)[0]=o[0],r[1]=o[1],r[2]=o[2]}t.distancesTime.modified()}var r,o;return t.distances},e.findPointIdAtDistanceFromFirstPoint=t=>{const n=e.getDistancesToFirstPoint();if(n.length<2)return-1;let r=0,o=n.length-1;if(t<n[r]||t>n[o]||0===n[o])return-1;for(;o-r>1;){const e=Math.floor((r+o)/2);n[e]<=t?r=e:o=e}return r}}(e,t)}var Lc={newInstance:Wt.newInstance(Dc,&quot;vtkPolyLine&quot;),extend:Dc};const Bc={elements:[]};function Nc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Bc,n),Wt.obj(e,t),function(e,t){t.classHierarchy.push(&quot;vtkPriorityQueue&quot;),e.push=(e,n)=>{const r=t.elements.findIndex((t=>t.priority>e));t.elements.splice(r,0,{priority:e,element:n})},e.pop=()=>t.elements.length>0?t.elements.shift().element:null,e.deleteById=e=>{t.elements=t.elements.filter((t=>{let{element:n}=t;return n.id!==e}))},e.length=()=>t.elements.length}(e,t)}var Fc={newInstance:Wt.newInstance(Nc,&quot;vtkPriorityQueue&quot;),extend:Nc};const _c=1e-6,kc=1.1920929e-7,Gc={FAILURE:-1,OUTSIDE:0,INSIDE:1,INTERSECTION:2,ON_LINE:3};function Uc(e,t,n,r,o){return(r[e]-n[e])*(o[t]-n[t])-(o[e]-n[e])*(r[t]-n[t])}const zc={PolygonWithPointIntersectionState:Gc,pointInPolygon:function(e,t,n,r){if(e[0]<n[0]||e[0]>n[1]||e[1]<n[2]||e[1]>n[3]||e[2]<n[4]||e[2]>n[5])return Gc.OUTSIDE;if(Fo(r)<=kc)return Gc.FAILURE;let o=1e-8*((n[1]-n[0])*(n[1]-n[0])+(n[3]-n[2])*(n[3]-n[2])+(n[5]-n[4])*(n[5]-n[4]));o*=o,o=0===o?kc:o;const a=[],i=[];for(let n=0;n<t.length;){if(a[0]=t[n++],a[1]=t[n++],a[2]=t[n++],Go(e,a)<=o)return Gc.INSIDE;const{distance:r,t:s}=Pc.distanceToLine(e,a,i);if(r<=o&&s>0&&s<1)return Gc.INSIDE}let s,l;Math.abs(r[0])>Math.abs(r[1])?Math.abs(r[0])>Math.abs(r[2])?(s=1,l=2):(s=0,l=1):Math.abs(r[1])>Math.abs(r[2])?(s=0,l=2):(s=0,l=1);let c=0;for(let n=0;n<t.length;)a[0]=t[n++],a[1]=t[n++],a[2]=t[n++],n<t.length?(i[0]=t[n],i[1]=t[n+1],i[2]=t[n+2]):(i[0]=t[0],i[1]=t[1],i[2]=t[2]),a[l]<=e[l]?i[l]>e[l]&&Uc(s,l,a,i,e)>0&&++c:i[l]<=e[l]&&Uc(s,l,a,i,e)<0&&--c;return 0===c?Gc.OUTSIDE:Gc.INSIDE},getBounds:function(e,t,n){const r=e.length,o=[];t.getPoint(e[0],o),n[0]=o[0],n[1]=o[0],n[2]=o[1],n[3]=o[1],n[4]=o[2],n[5]=o[2];for(let a=1;a<r;a++)t.getPoint(e[a],o),Gi.addPoint(n,...o);const a=Gi.getLengths(n);return Lo(a,a)},getNormal:function(e,t,n){n.length=3,n[0]=0,n[1]=0,n[2]=0;const r=[];let o=[],a=[];const i=[],s=[];t.getPoint(e[0],r),t.getPoint(e[1],o);for(let l=2;l<e.length;l++){t.getPoint(e[l],a),Mo(a,o,i),Mo(r,o,s);const c=[0,0,0];Bo(i,s,c),Ro(n,c,n),[o,a]=[a,o]}return Fo(n)},computeCentroid:function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[0,0,0];n[0]=0,n[1]=0,n[2]=0;const r=e.length,o=[];for(let a=0;a<r;a++)t.getPoint(e[a],o),n[0]+=o[0],n[1]+=o[1],n[2]+=o[2];return n[0]/=r,n[1]/=r,n[2]/=r,n}};function Wc(e,t){function n(e){const n=[0,0,0],r=[0,0,0],o=[0,0,0],a=[0,0,0];Mo(e.point,e.previous.point,n),Mo(e.next.point,e.point,r),Mo(e.previous.point,e.next.point,o),Bo(n,r,a);const i=Lo(a,t.normal);if(i<=0)return-1;const s=No(n)+No(r)+No(o);return s*s/i}function r(e){if(t.pointCount<=3)return!0;const n=e.previous,r=e.next,o=[0,0,0];Mo(r.point,n.point,o);const a=[0,0,0];if(Bo(o,t.normal,a),Fo(a),0===No(a))return!1;let i=ei.evaluate(a,n.point,r.next.point),s=i>_c?1:i<-1e-6?-1:0,l=s<0?1:0;for(let e=r.next.next;e.id!==n.id;e=e.next){const t=e.previous;i=ei.evaluate(a,n.point,e.point);const o=i>_c?1:i<-1e-6?-1:0;if(o!==s){if(l||(l=o<=0?1:0),Pc.intersection(n.point,r.point,e.point,t.point,[0],[0])===bc.YES_INTERSECTION)return!1;s=o}}return 1===l}function o(e,r){t.pointCount-=1;const o=e.previous,a=e.next;t.tris=t.tris.concat(e.point),t.tris=t.tris.concat(a.point),t.tris=t.tris.concat(o.point),o.next=a,a.previous=o,r.deleteById(o.id),r.deleteById(a.id);const i=n(o);i>0&&r.push(i,o);const s=n(a);s>0&&r.push(s,a),e.id===t.firstPoint.id&&(t.firstPoint=a)}t.classHierarchy.push(&quot;vtkPolygon&quot;),e.triangulate=()=>t.firstPoint?function(){!function(){const e=[0,0,0],n=[0,0,0];t.normal=[0,0,0];const r=[...t.firstPoint.point];let o=t.firstPoint;for(let a=0;a<t.pointCount;a++){Mo(o.point,r,e),Mo(o.next.point,r,n);const a=[0,0,0];Bo(e,n,a),Ro(t.normal,a,t.normal),o=o.next}Fo(t.normal)}();const e=Fc.newInstance();let a=t.firstPoint;for(let r=0;r<t.pointCount;r++){const t=n(a);t>0&&e.push(t,a),a=a.next}for(;t.pointCount>2&&e.length()>0;)if(t.pointCount===e.length())o(e.pop(),e);else{const t=e.pop();r(t)&&o(t,e)}return t.pointCount<=2}():null,e.setPoints=e=>{t.pointCount=e.length,t.firstPoint={id:0,point:e[0],next:null,previous:null};let n=t.firstPoint;for(let r=1;r<t.pointCount;r++)n.next={id:r,point:e[r],next:null,previous:n},n=n.next;t.firstPoint.previous=n,n.next=t.firstPoint},e.getPointArray=()=>t.tris}const Hc={firstPoint:null,pointCount:0,tris:[]};function jc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Hc,n),Wt.obj(e,t),Wc(e,t)}var Kc={newInstance:Wt.newInstance(jc,&quot;vtkPolygon&quot;),extend:jc,...zc};function $c(e,t,n,r){const o=n[0]-t[0],a=n[1]-t[1],i=n[2]-t[2],s=e[0]-t[0],l=e[1]-t[1],c=e[2]-t[2];r[0]=a*c-i*l,r[1]=i*s-o*c,r[2]=o*l-a*s}function qc(e,t,n,r){$c(e,t,n,r);const o=Math.sqrt(r[0]*r[0]+r[1]*r[1]+r[2]*r[2]);0!==o&&(r[0]/=o,r[1]/=o,r[2]/=o)}function Xc(e){e[0]=-1,e[1]=1,e[2]=0,e[3]=-1,e[4]=0,e[5]=1}const Yc={computeNormalDirection:$c,computeNormal:qc,interpolationDerivs:Xc,intersectWithTriangle:function(e,t,n,r,o,a){let i=arguments.length>6&&void 0!==arguments[6]?arguments[6]:1e-6,s=!1;const l=[],c=[],u=[],d=[],p=[];qc(e,t,n,d),qc(r,o,a,p);const f=-Lo(d,e),g=-Lo(p,r),m=[Lo(p,e)+g,Lo(p,t)+g,Lo(p,n)+g];if(m[0]*m[1]>i&&m[0]*m[2]>i)return{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};const h=[Lo(d,r)+f,Lo(d,o)+f,Lo(d,a)+f];if(h[0]*h[1]>i&&h[0]*h[2]>i)return{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};if(Math.abs(d[0]-p[0])<1e-9&&Math.abs(d[1]-p[1])<1e-9&&Math.abs(d[2]-p[2])<1e-9&&Math.abs(f-g)<1e-9)return s=!0,{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};const v=[e,t,n],T=[r,o,a],y=Lo(d,p),b=(f-g*y)/(y*y-1),x=(g-f*y)/(y*y-1),C=[b*d[0]+x*p[0],b*d[1]+x*p[1],b*d[2]+x*p[2]],S=Bo(d,p,[]);Fo(S);let A=0,I=0;const w=[],O=[];let P,R,M=50,E=50;for(let t=0;t<3;t++){const n=t,o=(t+1)%3,a=ei.intersectWithLine(v[n],v[o],r,p);a.intersection&&a.t>0-i&&a.t<1+i&&(a.t<1+i&&a.t>1-i&&(M=A),w[A++]=Lo(a.x,S)-Lo(C,S));const s=ei.intersectWithLine(T[n],T[o],e,d);s.intersection&&s.t>0-i&&s.t<1+i&&(s.t<1+i&&s.t>1-i&&(E=I),O[I++]=Lo(s.x,S)-Lo(C,S))}if(A>2){A--;const e=w[2];w[2]=w[M],w[M]=e}if(I>2){I--;const e=O[2];O[2]=O[E],O[E]=e}if(2!==A||2!==I)return{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};if(Number.isNaN(w[0])||Number.isNaN(w[1])||Number.isNaN(O[0])||Number.isNaN(O[1]))return{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};if(w[0]>w[1]){const e=w[1];w[1]=w[0],w[0]=e}if(O[0]>O[1]){const e=O[1];O[1]=O[0],O[0]=e}return w[1]<O[0]||O[1]<w[0]?{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u}:(w[0]<O[0]?w[1]<O[1]?(u[0]=2,u[1]=1,P=O[0],R=w[1]):(u[0]=2,u[1]=2,P=O[0],R=O[1]):w[1]<O[1]?(u[0]=1,u[1]=1,P=w[0],R=w[1]):(u[0]=1,u[1]=2,P=w[0],R=O[1]),Do(C,S,P,l),Do(C,S,R,c),{intersect:!0,coplanar:s,pt1:l,pt2:c,surfaceId:u})}},Zc={};function Qc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Zc,n),Jl.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkTriangle&quot;),e.getCellDimension=()=>2,e.intersectWithLine=(n,r,o,a,i)=>{const s={subId:0,t:Number.MAX_VALUE,intersect:0,betweenPoints:!1};i[2]=0;const l=[],c=o*o,u=[],d=[],p=[];t.points.getPoint(0,u),t.points.getPoint(1,d),t.points.getPoint(2,p);const f=[],g=[];if(qc(u,d,p,f),0!==f[0]||0!==f[1]||0!==f[2]){const t=ei.intersectWithLine(n,r,u,f);if(s.betweenPoints=t.betweenPoints,s.t=t.t,a[0]=t.x[0],a[1]=t.x[1],a[2]=t.x[2],!t.intersection)return i[0]=0,i[1]=0,s.intersect=0,s;const o=e.evaluatePosition(a,l,i,g);if(o.evaluation>=0)return o.dist2<=c?(s.intersect=1,s):(s.intersect=o.evaluation,s)}const m=Go(u,d),h=Go(d,p),v=Go(p,u);t.line||(t.line=Pc.newInstance()),m>h&&m>v?(t.line.getPoints().setPoint(0,u),t.line.getPoints().setPoint(1,d)):h>v&&h>m?(t.line.getPoints().setPoint(0,d),t.line.getPoints().setPoint(1,p)):(t.line.getPoints().setPoint(0,p),t.line.getPoints().setPoint(1,u));const T=t.line.intersectWithLine(n,r,o,a,i);if(s.betweenPoints=T.betweenPoints,s.t=T.t,T.intersect){const e=[],t=[],n=[];for(let r=0;r<3;r++)e[r]=u[r]-p[r],t[r]=d[r]-p[r],n[r]=a[r]-p[r];return i[0]=Lo(n,e)/v,i[1]=Lo(n,t)/h,s.intersect=1,s}return i[0]=0,i[1]=0,s.intersect=0,s},e.evaluatePosition=(e,n,r,o)=>{const a={subId:0,dist2:0,evaluation:-1};let i,s;const l=[],c=[],u=[],d=[];let p;const f=[],g=[],m=[];let h=0,v=0;const T=[];let y,b,x,C=[];const S=[],A=[],I=[];a.subId=0,r[2]=0,t.points.getPoint(1,l),t.points.getPoint(2,c),t.points.getPoint(0,u),$c(l,c,u,d),ei.generalizedProjectPoint(e,l,d,I);let w=0;for(i=0;i<3;i++)p=d[i]<0?-d[i]:d[i],p>w&&(w=p,v=i);for(s=0,i=0;i<3;i++)i!==v&&(T[s++]=i);for(i=0;i<2;i++)f[i]=I[T[i]]-u[T[i]],g[i]=l[T[i]]-u[T[i]],m[i]=c[T[i]]-u[T[i]];if(h=Wo(g,m),0===h)return r[0]=0,r[1]=0,a.evaluation=-1,a;if(r[0]=Wo(f,m)/h,r[1]=Wo(g,f)/h,o[0]=1-(r[0]+r[1]),o[1]=r[0],o[2]=r[1],o[0]>=0&&o[0]<=1&&o[1]>=0&&o[1]<=1&&o[2]>=0&&o[2]<=1)n&&(a.dist2=Go(I,e),n[0]=I[0],n[1]=I[1],n[2]=I[2]),a.evaluation=1;else{let t;if(n)if(o[1]<0&&o[2]<0)for(y=Go(e,u),b=Pc.distanceToLine(e,l,u,t,S),x=Pc.distanceToLine(e,u,c,t,A),y<b?(a.dist2=y,C=u):(a.dist2=b,C=S),x<a.dist2&&(a.dist2=x,C=A),i=0;i<3;i++)n[i]=C[i];else if(o[2]<0&&o[0]<0)for(y=Go(e,l),b=Pc.distanceToLine(e,l,u,t,S),x=Pc.distanceToLine(e,l,c,t,A),y<b?(a.dist2=y,C=l):(a.dist2=b,C=S),x<a.dist2&&(a.dist2=x,C=A),i=0;i<3;i++)n[i]=C[i];else if(o[1]<0&&o[0]<0)for(y=Go(e,c),b=Pc.distanceToLine(e,c,u,t,S),x=Pc.distanceToLine(e,l,c,t,A),y<b?(a.dist2=y,C=c):(a.dist2=b,C=S),x<a.dist2&&(a.dist2=x,C=A),i=0;i<3;i++)n[i]=C[i];else if(o[0]<0){const t=Pc.distanceToLine(e,l,c,n);a.dist2=t.distance}else if(o[1]<0){const t=Pc.distanceToLine(e,c,u,n);a.dist2=t.distance}else if(o[2]<0){const t=Pc.distanceToLine(e,l,u,n);a.dist2=t.distance}a.evaluation=0}return a},e.evaluateLocation=(e,n,r)=>{const o=[],a=[],i=[];t.points.getPoint(0,o),t.points.getPoint(1,a),t.points.getPoint(2,i);const s=1-e[0]-e[1];for(let t=0;t<3;t++)n[t]=o[t]*s+a[t]*e[0]+i[t]*e[1];r[0]=s,r[1]=e[0],r[2]=e[1]},e.getParametricDistance=e=>{let t,n=0;const r=[];r[0]=e[0],r[1]=e[1],r[2]=1-e[0]-e[1];for(let e=0;e<3;e++)t=r[e]<0?-r[e]:r[e]>1?r[e]-1:0,t>n&&(n=t);return n},e.derivatives=(e,n,r,o,a)=>{const i=t.points.getPoint(0),s=t.points.getPoint(1),l=t.points.getPoint(2),c=[],u=[],d=[],p=[];qc(i,s,l,c),Mo(s,i,u),Mo(l,i,p),Bo(c,u,d);const f=Fo(u);if(f<=0||Fo(d)<=0){for(let e=0;e<o;e++)for(let t=0;t<3;t++)a[e*o+t]=0;return}const g=[0,0],m=[f,0],h=[Lo(p,u),Lo(p,d)],v=new Array(6);Xc(v);const T=[m[0]-g[0],m[1]-g[1],h[0]-g[0],h[1]-g[1]],y=Wt.newTypedArray(ot.Float64Array,4);la(T,y,2);for(let e=0;e<o;e++){let t=0,n=0;for(let a=0;a<3;a++)t+=v[a]*r[o*a+e],n+=v[3+a]*r[o*a+e];const i=t*y[0]+n*y[1],s=t*y[2]+n*y[3];a[3*e]=i*u[0]+s*d[0],a[3*e+1]=i*u[1]+s*d[1],a[3*e+2]=i*u[2]+s*d[2]}},e.cellBoundary=(e,n,r)=>{const o=n[0]-n[1],a=.5*(1-n[0])-n[1],i=2*n[0]+n[1]-1;return o>=0&&a>=0?(r[0]=t.pointsIds[0],r[1]=t.pointsIds[1]):a<0&&i>=0?(r[0]=t.pointsIds[1],r[1]=t.pointsIds[2]):(r[0]=t.pointsIds[2],r[1]=t.pointsIds[0]),!(n[0]<0||n[1]<0||n[0]>1||n[1]>1||1-n[0]-n[1]<0)}}(e,t)}var Jc={newInstance:Wt.newInstance(Qc,&quot;vtkTriangle&quot;),extend:Qc,...Yc};const eu={};function tu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,eu,n),Jl.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkQuad&quot;),e.getCellDimension=()=>2,e.getCellType=()=>dc,e.getNumberOfEdges=()=>4,e.getNumberOfFaces=()=>0,e.intersectWithLine=(e,n,r,o,a)=>{let i,s={subId:0,t:Number.MAX_VALUE,intersect:0,betweenPoints:!1};const l=t.points.getPoint(0,[]),c=t.points.getPoint(1,[]),u=t.points.getPoint(2,[]),d=t.points.getPoint(3,[]),p=Go(l,u),f=Go(c,d);if(p===f){let e,n=0,r=0;for(let o=0;o<4;o++)e=t.pointsIds[o],e>n&&(n=e,r=o);i=0===r||2===r?0:1}else i=p<f?0:1;let g,m=null;t.triangle?m=t.triangle.getPoints():(t.triangle=Jc.newInstance(),m=Yl.newInstance(),m.setNumberOfPoints(3),t.triangle.initialize(m));const h=[0,0,0],v=[0,0,0];let T;const y=[0,0,0],b=[0,0,0];let x,C;switch(i){case 0:m.setPoint(0,...l),m.setPoint(1,...c),m.setPoint(2,...u),g=t.triangle.intersectWithLine(e,n,r,h,v),m.setPoint(0,...u),m.setPoint(1,...d),m.setPoint(2,...l),T=t.triangle.intersectWithLine(e,n,r,y,b),x=g.intersect&&T.intersect?g.t<=T.t:g.intersect,C=g.intersect&&T.intersect?T.t<g.t:T.intersect,x?(s=g,o[0]=h[0],o[1]=h[1],o[2]=h[2],a[0]=v[0]+v[1],a[1]=v[1],a[2]=v[2]):C&&(s=T,o[0]=y[0],o[1]=y[1],o[2]=y[2],a[0]=1-(b[0]+b[1]),a[1]=1-b[1],a[2]=b[2]);break;case 1:m.setPoint(0,...l),m.setPoint(1,...c),m.setPoint(2,...d),g=t.triangle.intersectWithLine(e,n,r,h,v),m.setPoint(0,...u),m.setPoint(1,...d),m.setPoint(2,...c),T=t.triangle.intersectWithLine(e,n,r,y,b),x=g.intersect&&T.intersect?g.t<=T.t:g.intersect,C=g.intersect&&T.intersect?T.t<g.t:T.intersect,x?(s=g,o[0]=h[0],o[1]=h[1],o[2]=h[2],a[0]=v[0],a[1]=v[1],a[2]=v[2]):C&&(s=T,o[0]=y[0],o[1]=y[1],o[2]=y[2],a[0]=1-b[0],a[1]=1-b[1],a[2]=b[2])}return s},e.interpolationFunctions=(e,t)=>{const n=1-e[0],r=1-e[1];t[0]=n*r,t[1]=e[0]*r,t[2]=e[0]*e[1],t[3]=n*e[1]},e.evaluateLocation=(n,r,o)=>{const a=[];e.interpolationFunctions(n,o),r[0]=0,r[1]=0,r[2]=0;for(let e=0;e<4;e++){t.points.getPoint(e,a);for(let t=0;t<3;t++)r[t]+=a[t]*o[e]}}}(e,t)}var nu={newInstance:Wt.newInstance(tu,&quot;vtkQuad&quot;),extend:tu};const{vtkErrorMacro:ru}=Wt;function ou(e){return()=>ru(`vtkTriangleStrip.${e} - NOT IMPLEMENTED`)}const au={decomposeStrip:function(e,t){if(!Array.isArray(e)||e.length<3)return void ru(&quot;decomposeStrip - Invalid points array&quot;);let n=e[0],r=e[1];for(let o=0;o<e.length-2;o++){const a=e[o+2];o%2?t.insertNextCell([r,n,a]):t.insertNextCell([n,r,a]),n=r,r=a}}},iu={line:null,triangle:null,tris:null};function su(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,iu,n),Jl.extend(e,t,n),t.line||(t.line=Pc.newInstance()),t.triangle||(t.triangle=Jc.newInstance()),function(e,t){t.classHierarchy.push(&quot;vtkTriangleStrip&quot;);const n=e.initialize;e.initialize=(e,r)=>{t.triangle.initialize(e,r),n(e,r)},e.getCellType=()=>cc,e.getCellDimension=()=>2,e.getNumberOfEdges=()=>t.pointsIds.length,e.getNumberOfFaces=()=>0,e.evaluatePosition=(e,n,r,o,a)=>{const i=[0,0,0];let s=Number.MAX_VALUE,l=0;const c=[],u=[],d=[];r[2]=0,u[0]=0,u[1]=0,u[2]=0;const p=t.triangle.getPoints();p.setNumberOfPoints(3);const f=t.triangle.getPointsIds().length;for(let e=0;e<f;e++)a[e]=0;for(let o=0;o<f-2;o++){const a=[];p.getPoint(o,a);const f=[];p.getPoint(o+1,f);const g=[];p.getPoint(o+2,g),p.setData(Float32Array.from([...a,...f,...g]),3);const m=t.triangle.evaluatePosition(e,d,i,c),h=m.dist2;m.evaluation>=0&&(h<s||h===s&&0===l)&&(l=m,n&&(n[0]=d[0],n[1]=d[1],n[2]=d[2]),r[0]=i[0],r[1]=i[1],s=h,u[0]=c[0],u[1]=c[1],u[2]=c[2])}return o[0]=s,a[0]=u[0],a[1]=u[1],a[2]=u[2],l},e.evaluateLocation=(e,n,r,o)=>{const a=[[0,1,2],[1,0,2]],i=e%2,s=t.pointsIds.length;for(let e=0;e<s;e++)o[e]=0;const l=1-n[0]-n[1];o[e]=l,o[e+1]=n[0],o[e+2]=n[1];const c=[];t.points.getPoint(e+a[i][0],c);const u=[];t.points.getPoint(e+a[i][1],u);const d=[];t.points.getPoint(e+a[i][2],d);for(let t=0;t<3;t++)r[t]=c[t]*o[e]+u[t]*o[e+1]+d[t]*o[e+2]},e.cellBoundary=(e,n,r)=>{const o=[[0,1,2],[1,0,2]],a=e%2,i=t.triangle.getPointsIds();return i[0]=t.pointsIds[o[a][0]],i[1]=t.pointsIds[o[a][1]],i[2]=t.pointsIds[o[a][2]],t.triangle.cellBoundary(0,n,r)},e.getEdge=e=>{let n,r;const o=t.pointsIds.length;return 0===e?(n=0,r=1):e===o-1?(n=e-1,r=e):(n=e-1,r=e+1),t.line.getPointsIds()[0]=t.pointsIds[n],t.line.getPointsIds()[1]=t.pointsIds[r],t.line.getPoints().setPoint(0,t.points.getPoint(n)),t.line.getPoints().setPoint(1,t.points.getPoint(r)),t.line},e.intersectWithLine=(e,n,r,o,a)=>{const i=t.pointsIds.length-2,s=t.triangle.getPoints();s.setNumberOfPoints(3);for(let l=0;l<i;l++){const i=[];t.points.getPoint(t.pointsIds[l],i);const c=[];t.points.getPoint(t.pointsIds[l+1],c);const u=[];t.points.getPoint(t.pointsIds[l+2],u),s.setData(Float32Array.from([...i,...c,...u]),3);const d=t.triangle.intersectWithLine(e,n,r,o,a);if(d.intersect)return d}return!1},e.triangulate=()=>{const e=t.points.getNumberOfPoints()-2;t.tris=new Array(3*e);const n=[[0,1,2],[1,0,2]];for(let r=0;r<e;r++){const e=r%2;for(let o=0;o<3;o++)t.tris[3*r+o]=r+n[e][o]}return!0},e.getPointArray=()=>t.tris,e.derivatives=(e,n,r,o,a)=>{const i=[];t.points.getPoint(e,i);const s=[];t.points.getPoint(e+1,s);const l=[];t.points.getPoint(e+2,l);const c=t.triangle.getPoints();c.setPoint(0,...i),c.setPoint(1,...s),c.setPoint(2,...l),t.triangle.derivatives(0,n,r,o,a)},e.getParametricCenter=e=>(e[0]=.333333,e[1]=.333333,e[2]=0,Math.floor((t.pointsIds.length-2)/2)),e.contour=(e,t,n,r,o,a,i,s,l,c,u)=>ou(&quot;contour&quot;)(),e.clip=(e,t,n,r,o,a,i,s,l,c)=>ou(&quot;clip&quot;)()}(e,t)}var lu={newInstance:Wt.newInstance(su,&quot;vtkTriangleStrip&quot;),extend:su,...au};const cu=[&quot;verts&quot;,&quot;lines&quot;,&quot;polys&quot;,&quot;strips&quot;],{vtkWarningMacro:uu}=Wt,du={[ic]:Pc,[dc]:nu,[sc]:Pc,[lc]:Jc,[cc]:lu,[sc]:Lc,[uc]:Kc},pu={};function fu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,pu,n),Ec.extend(e,t,n),Wt.get(e,t,[&quot;cells&quot;,&quot;links&quot;]),Wt.setGet(e,t,[&quot;verts&quot;,&quot;lines&quot;,&quot;polys&quot;,&quot;strips&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkPolyData&quot;),cu.forEach((n=>{e[`getNumberOf${function(e){return e.replace(/(?:^\\w|[A-Z]|\\b\\w)/g,(e=>e.toUpperCase())).replace(/\\s+/g,&quot;&quot;)}(n)}`]=()=>t[n].getNumberOfCells(),t[n]?t[n]=ze(t[n]):t[n]=Kl.newInstance()})),e.getNumberOfCells=()=>cu.reduce(((e,n)=>e+t[n].getNumberOfCells()),0);const n=e.shallowCopy;e.shallowCopy=function(e){n(e,arguments.length>1&&void 0!==arguments[1]&&arguments[1]),cu.forEach((n=>{t[n]=Kl.newInstance(),t[n].shallowCopy(e.getReferenceByName(n))}))};const r=e.getMTime;e.getMTime=()=>cu.reduce(((e,n)=>Math.max(e,t[n]?.getMTime()??e)),r());const o=e.initialize;e.initialize=()=>(cu.forEach((e=>t[e]?.initialize())),o()),e.buildCells=()=>{const n=e.getNumberOfVerts(),r=e.getNumberOfLines(),o=e.getNumberOfPolys(),a=e.getNumberOfStrips(),i=n+r+o+a,s=new Uint8Array(i);let l=s;const c=new Uint32Array(i);let u=c;if(n){let e=0;t.verts.getCellSizes().forEach(((t,n)=>{u[n]=e,l[n]=t>1?ac:oc,e+=t+1})),u=u.subarray(n),l=l.subarray(n)}if(r){let e=0;t.lines.getCellSizes().forEach(((t,n)=>{u[n]=e,l[n]=t>2?sc:ic,1===t&&uu(&quot;Building VTK_LINE &quot;,n,&quot; with only one point, but VTK_LINE needs at least two points. Check the input.&quot;),e+=t+1})),u=u.subarray(r),l=l.subarray(r)}if(o){let e=0;t.polys.getCellSizes().forEach(((t,n)=>{switch(u[n]=e,t){case 3:l[n]=lc;break;case 4:l[n]=dc;break;default:l[n]=uc}t<3&&uu(&quot;Building VTK_TRIANGLE &quot;,n,&quot; with less than three points, but VTK_TRIANGLE needs at least three points. Check the input.&quot;),e+=t+1})),u+=u.subarray(o),l+=l.subarray(o)}if(a){let e=0;l.fill(cc,0,a),t.strips.getCellSizes().forEach(((t,n)=>{u[n]=e,e+=t+1}))}t.cells=yc.newInstance(),t.cells.setCellTypes(i,s,c)},e.buildLinks=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;void 0===t.cells&&e.buildCells(),t.links=nc.newInstance(),n>0?t.links.allocate(n):t.links.allocate(e.getPoints().getNumberOfPoints()),t.links.buildLinks(e)},e.getCellType=e=>t.cells.getCellType(e),e.getCellPoints=n=>{const r=e.getCellType(n);let o=null;switch(r){case oc:case ac:o=t.verts;break;case ic:case sc:o=t.lines;break;case lc:case dc:case uc:o=t.polys;break;case cc:o=t.strips;break;default:return o=null,{type:0,cellPointIds:null}}const a=t.cells.getCellLocation(n);return{cellType:r,cellPointIds:o.getCell(a)}},e.getPointCells=e=>t.links.getCells(e),e.getCellEdgeNeighbors=(e,n,r)=>{const o=t.links.getLink(n),a=t.links.getLink(r);return o.cells.filter((t=>t!==e&&-1!==a.cells.indexOf(t)))},e.getCell=function(t){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;const r=e.getCellPoints(t),o=n||du[r.cellType].newInstance();return o.initialize(e.getPoints(),r.cellPointIds),o},e.getMaxCellSize=()=>cu.reduce(((e,n)=>Math.max(e,t[n]?.getMaxCellSize?.()??0)),0)}(e,t)}var gu={newInstance:Wt.newInstance(fu,&quot;vtkPolyData&quot;),extend:fu};const mu={image:null,canvas:null,jsImageData:null,imageBitmap:null,imageLoaded:!1,repeat:!1,interpolate:!1,edgeClamp:!1,mipLevel:0,resizable:!1};function hu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,mu,n),Wt.obj(e,t),Wt.algo(e,t,6,0),Wt.get(e,t,[&quot;canvas&quot;,&quot;image&quot;,&quot;jsImageData&quot;,&quot;imageBitmap&quot;,&quot;imageLoaded&quot;,&quot;resizable&quot;]),Wt.setGet(e,t,[&quot;repeat&quot;,&quot;edgeClamp&quot;,&quot;interpolate&quot;,&quot;mipLevel&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkTexture&quot;),e.imageLoaded=()=>{t.image.removeEventListener(&quot;load&quot;,e.imageLoaded),t.imageLoaded=!0,e.modified()},e.setJsImageData=n=>{t.jsImageData!==n&&(null!==n&&(e.setInputData(null),e.setInputConnection(null),t.image=null,t.canvas=null,t.imageBitmap=null),t.jsImageData=n,t.imageLoaded=!0,e.modified())},e.setImageBitmap=n=>{t.imageBitmap!==n&&(null!==n&&(e.setInputData(null),e.setInputConnection(null),t.image=null,t.canvas=null,t.jsImageData=null),t.imageBitmap=n,t.imageLoaded=!0,e.modified())},e.setCanvas=n=>{t.canvas!==n&&(null!==n&&(e.setInputData(null),e.setInputConnection(null),t.image=null,t.imageBitmap=null,t.jsImageData=null),t.canvas=n,e.modified())},e.setImage=n=>{t.image!==n&&(null!==n&&(e.setInputData(null),e.setInputConnection(null),t.canvas=null,t.jsImageData=null,t.imageBitmap=null),t.image=n,t.imageLoaded=!1,n.complete?e.imageLoaded():n.addEventListener(&quot;load&quot;,e.imageLoaded),e.modified())},e.getDimensionality=()=>{let n=0,r=0,o=1;if(e.getInputData()){const t=e.getInputData();n=t.getDimensions()[0],r=t.getDimensions()[1],o=t.getDimensions()[2]}return t.jsImageData&&(n=t.jsImageData.width,r=t.jsImageData.height),t.canvas&&(n=t.canvas.width,r=t.canvas.height),t.image&&(n=t.image.width,r=t.image.height),t.imageBitmap&&(n=t.imageBitmap.width,r=t.imageBitmap.height),(n>1)+(r>1)+(o>1)},e.getInputAsJsImageData=()=>{if(!t.imageLoaded||e.getInputData())return null;if(t.jsImageData)return t.jsImageData;if(t.imageBitmap)return t.imageBitmap;if(t.canvas)return t.canvas.getContext(&quot;2d&quot;).getImageData(0,0,t.canvas.width,t.canvas.height);if(t.image){const e=t.image.width,n=t.image.height,r=new OffscreenCanvas(e,n).getContext(&quot;2d&quot;);return r.translate(0,n),r.scale(1,-1),r.drawImage(t.image,0,0,e,n),r.getImageData(0,0,e,n)}return null}}(e,t)}var vu={newInstance:Wt.newInstance(hu,&quot;vtkTexture&quot;),extend:hu,generateMipmaps:(e,t,n)=>{const r=e.createShaderModule({code:&quot;\\n    @group(0) @binding(0) var inputTexture: texture_2d<f32>;\\n    @group(0) @binding(1) var outputTexture: texture_storage_2d<rgba8unorm, write>;\\n\\n    @compute @workgroup_size(8, 8)\\n    fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {\\n      let texelCoord = vec2<i32>(global_id.xy);\\n      let outputSize = textureDimensions(outputTexture);\\n\\n      if (texelCoord.x >= i32(outputSize.x) || texelCoord.y >= i32(outputSize.y)) {\\n        return;\\n      }\\n\\n      let inputSize = textureDimensions(inputTexture);\\n      let scale = vec2<f32>(inputSize) / vec2<f32>(outputSize);\\n\\n      // Compute the floating-point source coordinate\\n      let srcCoord = (vec2<f32>(texelCoord) + 0.5) * scale - 0.5;\\n\\n      // Get integer coordinates for the four surrounding texels\\n      let x0 = i32(floor(srcCoord.x));\\n      let x1 = min(x0 + 1, i32(inputSize.x) - 1);\\n      let y0 = i32(floor(srcCoord.y));\\n      let y1 = min(y0 + 1, i32(inputSize.y) - 1);\\n\\n      // Compute the weights\\n      let wx = srcCoord.x - f32(x0);\\n      let wy = srcCoord.y - f32(y0);\\n\\n      // Fetch the four texels\\n      let c00 = textureLoad(inputTexture, vec2<i32>(x0, y0), 0);\\n      let c10 = textureLoad(inputTexture, vec2<i32>(x1, y0), 0);\\n      let c01 = textureLoad(inputTexture, vec2<i32>(x0, y1), 0);\\n      let c11 = textureLoad(inputTexture, vec2<i32>(x1, y1), 0);\\n\\n      // Bilinear interpolation\\n      let color = mix(\\n        mix(c00, c10, wx),\\n        mix(c01, c11, wx),\\n        wy\\n      );\\n\\n      textureStore(outputTexture, texelCoord, color);\\n    }\\n  &quot;}),o=e.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.COMPUTE,texture:{sampleType:&quot;float&quot;}},{binding:1,visibility:GPUShaderStage.COMPUTE,storageTexture:{format:&quot;rgba8unorm&quot;,access:&quot;write-only&quot;}},{binding:2,visibility:GPUShaderStage.COMPUTE,sampler:{type:&quot;filtering&quot;}}]}),a=e.createPipelineLayout({bindGroupLayouts:[o]}),i=e.createComputePipeline({label:&quot;ComputeMipmapPipeline&quot;,layout:a,compute:{module:r,entryPoint:&quot;main&quot;}}),s=e.createSampler({magFilter:&quot;linear&quot;,minFilter:&quot;linear&quot;});for(let r=1;r<n;r++){const n=t.createView({baseMipLevel:r-1,mipLevelCount:1}),o=t.createView({baseMipLevel:r,mipLevelCount:1}),a=e.createBindGroup({layout:i.getBindGroupLayout(0),entries:[{binding:0,resource:n},{binding:1,resource:o},{binding:2,resource:s}]}),l=e.createCommandEncoder({label:&quot;MipmapGenerateCommandEncoder&quot;}),c=l.beginComputePass();c.setPipeline(i),c.setBindGroup(0,a);const u=Math.max(1,t.width>>r),d=Math.max(1,t.height>>r),p=Math.ceil(u/8),f=Math.ceil(d/8);c.dispatchWorkgroups(p,f),c.end(),e.queue.submit([l.finish()])}}};const Tu=[[-1,0,0],[1,0,0],[0,-1,0],[0,1,0],[0,0,-1],[0,0,1]],yu=[[8,7,11,3],[9,1,10,5],[4,9,0,8],[2,11,6,10],[0,3,2,1],[4,5,6,7]],bu=[[0,1],[1,3],[2,3],[0,2],[4,5],[5,7],[6,7],[4,6],[0,4],[1,5],[3,7],[2,6]],xu=[0,1,0,1,0,1,0,1,2,2,2,2],Cu=[[1,2],[1,2],[0,2],[0,2],[0,1],[0,1]],Su=new Float64Array(3),Au=new Float64Array(3),Iu=new Float64Array(3),wu=new Float64Array(3),Ou=new Float64Array(3),Pu=new Float64Array(3),Ru=new Float64Array(16);function Mu(e,t){e.strokeStyle=t.strokeColor,e.lineWidth=t.strokeSize,e.fillStyle=t.fontColor,e.font=`${t.fontStyle} ${t.fontSize}px ${t.fontFamily}`}function Eu(e){const t=[],n=[];for(let r=0;r<3;r++){const o=ro().domain([e[2*r],e[2*r+1]]);t[r]=o.ticks(5);const a=o.tickFormat(5);n[r]=t[r].map(a)}return{ticks:t,tickStrings:n}}const Vu=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{renderable:null};Object.assign(t,{},n),Wt.obj(e,t),t.tmPolyData=gu.newInstance(),t.tmMapper=Gl.newInstance(),t.tmMapper.setInputData(t.tmPolyData),t.tmActor=ss.newInstance({parentProp:e}),t.tmActor.setMapper(t.tmMapper),Wt.setGet(e,t,[&quot;renderable&quot;]),Wt.get(e,t,[&quot;lastSize&quot;,&quot;lastAspectRatio&quot;,&quot;axisTextStyle&quot;,&quot;tickTextStyle&quot;,&quot;tmActor&quot;,&quot;ticks&quot;]),t.forceUpdate=!1,t.lastRedrawTime={},Wt.obj(t.lastRedrawTime,{mtime:0}),t.lastRebuildTime={},Wt.obj(t.lastRebuildTime,{mtime:0}),t.lastSize=[-1,-1],t.lastTickBounds=[],function(e,t){t.classHierarchy.push(&quot;vtkCubeAxesActorHelper&quot;),e.setRenderable=n=>{t.renderable!==n&&(t.renderable=n,t.tmActor.addTexture(t.renderable.getTmTexture()),t.tmActor.setProperty(n.getProperty()),t.tmActor.setParentProp(n),e.modified())},e.createPolyDataForOneLabel=(e,n,r,o,a,i,s)=>{const l=t.renderable.get_tmAtlas().get(e);if(!l)return;const c=t.renderable.getTextPolyData().getPoints().getData(),u=t.lastSize;Su[0]=c[3*n],Su[1]=c[3*n+1],Su[2]=c[3*n+2],In(Iu,Su,r),Iu[0]+=.1,In(Au,Iu,o),Tn(Ou,Au,Su),Iu[0]-=.1,Iu[1]+=.1,In(Au,Iu,o),Tn(Pu,Au,Su);for(let e=0;e<3;e++)Ou[e]/=.05*u[0],Pu[e]/=.05*u[1];let d=s.ptIdx,p=s.cellIdx;Su[0]=c[3*n],Su[1]=c[3*n+1],Su[2]=c[3*n+2],a[0]<-.5?bn(Iu,Ou,a[0]*i-l.width):a[0]>.5?bn(Iu,Ou,a[0]*i):bn(Iu,Ou,a[0]*i-l.width/2),vn(Su,Su,Iu),bn(Iu,Pu,a[1]*i-l.height/2),vn(Su,Su,Iu),s.points[3*d]=Su[0],s.points[3*d+1]=Su[1],s.points[3*d+2]=Su[2],s.tcoords[2*d]=l.tcoords[0],s.tcoords[2*d+1]=l.tcoords[1],d++,bn(Iu,Ou,l.width),vn(Su,Su,Iu),s.points[3*d]=Su[0],s.points[3*d+1]=Su[1],s.points[3*d+2]=Su[2],s.tcoords[2*d]=l.tcoords[2],s.tcoords[2*d+1]=l.tcoords[3],d++,bn(Iu,Pu,l.height),vn(Su,Su,Iu),s.points[3*d]=Su[0],s.points[3*d+1]=Su[1],s.points[3*d+2]=Su[2],s.tcoords[2*d]=l.tcoords[4],s.tcoords[2*d+1]=l.tcoords[5],d++,bn(Iu,Ou,l.width),Tn(Su,Su,Iu),s.points[3*d]=Su[0],s.points[3*d+1]=Su[1],s.points[3*d+2]=Su[2],s.tcoords[2*d]=l.tcoords[6],s.tcoords[2*d+1]=l.tcoords[7],d++,s.polys[4*p]=3,s.polys[4*p+1]=d-4,s.polys[4*p+2]=d-3,s.polys[4*p+3]=d-2,p++,s.polys[4*p]=3,s.polys[4*p+1]=d-4,s.polys[4*p+2]=d-2,s.polys[4*p+3]=d-1,s.ptIdx+=4,s.cellIdx+=2},e.updateTexturePolyData=()=>{const n=t.camera.getCompositeProjectionMatrix(t.lastAspectRatio,-1,1);h(n,n);const r=t.renderable.getTextValues().length,o=4*r,a=2*r,i=new Float64Array(3*o),s=new Uint16Array(4*a),l=new Float32Array(2*o);v(Ru,n);const c={ptIdx:0,cellIdx:0,polys:s,points:i,tcoords:l};let u=0,d=0,p=0;const f=t.renderable.getTextPolyData().getPoints().getData(),g=t.renderable.getTextValues();for(;u<f.length/3;){Su[0]=f[3*u],Su[1]=f[3*u+1],Su[2]=f[3*u+2],In(Iu,Su,n),Su[0]=f[3*u+3],Su[1]=f[3*u+4],Su[2]=f[3*u+5],In(wu,Su,n),Tn(Iu,Iu,wu);const r=[Iu[0],Iu[1]];zo(r),e.createPolyDataForOneLabel(g[d],u,n,Ru,r,t.renderable.getAxisTitlePixelOffset(),c),u+=2,d++;for(let o=0;o<t.renderable.getTickCounts()[p];o++)e.createPolyDataForOneLabel(g[d],u,n,Ru,r,t.renderable.getTickLabelPixelOffset(),c),u++,d++;p++}const m=xs.newInstance({numberOfComponents:2,values:l,name:&quot;TextureCoordinates&quot;});t.tmPolyData.getPointData().setTCoords(m),t.tmPolyData.getPoints().setData(i,3),t.tmPolyData.getPoints().modified(),t.tmPolyData.getPolys().setData(s,1),t.tmPolyData.getPolys().modified(),t.tmPolyData.modified()},e.updateAPISpecificData=(n,r,o)=>{t.lastSize[0]===n[0]&&t.lastSize[1]===n[1]||(t.lastSize[0]=n[0],t.lastSize[1]=n[1],t.lastAspectRatio=n[0]/n[1],t.forceUpdate=!0),t.camera=r,e.updateTexturePolyData()}}(e,t)}),&quot;vtkCubeAxesActorHelper&quot;);function Du(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};ss.extend(e,t,function(e,t,n){return{boundsScaleFactor:1.3,camera:null,dataBounds:[...Gi.INIT_BOUNDS],faceVisibilityAngle:8,gridLines:!0,axisLabels:null,axisTitlePixelOffset:35,tickLabelPixelOffset:12,generateTicks:Eu,...n,axisTextStyle:{fontColor:&quot;white&quot;,fontStyle:&quot;normal&quot;,fontSize:18,fontFamily:&quot;serif&quot;,...n?.axisTextStyle},tickTextStyle:{fontColor:&quot;white&quot;,fontStyle:&quot;normal&quot;,fontSize:14,fontFamily:&quot;serif&quot;,...n?.tickTextStyle}}}(0,0,n)),t.lastFacesToDraw=[!1,!1,!1,!1,!1,!1],t.axisLabels=[&quot;X-Axis&quot;,&quot;Y-Axis&quot;,&quot;Z-Axis&quot;],t.tickCounts=[],t.textValues=[],t.lastTickBounds=[],t.tmCanvas=document.createElement(&quot;canvas&quot;),t.tmContext=t.tmCanvas.getContext(&quot;2d&quot;),t._tmAtlas=new Map,t.tmTexture=vu.newInstance({resizable:!0}),t.tmTexture.setInterpolate(!1),e.getProperty().setDiffuse(0),e.getProperty().setAmbient(1),t.gridMapper=Gl.newInstance(),t.polyData=gu.newInstance(),t.gridMapper.setInputData(t.polyData),t.gridActor=ss.newInstance(),t.gridActor.setMapper(t.gridMapper),t.gridActor.setProperty(e.getProperty()),t.gridActor.setParentProp(e),t.textPolyData=gu.newInstance(),Wt.setGet(e,t,[&quot;axisTitlePixelOffset&quot;,&quot;boundsScaleFactor&quot;,&quot;faceVisibilityAngle&quot;,&quot;gridLines&quot;,&quot;tickLabelPixelOffset&quot;,&quot;generateTicks&quot;]),Wt.setGetArray(e,t,[&quot;dataBounds&quot;],6),Wt.setGetArray(e,t,[&quot;axisLabels&quot;],3),Wt.get(e,t,[&quot;axisTextStyle&quot;,&quot;tickTextStyle&quot;,&quot;camera&quot;,&quot;tmTexture&quot;,&quot;textValues&quot;,&quot;textPolyData&quot;,&quot;tickCounts&quot;,&quot;gridActor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkCubeAxesActor&quot;),e.setCamera=n=>{t.camera!==n&&(t.cameraModifiedSub&&(t.cameraModifiedSub.unsubscribe(),t.cameraModifiedSub=null),t.camera=n,n&&(t.cameraModifiedSub=n.onModified(e.update)),e.update(),e.modified())},e.computeFacesToDraw=()=>{const e=t.camera.getViewMatrix();h(e,e);let n=!1;const r=Gi.getDiagonalLength(t.dataBounds),o=Math.sin(t.faceVisibilityAngle*Math.PI/180);for(let a=0;a<6;a++){let i=!1;const s=Math.floor(a/2),l=(s+1)%3,c=(s+2)%3;t.dataBounds[2*l]!==t.dataBounds[2*l+1]&&t.dataBounds[2*c]!==t.dataBounds[2*c+1]&&(Su[s]=t.dataBounds[a]-.1*r*Tu[a][s],Su[l]=.5*(t.dataBounds[2*l]+t.dataBounds[2*l+1]),Su[c]=.5*(t.dataBounds[2*c]+t.dataBounds[2*c+1]),In(Iu,Su,e),Su[s]=t.dataBounds[a],In(wu,Su,e),Tn(Iu,wu,Iu),Cn(Iu,Iu),i=Iu[2]>o,t.camera.getParallelProjection()||(Cn(wu,wu),i=Sn(wu,Iu)>o)),i!==t.lastFacesToDraw[a]&&(t.lastFacesToDraw[a]=i,n=!0)}return n},e.updatePolyData=(e,n,r)=>{let o=0,a=0;o+=8;let i=0;for(let e=0;e<12;e++)n[e]>0&&i++;if(a+=i,t.gridLines)for(let t=0;t<6;t++)e[t]&&(o+=2*r[Cu[t][0]].length+2*r[Cu[t][1]].length,a+=r[Cu[t][0]].length+r[Cu[t][1]].length);const s=new Float64Array(3*o),l=new Uint32Array(3*a);let c=0,u=0;for(let e=0;e<2;e++)for(let n=0;n<2;n++)for(let r=0;r<2;r++)s[3*c]=t.dataBounds[r],s[3*c+1]=t.dataBounds[2+n],s[3*c+2]=t.dataBounds[4+e],c++;for(let e=0;e<12;e++)n[e]>0&&(l[3*u]=2,l[3*u+1]=bu[e][0],l[3*u+2]=bu[e][1],u++);if(t.gridLines)for(let n=0;n<6;n++)if(e[n]){const e=Math.floor(n/2);let o=r[Cu[n][0]];for(let r=0;r<o.length;r++)s[3*c+e]=t.dataBounds[n],s[3*c+Cu[n][0]]=o[r],s[3*c+Cu[n][1]]=t.dataBounds[2*Cu[n][1]],c++,s[3*c+e]=t.dataBounds[n],s[3*c+Cu[n][0]]=o[r],s[3*c+Cu[n][1]]=t.dataBounds[2*Cu[n][1]+1],c++,l[3*u]=2,l[3*u+1]=c-2,l[3*u+2]=c-1,u++;o=r[Cu[n][1]];for(let r=0;r<o.length;r++)s[3*c+e]=t.dataBounds[n],s[3*c+Cu[n][1]]=o[r],s[3*c+Cu[n][0]]=t.dataBounds[2*Cu[n][0]],c++,s[3*c+e]=t.dataBounds[n],s[3*c+Cu[n][1]]=o[r],s[3*c+Cu[n][0]]=t.dataBounds[2*Cu[n][0]+1],c++,l[3*u]=2,l[3*u+1]=c-2,l[3*u+2]=c-1,u++}t.polyData.getPoints().setData(s,3),t.polyData.getPoints().modified(),t.polyData.getLines().setData(l,1),t.polyData.getLines().modified(),t.polyData.modified()},e.updateTextData=(e,n,r,o)=>{let a=0;for(let e=0;e<12;e++)1===n[e]&&(a+=2,a+=r[xu[e]].length);const i=t.polyData.getPoints().getData(),s=new Float64Array(3*a);let l=0,c=0,u=0;for(let a=0;a<6;a++)if(e[a])for(let e=0;e<4;e++){const d=yu[a][e];if(1===n[d]){const e=xu[d],n=3*bu[d][0],p=3*bu[d][1];s[3*l]=.5*(i[n]+i[p]),s[3*l+1]=.5*(i[n+1]+i[p+1]),s[3*l+2]=.5*(i[n+2]+i[p+2]),l++,s[3*l+Math.floor(a/2)]=t.dataBounds[a],s[3*l+Cu[a][0]]=.5*(t.dataBounds[2*Cu[a][0]]+t.dataBounds[2*Cu[a][0]+1]),s[3*l+Cu[a][1]]=.5*(t.dataBounds[2*Cu[a][1]]+t.dataBounds[2*Cu[a][1]+1]),l++,t.textValues[c]=t.axisLabels[e],c++;const f=(e+1)%3,g=(e+2)%3,m=r[e],h=o[e];t.tickCounts[u]=m.length;for(let r=0;r<m.length;r++)s[3*l+e]=m[r],s[3*l+f]=i[n+f],s[3*l+g]=i[n+g],l++,t.textValues[c]=h[r],c++;u++}}t.textPolyData.getPoints().setData(s,3),t.textPolyData.modified()},e.update=()=>{if(!t.camera)return;const n=e.computeFacesToDraw(),r=t.lastFacesToDraw;let o=!1;for(let e=0;e<6;e++)t.dataBounds[e]!==t.lastTickBounds[e]&&(o=!0,t.lastTickBounds[e]=t.dataBounds[e]);if(n||o||t.forceUpdate){const n=new Array(12).fill(0);for(let e=0;e<6;e++)if(r[e])for(let t=0;t<4;t++)n[yu[e][t]]++;const a=t.generateTicks(t.dataBounds);e.updatePolyData(r,n,a.ticks),e.updateTextData(r,n,a.ticks,a.tickStrings),(o||t.forceUpdate)&&e.updateTextureAtlas(a.tickStrings)}t.forceUpdate=!1},e.updateTextureAtlas=e=>{t.tmContext.textBaseline=&quot;bottom&quot;,t.tmContext.textAlign=&quot;left&quot;,t._tmAtlas.clear();let n=0,r=1;for(let o=0;o<3;o++){if(!t._tmAtlas.has(t.axisLabels[o])){Mu(t.tmContext,t.axisTextStyle);const e=t.tmContext.measureText(t.axisLabels[o]),a={height:e.actualBoundingBoxAscent+2,startingHeight:r,width:e.width+2,textStyle:t.axisTextStyle};t._tmAtlas.set(t.axisLabels[o],a),r+=a.height,n<a.width&&(n=a.width)}Mu(t.tmContext,t.tickTextStyle);for(let a=0;a<e[o].length;a++)if(!t._tmAtlas.has(e[o][a])){const i=t.tmContext.measureText(e[o][a]),s={height:i.actualBoundingBoxAscent+2,startingHeight:r,width:i.width+2,textStyle:t.tickTextStyle};t._tmAtlas.set(e[o][a],s),r+=s.height,n<s.width&&(n=s.width)}}n=wo(n),r=wo(r),t._tmAtlas.forEach((e=>{e.tcoords=[0,(r-e.startingHeight-e.height)/r,e.width/n,(r-e.startingHeight-e.height)/r,e.width/n,(r-e.startingHeight)/r,0,(r-e.startingHeight)/r]})),t.tmCanvas.width=n,t.tmCanvas.height=r,t.tmContext.textBaseline=&quot;bottom&quot;,t.tmContext.textAlign=&quot;left&quot;,t.tmContext.clearRect(0,0,n,r),t._tmAtlas.forEach(((e,n)=>{Mu(t.tmContext,e.textStyle),t.tmContext.fillText(n,1,e.startingHeight+e.height-1)})),t.tmTexture.setCanvas(t.tmCanvas),t.tmTexture.modified()},e.onModified((()=>{t.forceUpdate=!0,e.update()})),e.setTickTextStyle=n=>{t.tickTextStyle={...t.tickTextStyle,...n},e.modified()},e.setAxisTextStyle=n=>{t.axisTextStyle={...t.axisTextStyle,...n},e.modified()},e.get_tmAtlas=()=>t._tmAtlas,e.getBounds=()=>(e.update(),Gi.setBounds(t.bounds,t.gridActor.getBounds()),Gi.scaleAboutCenter(t.bounds,t.boundsScaleFactor,t.boundsScaleFactor,t.boundsScaleFactor),t.bounds);const n=Wt.chain(e.setProperty,t.gridActor.setProperty);e.setProperty=e=>n(e)[0]}(e,t)}var Lu={newInstance:Wt.newInstance(Du,&quot;vtkCubeAxesActor&quot;),extend:Du,newCubeAxesActorHelper:Vu,defaultGenerateTicks:Eu};const Bu={};const Nu=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Bu,n),qt.extend(e,t,n),t.CubeAxesActorHelper=Lu.newCubeAxesActorHelper(),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLCubeAxesActor&quot;),e.buildPass=n=>{n&&(t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getParent(),t.CubeAxesActorHelper.getRenderable()||t.CubeAxesActorHelper.setRenderable(t.renderable),e.prepareNodes(),e.addMissingNode(t.CubeAxesActorHelper.getTmActor()),e.addMissingNode(t.renderable.getGridActor()),e.removeUnusedNodes())},e.opaquePass=(e,n)=>{if(e){const e=t._openGLRenderer?t._openGLRenderer.getRenderable().getActiveCamera():null,n=t._openGLRenderer.getTiledSizeAndOrigin();t.CubeAxesActorHelper.updateAPISpecificData([n.usize,n.vsize],e,t._openGLRenderWindow.getRenderable())}}}(e,t)}),&quot;vtkOpenGLCubeAxesActor&quot;);Jt(&quot;vtkCubeAxesActor&quot;,Nu);const Fu={ARRAY_BUFFER:0,ELEMENT_ARRAY_BUFFER:1,TEXTURE_BUFFER:2};var _u={ObjectType:Fu};const{ObjectType:ku}=_u,Gu={objectType:ku.ARRAY_BUFFER,context:null,allocatedGPUMemoryInBytes:0};function Uu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Gu,n),Wt.obj(e,t),Wt.get(e,t,[&quot;_openGLRenderWindow&quot;,&quot;allocatedGPUMemoryInBytes&quot;]),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){function n(e){switch(e){case ku.ELEMENT_ARRAY_BUFFER:return t.context.ELEMENT_ARRAY_BUFFER;case ku.TEXTURE_BUFFER:if(&quot;TEXTURE_BUFFER&quot;in t.context)return t.context.TEXTURE_BUFFER;case ku.ARRAY_BUFFER:default:return t.context.ARRAY_BUFFER}}t.classHierarchy.push(&quot;vtkOpenGLBufferObject&quot;);let r=null,o=null,a=!0,i=&quot;&quot;;e.getType=()=>r,e.setType=e=>{r=e},e.getHandle=()=>o,e.isReady=()=>!1===a,e.generateBuffer=e=>{const a=n(e);return null===o&&(o=t.context.createBuffer(),r=e),n(r)===a},e.upload=(s,l)=>e.generateBuffer(l)?(t.context.bindBuffer(n(r),o),t.context.bufferData(n(r),s,t.context.STATIC_DRAW),t.allocatedGPUMemoryInBytes=s.length*s.BYTES_PER_ELEMENT,a=!1,!0):(i=&quot;Trying to upload array buffer to incompatible buffer.&quot;,!1),e.bind=()=>!!o&&(t.context.bindBuffer(n(r),o),!0),e.release=()=>!!o&&(t.context.bindBuffer(n(r),null),!0),e.releaseGraphicsResources=()=>{null!==o&&(t.context.bindBuffer(n(r),null),t.context.deleteBuffer(o),o=null,t.allocatedGPUMemoryInBytes=0)},e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))},e.getError=()=>i}(e,t)}var zu={newInstance:Wt.newInstance(Uu),extend:Uu,..._u};function Wu(e){let t=0,n=0;for(let r=0;r<3;++r){const o=e.getRange(r),a=o[1]-o[0];t+=a*a;const i=.5*(o[1]+o[0]);n+=i*i}const r=t>0&&(Math.abs(n)/t>1e6||Math.abs(Math.log10(t))>3||0===t&&n>1e6);if(r){const t=new Float64Array(3),n=new Float64Array(3);for(let r=0;r<3;++r){const o=e.getRange(r),a=o[1]-o[0];t[r]=.5*(o[1]+o[0]),n[r]=a>0?1/a:1}return{useShiftAndScale:r,coordShift:t,coordScale:n}}return{useShiftAndScale:r,coordShift:new Float32Array([0,0,0]),coordScale:new Float32Array([1,1,1])}}const{vtkErrorMacro:Hu}=Wt;const ju={elementCount:0,stride:0,colorBOStride:0,vertexOffset:0,normalOffset:0,tCoordOffset:0,tCoordComponents:0,colorOffset:0,colorComponents:0,tcoordBO:null,customData:[],coordShift:null,coordScale:null,coordShiftAndScaleEnabled:!1,inverseShiftAndScaleMatrix:null};function Ku(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ju,n),zu.extend(e,t,n),Wt.setGet(e,t,[&quot;colorBO&quot;,&quot;elementCount&quot;,&quot;stride&quot;,&quot;colorBOStride&quot;,&quot;vertexOffset&quot;,&quot;normalOffset&quot;,&quot;tCoordOffset&quot;,&quot;tCoordComponents&quot;,&quot;colorOffset&quot;,&quot;colorComponents&quot;,&quot;customData&quot;]),Wt.get(e,t,[&quot;coordShift&quot;,&quot;coordScale&quot;,&quot;coordShiftAndScaleEnabled&quot;,&quot;inverseShiftAndScaleMatrix&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLCellArrayBufferObject&quot;),e.setType(Fu.ARRAY_BUFFER),e.createVBO=function(n,r,o,a){let i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null;if(!n.getData()||!n.getData().length)return t.elementCount=0,0;t.blockSize=3,t.vertexOffset=0,t.normalOffset=0,t.tCoordOffset=0,t.tCoordComponents=0,t.colorComponents=0,t.colorOffset=0,t.customData=[];const s=a.points.getData();let l=null,c=null,u=null;const d=a.colors?a.colors.getNumberOfComponents():0,p=a.tcoords?a.tcoords.getNumberOfComponents():0;a.normals&&(t.normalOffset=4*t.blockSize,t.blockSize+=3,l=a.normals.getData()),a.customAttributes&&a.customAttributes.forEach((e=>{e&&(t.customData.push({data:e.getData(),offset:4*t.blockSize,components:e.getNumberOfComponents(),name:e.getName()}),t.blockSize+=e.getNumberOfComponents())})),a.tcoords&&(t.tCoordOffset=4*t.blockSize,t.tCoordComponents=p,t.blockSize+=p,c=a.tcoords.getData()),a.colors?(t.colorComponents=a.colors.getNumberOfComponents(),t.colorOffset=0,u=a.colors.getData(),t.colorBO||(t.colorBO=zu.newInstance()),t.colorBO.setOpenGLRenderWindow(t._openGLRenderWindow)):t.colorBO=null,t.stride=4*t.blockSize;let f,g=0,m=0,h=0,v=0,T=0,y=0;const b={anythingToPoints(e,t,n,r){for(let o=0;o<e;++o)f(t[n+o],r)},linesToWireframe(e,t,n,r){for(let o=0;o<e-1;++o)f(t[n+o],r),f(t[n+o+1],r)},polysToWireframe(e,t,n,r){if(e>2)for(let o=0;o<e;++o)f(t[n+o],r),f(t[n+(o+1)%e],r)},stripsToWireframe(e,t,n,r){if(e>2){for(let o=0;o<e-1;++o)f(t[n+o],r),f(t[n+o+1],r);for(let o=0;o<e-2;o++)f(t[n+o],r),f(t[n+o+2],r)}},polysToSurface(e,t,n,r){for(let o=0;o<e-2;o++)f(t[n+0],r),f(t[n+o+1],r),f(t[n+o+2],r)},stripsToSurface(e,t,n,r){for(let o=0;o<e-2;o++)f(t[n+o],r),f(t[n+o+1+o%2],r),f(t[n+o+1+(o+1)%2],r)}},x={anythingToPoints(e,t){return e},linesToWireframe(e,t){return e>1?2*(e-1):0},polysToWireframe(e,t){return e>2?2*e:0},stripsToWireframe(e,t){return e>2?4*e-6:0},polysToSurface(e,t){return e>2?3*(e-2):0},stripsToSurface(e,t,n){return e>2?3*(e-2):0}};let C=null,S=null;o===Zi.POINTS||&quot;verts&quot;===r?(C=b.anythingToPoints,S=x.anythingToPoints):o===Zi.WIREFRAME||&quot;lines&quot;===r?(C=b[`${r}ToWireframe`],S=x[`${r}ToWireframe`]):(C=b[`${r}ToSurface`],S=x[`${r}ToSurface`]);const A=n.getData(),I=A.length;let w=0;for(let e=0;e<I;)w+=S(A[e],A),e+=A[e]+1;let O=null;const P=new Float32Array(w*t.blockSize);u&&(O=new Uint8Array(4*w));let R=0,M=0;const{useShiftAndScale:E,coordShift:V,coordScale:D}=Wu(a.points);if(E?e.setCoordShiftAndScale(V,D):!0===t.coordShiftAndScaleEnabled&&e.setCoordShiftAndScale(null,null),i)if(i.points||i.cells){const e=new Int32Array(w+i.points.length);e.set(i.points),i.points=e;const t=new Int32Array(w+i.cells.length);t.set(i.cells),i.cells=t}else i.points=new Int32Array(w),i.cells=new Int32Array(w);let L=a.vertexOffset;f=function(e,n){if(i&&(i.points[L]=e,i.cells[L]=y+a.cellOffset),++L,g=3*e,t.coordShiftAndScaleEnabled?(P[R++]=(s[g++]-t.coordShift[0])*t.coordScale[0],P[R++]=(s[g++]-t.coordShift[1])*t.coordScale[1],P[R++]=(s[g++]-t.coordShift[2])*t.coordScale[2]):(P[R++]=s[g++],P[R++]=s[g++],P[R++]=s[g++]),null!==l&&(m=a.haveCellNormals?3*(y+a.cellOffset):3*e,P[R++]=l[m++],P[R++]=l[m++],P[R++]=l[m++]),t.customData.forEach((t=>{T=e*t.components;for(let e=0;e<t.components;++e)P[R++]=t.data[T++]})),null!==c){h=a.useTCoordsPerCell?n*p:e*p;for(let e=0;e<p;++e)P[R++]=c[h++]}null!==u&&(v=a.haveCellScalars?(y+a.cellOffset)*d:e*d,O[M++]=u[v++],O[M++]=u[v++],O[M++]=u[v++],O[M++]=4===d?u[v++]:255)};for(let e=0;e<I;e+=A[e]+1,y++)C(A[e],A,e+1,y+a.cellOffset);return t.elementCount=w,e.upload(P,Fu.ARRAY_BUFFER),t.colorBO&&(t.colorBOStride=4,t.colorBO.upload(O,Fu.ARRAY_BUFFER)),y},e.setCoordShiftAndScale=(e,n)=>{null===e||e.constructor===Float64Array&&3===e.length?null===n||n.constructor===Float64Array&&3===n.length?(null!==t.coordShift&&null!==e&&Pn(e,t.coordShift)||(t.coordShift=e),null!==t.coordScale&&null!==n&&Pn(n,t.coordScale)||(t.coordScale=n),t.coordShiftAndScaleEnabled=function(e,t){return null!==e&&null!==t&&!(On(e,[0,0,0])&&On(t,[1,1,1]))}(t.coordShift,t.coordScale),t.coordShiftAndScaleEnabled?t.inverseShiftAndScaleMatrix=function(e,t){const n=new Float64Array(3);xn(n,t);const r=new Float64Array(16);return _(r,Ba(),e,n),r}(t.coordShift,t.coordScale):t.inverseShiftAndScaleMatrix=null):Hu(&quot;Wrong type for coordScale, expected vec3 or null&quot;):Hu(&quot;Wrong type for coordShift, expected vec3 or null&quot;)}}(e,t)}var $u={newInstance:Wt.newInstance(Ku),extend:Ku};const{vtkErrorMacro:qu}=Wt,Xu={shaderType:&quot;Unknown&quot;,source:&quot;&quot;,error:&quot;&quot;,handle:0,dirty:!1,context:null};function Yu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Xu,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;shaderType&quot;,&quot;source&quot;,&quot;error&quot;,&quot;handle&quot;,&quot;context&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkShader&quot;),e.compile=()=>{let e=t.context.VERTEX_SHADER;if(!t.source||!t.source.length||&quot;Unknown&quot;===t.shaderType)return!1;if(0!==t.handle&&(t.context.deleteShader(t.handle),t.handle=0),e=&quot;Fragment&quot;===t.shaderType?t.context.FRAGMENT_SHADER:t.context.VERTEX_SHADER,t.handle=t.context.createShader(e),t.context.shaderSource(t.handle,t.source),t.context.compileShader(t.handle),!t.context.getShaderParameter(t.handle,t.context.COMPILE_STATUS)){const e=t.context.getShaderInfoLog(t.handle);return qu(`Error compiling shader '${t.source}': ${e}`),t.context.deleteShader(t.handle),t.handle=0,!1}return!0},e.cleanup=()=>{&quot;Unknown&quot;!==t.shaderType&&0!==t.handle&&(t.context.deleteShader(t.handle),t.handle=0,t.dirty=!0)}}(e,t)}var Zu={newInstance:Wt.newInstance(Yu,&quot;vtkShader&quot;),extend:Yu};const{vtkErrorMacro:Qu}=Wt,Ju={vertexShaderHandle:0,fragmentShaderHandle:0,geometryShaderHandle:0,vertexShader:null,fragmentShader:null,geometryShader:null,linked:!1,bound:!1,compiled:!1,error:&quot;&quot;,handle:0,numberOfOutputs:0,attributesLocs:null,uniformLocs:null,md5Hash:0,context:null,lastCameraMTime:null};function ed(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ju,n),t.attributesLocs={},t.uniformLocs={},t.vertexShader=Zu.newInstance(),t.vertexShader.setShaderType(&quot;Vertex&quot;),t.fragmentShader=Zu.newInstance(),t.fragmentShader.setShaderType(&quot;Fragment&quot;),t.geometryShader=Zu.newInstance(),t.geometryShader.setShaderType(&quot;Geometry&quot;),Wt.obj(e,t),Wt.get(e,t,[&quot;lastCameraMTime&quot;]),Wt.setGet(e,t,[&quot;error&quot;,&quot;handle&quot;,&quot;compiled&quot;,&quot;bound&quot;,&quot;md5Hash&quot;,&quot;vertexShader&quot;,&quot;fragmentShader&quot;,&quot;geometryShader&quot;,&quot;linked&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkShaderProgram&quot;),e.compileShader=()=>t.vertexShader.compile()?t.fragmentShader.compile()?e.attachShader(t.vertexShader)&&e.attachShader(t.fragmentShader)?e.link()?(e.setCompiled(!0),1):(Qu(`Links failed: ${t.error}`),0):(Qu(t.error),0):(Qu(t.fragmentShader.getSource().split(&quot;\\n&quot;).map(((e,t)=>`${t}: ${e}`)).join(&quot;\\n&quot;)),Qu(t.fragmentShader.getError()),0):(Qu(t.vertexShader.getSource().split(&quot;\\n&quot;).map(((e,t)=>`${t}: ${e}`)).join(&quot;\\n&quot;)),Qu(t.vertexShader.getError()),0),e.cleanup=()=>{&quot;Unknown&quot;!==t.shaderType&&0!==t.handle&&(e.release(),0!==t.vertexShaderHandle&&(t.context.detachShader(t.handle,t.vertexShaderHandle),t.vertexShaderHandle=0),0!==t.fragmentShaderHandle&&(t.context.detachShader(t.handle,t.fragmentShaderHandle),t.fragmentShaderHandle=0),t.context.deleteProgram(t.handle),t.handle=0,e.setCompiled(!1))},e.bind=()=>!(!t.linked&&!e.link()||(t.context.useProgram(t.handle),e.setBound(!0),0)),e.isBound=()=>!!t.bound,e.release=()=>{t.context.useProgram(null),e.setBound(!1)},e.setContext=e=>{t.vertexShader.setContext(e),t.fragmentShader.setContext(e),t.geometryShader.setContext(e)},e.link=()=>{if(t.linked)return!0;if(0===t.handle)return t.error=&quot;Program has not been initialized, and/or does not have shaders.&quot;,!1;if(t.uniformLocs={},t.context.linkProgram(t.handle),!t.context.getProgramParameter(t.handle,t.context.LINK_STATUS)){const e=t.context.getProgramInfoLog(t.handle);return Qu(`Error linking shader ${e}`),t.handle=0,!1}return e.setLinked(!0),t.attributeLocs={},!0},e.setUniformMatrix=(n,r)=>{const o=e.findUniform(n);if(-1===o)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;const a=new Float32Array(r);return t.context.uniformMatrix4fv(o,!1,a),!0},e.setUniformMatrix3x3=(n,r)=>{const o=e.findUniform(n);if(-1===o)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;const a=new Float32Array(r);return t.context.uniformMatrix3fv(o,!1,a),!0},e.setUniformf=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform1f(o,r),!0)},e.setUniformfv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform1fv(o,r),!0)},e.setUniformi=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform1i(o,r),!0)},e.setUniformiv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform1iv(o,r),!0)},e.setUniform2f=(n,r,o)=>{const a=e.findUniform(n);if(-1===a)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;if(void 0===o)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform2f(a,r,o),!0},e.setUniform2fv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform2fv(o,r),!0)},e.setUniform2i=(n,r,o)=>{const a=e.findUniform(n);if(-1===a)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;if(void 0===o)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform2i(a,r,o),!0},e.setUniform2iv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform2iv(o,r),!0)},e.setUniform3f=(n,r,o,a)=>{const i=e.findUniform(n);if(-1===i)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;if(void 0===a)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform3f(i,r,o,a),!0},e.setUniform3fArray=(n,r)=>{const o=e.findUniform(n);if(-1===o)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;if(!Array.isArray(r)||3!==r.length)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform3f(o,r[0],r[1],r[2]),!0},e.setUniform3fv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform3fv(o,r),!0)},e.setUniform3i=function(n){const r=e.findUniform(n);if(-1===r)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;for(var o=arguments.length,a=new Array(o>1?o-1:0),i=1;i<o;i++)a[i-1]=arguments[i];let s=a;if(1===s.length&&Array.isArray(s[0])&&(s=s[0]),3!==s.length)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform3i(r,s[0],s[1],s[2]),!0},e.setUniform3iv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform3iv(o,r),!0)},e.setUniform4f=function(n){const r=e.findUniform(n);if(-1===r)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;for(var o=arguments.length,a=new Array(o>1?o-1:0),i=1;i<o;i++)a[i-1]=arguments[i];let s=a;if(1===s.length&&Array.isArray(s[0])&&(s=s[0]),4!==s.length)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform4f(r,s[0],s[1],s[2],s[3]),!0},e.setUniform4fv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform4fv(o,r),!0)},e.setUniform4i=function(n){const r=e.findUniform(n);if(-1===r)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;for(var o=arguments.length,a=new Array(o>1?o-1:0),i=1;i<o;i++)a[i-1]=arguments[i];let s=a;if(1===s.length&&Array.isArray(s[0])&&(s=s[0]),4!==s.length)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform4i(r,s[0],s[1],s[2],s[3]),!0},e.setUniform4iv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform4iv(o,r),!0)},e.findUniform=e=>{if(!e||!t.linked)return-1;let n=t.uniformLocs[e];return void 0!==n?n:(n=t.context.getUniformLocation(t.handle,e),null===n?(t.error=`Uniform ${e} not found in current shader program.`,t.uniformLocs[e]=-1,-1):(t.uniformLocs[e]=n,n))},e.isUniformUsed=e=>{if(!e)return!1;let n=t.uniformLocs[e];return void 0!==n?null!==n:t.linked?(n=t.context.getUniformLocation(t.handle,e),t.uniformLocs[e]=n,null!==n):(Qu(&quot;attempt to find uniform when the shader program is not linked&quot;),!1)},e.isAttributeUsed=e=>{if(!e)return!1;if(e in t.attributeLocs)return!0;if(!t.linked)return Qu(&quot;attempt to find uniform when the shader program is not linked&quot;),!1;const n=t.context.getAttribLocation(t.handle,e);return-1!==n&&(t.attributeLocs[e]=n,!0)},e.attachShader=n=>{if(0===n.getHandle())return t.error=&quot;Shader object was not initialized, cannot attach it.&quot;,!1;if(&quot;Unknown&quot;===n.getShaderType())return t.error=&quot;Shader object is of type Unknown and cannot be used.&quot;,!1;if(0===t.handle){const e=t.context.createProgram();if(0===e)return t.error=&quot;Could not create shader program.&quot;,!1;t.handle=e,t.linked=!1}return&quot;Vertex&quot;===n.getShaderType()&&(0!==t.vertexShaderHandle&&t.context.detachShader(t.handle,t.vertexShaderHandle),t.vertexShaderHandle=n.getHandle()),&quot;Fragment&quot;===n.getShaderType()&&(0!==t.fragmentShaderHandle&&t.context.detachShader(t.handle,t.fragmentShaderHandle),t.fragmentShaderHandle=n.getHandle()),t.context.attachShader(t.handle,n.getHandle()),e.setLinked(!1),!0},e.detachShader=e=>{if(0===e.getHandle())return t.error=&quot;shader object was not initialized, cannot attach it.&quot;,!1;if(&quot;Unknown&quot;===e.getShaderType())return t.error=&quot;Shader object is of type Unknown and cannot be used.&quot;,!1;switch(0===t.handle&&(t.error=&quot;This shader program has not been initialized yet.&quot;),e.getShaderType()){case&quot;Vertex&quot;:return t.vertexShaderHandle!==e.getHandle()?(t.error=&quot;The supplied shader was not attached to this program.&quot;,!1):(t.context.detachShader(t.handle,e.getHandle()),t.vertexShaderHandle=0,t.linked=!1,!0);case&quot;Fragment&quot;:return t.fragmentShaderHandle!==e.getHandle()?(t.error=&quot;The supplied shader was not attached to this program.&quot;,!1):(t.context.detachShader(t.handle,e.getHandle()),t.fragmentShaderHandle=0,t.linked=!1,!0);default:return!1}},e.setContext=e=>{t.context=e,t.vertexShader.setContext(e),t.fragmentShader.setContext(e),t.geometryShader.setContext(e)},e.setLastCameraMTime=e=>{t.lastCameraMTime=e}}(e,t)}var td={newInstance:Wt.newInstance(ed,&quot;vtkShaderProgram&quot;),extend:ed,substitute:function(e,t,n,r){const o=&quot;string&quot;==typeof n?n:n.join(&quot;\\n&quot;),a=!1===r?t:new RegExp(t,&quot;g&quot;),i=e.replace(a,o);return{replace:i!==o,result:i}}};const nd={forceEmulation:!1,handleVAO:0,handleProgram:0,supported:!0,buffers:null,context:null};function rd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,nd,n),t.buffers=[],Wt.obj(e,t),Wt.get(e,t,[&quot;supported&quot;]),Wt.setGet(e,t,[&quot;forceEmulation&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLVertexArrayObject&quot;),e.exposedMethod=()=>{},e.initialize=()=>{t.instancingExtension=null,t._openGLRenderWindow.getWebgl2()||(t.instancingExtension=t.context.getExtension(&quot;ANGLE_instanced_arrays&quot;)),!t.forceEmulation&&t._openGLRenderWindow&&t._openGLRenderWindow.getWebgl2()?(t.extension=null,t.supported=!0,t.handleVAO=t.context.createVertexArray()):(t.extension=t.context.getExtension(&quot;OES_vertex_array_object&quot;),!t.forceEmulation&&t.extension?(t.supported=!0,t.handleVAO=t.extension.createVertexArrayOES()):t.supported=!1)},e.isReady=()=>0!==t.handleVAO||!1===t.supported,e.bind=()=>{if(e.isReady()||e.initialize(),e.isReady()&&t.supported)t.extension?t.extension.bindVertexArrayOES(t.handleVAO):t.context.bindVertexArray(t.handleVAO);else if(e.isReady()){const e=t.context;for(let n=0;n<t.buffers.length;++n){const r=t.buffers[n];t.context.bindBuffer(e.ARRAY_BUFFER,r.buffer);for(let n=0;n<r.attributes.length;++n){const o=r.attributes[n],a=o.isMatrix?o.size:1;for(let n=0;n<a;++n)e.enableVertexAttribArray(o.index+n),e.vertexAttribPointer(o.index+n,o.size,o.type,o.normalize,o.stride,o.offset+o.stride*n/o.size),o.divisor>0&&(t.instancingExtension?t.instancingExtension.vertexAttribDivisorANGLE(o.index+n,1):e.vertexAttribDivisor(o.index+n,1))}}}},e.release=()=>{if(e.isReady()&&t.supported)t.extension?t.extension.bindVertexArrayOES(null):t.context.bindVertexArray(null);else if(e.isReady()){const e=t.context;for(let n=0;n<t.buffers.length;++n){const r=t.buffers[n];t.context.bindBuffer(e.ARRAY_BUFFER,r.buffer);for(let n=0;n<r.attributes.length;++n){const o=r.attributes[n],a=o.isMatrix?o.size:1;for(let n=0;n<a;++n)e.enableVertexAttribArray(o.index+n),e.vertexAttribPointer(o.index+n,o.size,o.type,o.normalize,o.stride,o.offset+o.stride*n/o.size),o.divisor>0&&(t.instancingExtension?t.instancingExtension.vertexAttribDivisorANGLE(o.index+n,0):e.vertexAttribDivisor(o.index+n,0)),e.disableVertexAttribArray(o.index+n)}}}},e.shaderProgramChanged=()=>{e.release(),t.handleVAO&&(t.extension?t.extension.deleteVertexArrayOES(t.handleVAO):t.context.deleteVertexArray(t.handleVAO)),t.handleVAO=0,t.handleProgram=0},e.releaseGraphicsResources=()=>{e.shaderProgramChanged(),t.handleVAO&&(t.extension?t.extension.deleteVertexArrayOES(t.handleVAO):t.context.deleteVertexArray(t.handleVAO)),t.handleVAO=0,t.supported=!0,t.handleProgram=0},e.addAttributeArray=(t,n,r,o,a,i,s,l)=>e.addAttributeArrayWithDivisor(t,n,r,o,a,i,s,l,0,!1),e.addAttributeArrayWithDivisor=(n,r,o,a,i,s,l,c,u,d)=>{if(!n)return!1;if(!n.isBound()||0===r.getHandle()||r.getType()!==Fu.ARRAY_BUFFER)return!1;if(0===t.handleProgram&&(t.handleProgram=n.getHandle()),e.isReady()||e.initialize(),!e.isReady()||t.handleProgram!==n.getHandle())return!1;const p=t.context,f={};if(f.name=o,f.index=p.getAttribLocation(t.handleProgram,o),f.offset=a,f.stride=i,f.type=s,f.size=l,f.normalize=c,f.isMatrix=d,f.divisor=u,-1===f.Index)return!1;if(r.bind(),p.enableVertexAttribArray(f.index),p.vertexAttribPointer(f.index,f.size,f.type,f.normalize,f.stride,f.offset),u>0&&(t.instancingExtension?t.instancingExtension.vertexAttribDivisorANGLE(f.index,1):p.vertexAttribDivisor(f.index,1)),f.buffer=r.getHandle(),!t.supported){let e=!1;for(let n=0;n<t.buffers.length;++n){const r=t.buffers[n];if(r.buffer===f.buffer){e=!0;let t=!1;for(let e=0;e<r.attributes.length;++e)r.attributes[e].name===o&&(t=!0,r.attributes[e]=f);t||r.attributes.push(f)}}e||t.buffers.push({buffer:f.buffer,attributes:[f]})}return!0},e.addAttributeMatrixWithDivisor=(n,r,o,a,i,s,l,c,u)=>{const d=e.addAttributeArrayWithDivisor(n,r,o,a,i,s,l,c,u,!0);if(!d)return d;const p=t.context,f=p.getAttribLocation(t.handleProgram,o);for(let e=1;e<l;e++)p.enableVertexAttribArray(f+e),p.vertexAttribPointer(f+e,l,s,c,i,a+i*e/l),u>0&&(t.instancingExtension?t.instancingExtension.vertexAttribDivisorANGLE(f+e,1):p.vertexAttribDivisor(f+e,1));return!0},e.removeAttributeArray=n=>{if(!e.isReady()||0===t.handleProgram)return!1;if(!t.supported)for(let e=0;e<t.buffers.length;++e){const r=t.buffers[e];for(let o=0;o<r.attributes.length;++o)if(r.attributes[o].name===n)return r.attributes.splice(o,1),r.attributes.length||t.buffers.splice(e,1),!0}return!0},e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))}}(e,t)}var od={newInstance:Wt.newInstance(rd,&quot;vtkOpenGLVertexArrayObject&quot;),extend:rd};const ad={Start:0,Points:0,Lines:1,Tris:2,TriStrips:3,TrisEdges:4,TriStripsEdges:5,End:6},id={context:null,program:null,shaderSourceTime:null,VAO:null,attributeUpdateTime:null,CABO:null,primitiveType:0,pointPicking:!1};function sd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,id,n),Wt.obj(e,t),t.shaderSourceTime={},Wt.obj(t.shaderSourceTime),t.attributeUpdateTime={},Wt.obj(t.attributeUpdateTime),Wt.setGet(e,t,[&quot;program&quot;,&quot;shaderSourceTime&quot;,&quot;VAO&quot;,&quot;attributeUpdateTime&quot;,&quot;CABO&quot;,&quot;primitiveType&quot;,&quot;pointPicking&quot;]),t.program=td.newInstance(),t.VAO=od.newInstance(),t.CABO=$u.newInstance(),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLHelper&quot;),e.setOpenGLRenderWindow=e=>{t.context=e.getContext(),t.program.setContext(t.context),t.VAO.setOpenGLRenderWindow(e),t.CABO.setOpenGLRenderWindow(e)},e.releaseGraphicsResources=e=>{t.VAO.releaseGraphicsResources(),t.CABO.releaseGraphicsResources(),t.CABO.setElementCount(0)},e.drawArrays=(n,r,o,a)=>{if(t.CABO.getElementCount()){const i=e.getOpenGLMode(o),s=e.haveWideLines(n,r),l=t.context,c=l.getParameter(l.DEPTH_WRITEMASK);t.pointPicking&&l.depthMask(!1),i===l.LINES&&s?(e.updateShaders(n,r,a),l.drawArraysInstanced(i,0,t.CABO.getElementCount(),2*Math.ceil(r.getProperty().getLineWidth()))):(l.lineWidth(r.getProperty().getLineWidth()),e.updateShaders(n,r,a),l.drawArrays(i,0,t.CABO.getElementCount()),l.lineWidth(1));const u=(i===l.POINTS?1:0)||(i===l.LINES?2:3);return t.pointPicking&&l.depthMask(c),t.CABO.getElementCount()/u}return 0},e.getOpenGLMode=e=>{if(t.pointPicking)return t.context.POINTS;const n=t.primitiveType;return e===Zi.POINTS||n===ad.Points?t.context.POINTS:e===Zi.WIREFRAME||n===ad.Lines||n===ad.TrisEdges||n===ad.TriStripsEdges?t.context.LINES:t.context.TRIANGLES},e.haveWideLines=(e,n)=>n.getProperty().getLineWidth()>1&&!(t.CABO.getOpenGLRenderWindow()&&t.CABO.getOpenGLRenderWindow().getHardwareMaximumLineWidth()>=n.getProperty().getLineWidth()),e.getNeedToRebuildShaders=(t,n,r)=>!!(r.getNeedToRebuildShaders(e,t,n)||0===e.getProgram()||e.getShaderSourceTime().getMTime()<r.getMTime()||e.getShaderSourceTime().getMTime()<n.getMTime()),e.updateShaders=(n,r,o)=>{if(e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};o.buildShaders(a,n,r);const i=t.CABO.getOpenGLRenderWindow().getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==e.getProgram()&&(e.setProgram(i),e.getVAO().releaseGraphicsResources()),e.getShaderSourceTime().modified()}else t.CABO.getOpenGLRenderWindow().getShaderCache().readyShaderProgram(e.getProgram());e.getVAO().bind(),o.setMapperShaderParameters(e,n,r),o.setPropertyShaderParameters(e,n,r),o.setCameraShaderParameters(e,n,r),o.setLightingShaderParameters(e,n,r),o.invokeShaderCallbacks(e,n,r)},e.setMapperShaderParameters=(n,r,o)=>{if(e.haveWideLines(n,r)){e.getProgram().setUniform2f(&quot;viewportSize&quot;,o.usize,o.vsize);const t=parseFloat(r.getProperty().getLineWidth()),n=t/2;e.getProgram().setUniformf(&quot;lineWidthStepSize&quot;,t/Math.ceil(t)),e.getProgram().setUniformf(&quot;halfLineWidth&quot;,n)}t.primitiveType===ad.Points||r.getProperty().getRepresentation()===Zi.POINTS?e.getProgram().setUniformf(&quot;pointSize&quot;,r.getProperty().getPointSize()):t.pointPicking&&e.getProgram().setUniformf(&quot;pointSize&quot;,e.getPointPickingPrimitiveSize())},e.replaceShaderPositionVC=(n,r,o)=>{let a=n.Vertex;a=td.substitute(a,&quot;//VTK::PositionVC::Dec&quot;,[&quot;//VTK::PositionVC::Dec&quot;,&quot;uniform float pointSize;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;//VTK::PositionVC::Impl&quot;,&quot;  gl_PointSize = pointSize;&quot;],!1).result,e.getOpenGLMode(o.getProperty().getRepresentation())===t.context.LINES&&e.haveWideLines(r,o)&&(a=td.substitute(a,&quot;//VTK::PositionVC::Dec&quot;,[&quot;//VTK::PositionVC::Dec&quot;,&quot;uniform vec2 viewportSize;&quot;,&quot;uniform float lineWidthStepSize;&quot;,&quot;uniform float halfLineWidth;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;//VTK::PositionVC::Impl&quot;,&quot; if (halfLineWidth > 0.0)&quot;,&quot;   {&quot;,&quot;   float offset = float(gl_InstanceID / 2) * lineWidthStepSize - halfLineWidth;&quot;,&quot;   vec4 tmpPos = gl_Position;&quot;,&quot;   vec3 tmpPos2 = tmpPos.xyz / tmpPos.w;&quot;,&quot;   tmpPos2.x = tmpPos2.x + 2.0 * mod(float(gl_InstanceID), 2.0) * offset / viewportSize[0];&quot;,&quot;   tmpPos2.y = tmpPos2.y + 2.0 * mod(float(gl_InstanceID + 1), 2.0) * offset / viewportSize[1];&quot;,&quot;   gl_Position = vec4(tmpPos2.xyz * tmpPos.w, tmpPos.w);&quot;,&quot;   }&quot;]).result),n.Vertex=a},e.getPointPickingPrimitiveSize=()=>t.primitiveType===ad.Points?2:t.primitiveType===ad.Lines?4:6,e.getAllocatedGPUMemoryInBytes=()=>e.getCABO().getAllocatedGPUMemoryInBytes()}(e,t)}var ld={newInstance:Wt.newInstance(sd),extend:sd,primTypes:ad};const cd={CLAMP_TO_EDGE:0,REPEAT:1,MIRRORED_REPEAT:2},ud={NEAREST:0,LINEAR:1,NEAREST_MIPMAP_NEAREST:2,NEAREST_MIPMAP_LINEAR:3,LINEAR_MIPMAP_NEAREST:4,LINEAR_MIPMAP_LINEAR:5};var dd={Wrap:cd,Filter:ud};const pd=new Float32Array(1),fd=new Int32Array(pd.buffer);var gd={fromHalf:function(e){const t=(32768&e)>>15,n=(31744&e)>>10,r=1023&e;return 0===n?(t?-1:1)*2**-14*(r/1024):31===n?r?NaN:1/0*(t?-1:1):(t?-1:1)*2**(n-15)*(1+r/1024)},toHalf:function(e){pd[0]=e;const t=fd[0];let n=t>>16&32768,r=t>>12&2047;const o=t>>23&255;return o<103?n:o>142?(n|=31744,n|=(255===o?0:1)&&8388607&t,n):o<113?(r|=2048,n|=(r>>114-o)+(r>>113-o&1),n):(n|=o-112<<10|r>>1,n+=1&r,n)}};let md;const{Wrap:hd,Filter:vd}=dd,{VtkDataTypes:Td}=xs,{vtkDebugMacro:yd,vtkErrorMacro:bd,vtkWarningMacro:xd,requiredParam:Cd}=Ht,{toHalf:Sd}=gd;function Ad(e,t){function n(){return{internalFormat:t.internalFormat,format:t.format,openGLDataType:t.openGLDataType,width:t.width,height:t.height}}t.classHierarchy.push(&quot;vtkOpenGLTexture&quot;),e.render=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:null;if(n?t._openGLRenderWindow=n:(t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;)),t.context=t._openGLRenderWindow.getContext(),t.renderable.getInterpolate()?(t.generateMipmap?e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR):e.setMinificationFilter(vd.LINEAR),e.setMagnificationFilter(vd.LINEAR)):(e.setMinificationFilter(vd.NEAREST),e.setMagnificationFilter(vd.NEAREST)),t.renderable.getRepeat()&&(e.setWrapR(hd.REPEAT),e.setWrapS(hd.REPEAT),e.setWrapT(hd.REPEAT)),t.renderable.getInputData()&&t.renderable.setImage(null),!t.handle||t.renderable.getMTime()>t.textureBuildTime.getMTime()){if(null!==t.renderable.getImageBitmap()&&(t.renderable.getInterpolate()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR)),t.renderable.getImageBitmap()&&t.renderable.getImageLoaded()&&(e.create2DFromImageBitmap(t.renderable.getImageBitmap()),e.activate(),e.sendParameters(),t.textureBuildTime.modified())),null!==t.renderable.getImage()&&(t.renderable.getInterpolate()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR)),t.renderable.getImage()&&t.renderable.getImageLoaded()&&(e.create2DFromImage(t.renderable.getImage()),e.activate(),e.sendParameters(),t.textureBuildTime.modified())),null!==t.renderable.getCanvas()){t.renderable.getInterpolate()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR));const n=t.renderable.getCanvas();e.create2DFromRaw({width:n.width,height:n.height,numComps:4,dataType:Td.UNSIGNED_CHAR,data:n,flip:!0}),e.activate(),e.sendParameters(),t.textureBuildTime.modified()}if(null!==t.renderable.getJsImageData()){const n=t.renderable.getJsImageData();t.renderable.getInterpolate()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR)),e.create2DFromRaw({width:n.width,height:n.height,numComps:4,dataType:Td.UNSIGNED_CHAR,data:n.data,flip:!0}),e.activate(),e.sendParameters(),t.textureBuildTime.modified()}const n=t.renderable.getInputData(0);if(n&&n.getPointData().getScalars()){const r=n.getExtent(),o=n.getPointData().getScalars(),a=[];for(let e=0;e<t.renderable.getNumberOfInputPorts();++e){const n=t.renderable.getInputData(e),r=n?n.getPointData().getScalars().getData():null;r&&a.push(r)}t.renderable.getInterpolate()&&4===o.getNumberOfComponents()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR)),a.length%6==0?e.createCubeFromRaw({width:r[1]-r[0]+1,height:r[3]-r[2]+1,numComps:o.getNumberOfComponents(),dataType:o.getDataType(),data:a}):e.create2DFromRaw({width:r[1]-r[0]+1,height:r[3]-r[2]+1,numComps:o.getNumberOfComponents(),dataType:o.getDataType(),data:o.getData()}),e.activate(),e.sendParameters(),t.textureBuildTime.modified()}}t.handle&&e.activate()};const r=()=>{if(t.minificationFilter!==vd.LINEAR&&t.magnificationFilter!==vd.LINEAR||(void 0===md&&(md=function(){try{const e=4,t=2,n=1,r=new Int16Array([0,32767]),o=[1,1],a=document.createElement(&quot;canvas&quot;);a.width=e,a.height=e;const i=a.getContext(&quot;webgl2&quot;);if(!i)return!1;const s=i.getExtension(&quot;EXT_texture_norm16&quot;);if(!s)return!1;const l=`#version 300 es\\n    void main() {\\n      gl_PointSize = ${e.toFixed(1)};\\n      gl_Position = vec4(0, 0, 0, 1);\\n    }\\n  `,c=&quot;#version 300 es\\n    precision highp float;\\n    precision highp int;\\n    precision highp sampler2D;\\n\\n    uniform sampler2D u_image;\\n\\n    out vec4 color;\\n\\n    void main() {\\n        vec4 intColor = texture(u_image, gl_PointCoord.xy);\\n        color = vec4(vec3(intColor.rrr), 1);\\n    }\\n    &quot;,u=i.createShader(i.VERTEX_SHADER);if(i.shaderSource(u,l),i.compileShader(u),!i.getShaderParameter(u,i.COMPILE_STATUS))return!1;const d=i.createShader(i.FRAGMENT_SHADER);if(i.shaderSource(d,c),i.compileShader(d),!i.getShaderParameter(d,i.COMPILE_STATUS))return!1;const p=i.createProgram();if(i.attachShader(p,u),i.attachShader(p,d),i.linkProgram(p),!i.getProgramParameter(p,i.LINK_STATUS))return!1;const f=i.createTexture();i.bindTexture(i.TEXTURE_2D,f),i.texImage2D(i.TEXTURE_2D,0,s.R16_SNORM_EXT,t,n,0,i.RED,i.SHORT,r),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_MAG_FILTER,i.LINEAR),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_MIN_FILTER,i.LINEAR),i.useProgram(p),i.drawArrays(i.POINTS,0,1);const g=new Uint8Array(4);i.readPixels(o[0],o[1],1,1,i.RGBA,i.UNSIGNED_BYTE,g);const[m,h,v]=g,T=i.getExtension(&quot;WEBGL_lose_context&quot;);return T&&T.loseContext(),m===h&&h===v&&0!==m}catch(e){return!1}}()),md))return t.oglNorm16Ext};function o(e){const[t,n,r,o,a,i]=e;return[n-t+1,o-r+1,i-a+1]}function a(e){const[t,n,r]=o(e);return t*n*r}function i(e,n){const r=new((arguments.length>2&&void 0!==arguments[2]?arguments[2]:null)||e.constructor)(n.reduce(((e,t)=>e+a(t)),0)),o=[t.width,t.height,t.depth];let i=0;return n.forEach((t=>{!function(e,t,n,r,o){const[a,i,s,l,c,u]=n,[d,p]=t,f=d*p;let g=o;for(let t=c;t<=u;t++){const n=t*f;for(let t=s;t<=l;t++){const o=n+t*d;for(let t=o+a,n=o+i;t<=n;t++,g++)r[g]=e[t]}}}(e,o,t,r,i),i+=a(t)})),r}function s(e){if(t._openGLRenderWindow.getWebgl2())return e;const n=[],r=t.width,o=t.height,a=t.components;if(e&&(!Oo(r)||!Oo(o))){const i=t.context.getExtension(&quot;OES_texture_half_float&quot;),s=wo(r),l=wo(o),c=s*l*t.components;for(let u=0;u<e.length;u++)if(null!==e[u]){let d=null;const p=o/l,f=r/s;let g=!1;t.openGLDataType===t.context.FLOAT?d=new Float32Array(c):i&&t.openGLDataType===i.HALF_FLOAT_OES?(d=new Uint16Array(c),g=!0):d=new Uint8Array(c);for(let t=0;t<l;t++){const n=t*s*a,i=t*p;let l=Math.floor(i),c=Math.ceil(i);c>=o&&(c=o-1);const m=i-l,h=1-m;l=l*r*a,c=c*r*a;for(let t=0;t<s;t++){const o=t*a,i=t*f;let s=Math.floor(i),p=Math.ceil(i);p>=r&&(p=r-1);const v=i-s;s*=a,p*=a;for(let t=0;t<a;t++)d[n+o+t]=g?gd.toHalf(gd.fromHalf(e[u][l+s+t])*h*(1-v)+gd.fromHalf(e[u][l+p+t])*h*v+gd.fromHalf(e[u][c+s+t])*m*(1-v)+gd.fromHalf(e[u][c+p+t])*m*v):e[u][l+s+t]*h*(1-v)+e[u][l+p+t]*h*v+e[u][c+s+t]*m*(1-v)+e[u][c+p+t]*m*v}}n.push(d),t.width=s,t.height=l}else n.push(null)}if(0===n.length)for(let t=0;t<e.length;t++)n.push(e[t]);return n}function l(e){return!!t._openGLRenderWindow&&(!t.resizable&&!t.renderable?.getResizable()&&(!!t._openGLRenderWindow.getWebgl2()&&(!(t._openGLRenderWindow.getGLInformations().RENDERER.value.match(/WebKit/gi)&&navigator.platform.match(/Mac/gi)&&r())||e!==Td.UNSIGNED_SHORT&&e!==Td.SHORT)))}function c(n,r){const o=n.getNumberOfComponents(),a=n.getDataType(),i=n.getData(),s=new Array(o),l=new Array(o);for(let e=0;e<o;++e){const[t,r]=n.getRange(e);s[e]=t,l[e]=r}const c=function(e,t,n){const r=new Array(n),o=new Array(n);for(let a=0;a<n;++a)r[a]=e[a],o[a]=t[a]-e[a]||1;return{scale:o,offset:r}}(s,l,o);return function(n,r,o,a){e.getOpenGLDataType(n);const i=function(e,t){for(let n=0;n<e.length;n++){const r=e[n],o=t[n]+r;if(r<-2048||r>2048||o<-2048||o>2048)return!1}return!0}(r,o)||a;let s=!1;if(t._openGLRenderWindow.getWebgl2())s=t.openGLDataType===t.context.FLOAT&&null===t.context.getExtension(&quot;OES_texture_float_linear&quot;)&&i||t.openGLDataType===t.context.HALF_FLOAT;else{const e=t.context.getExtension(&quot;OES_texture_half_float&quot;);s=e&&t.openGLDataType===e.HALF_FLOAT_OES}t.canUseHalfFloat=s&&i}(a,c.offset,c.scale,r),e.useHalfFloat()||e.getOpenGLDataType(a,!0),{numComps:o,dataType:a,data:i,scaleOffsets:c}}e.destroyTexture=()=>{e.deactivate(),t.context&&t.handle&&t.context.deleteTexture(t.handle),t._prevTexParams=null,t.handle=0,t.numberOfDimensions=0,t.target=0,t.components=0,t.width=0,t.height=0,t.depth=0,e.resetFormatAndType()},e.createTexture=()=>{t.handle||(t.handle=t.context.createTexture(),t.target&&(t.context.bindTexture(t.target,t.handle),t.context.texParameteri(t.target,t.context.TEXTURE_MIN_FILTER,e.getOpenGLFilterMode(t.minificationFilter)),t.context.texParameteri(t.target,t.context.TEXTURE_MAG_FILTER,e.getOpenGLFilterMode(t.magnificationFilter)),t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_S,e.getOpenGLWrapMode(t.wrapS)),t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_T,e.getOpenGLWrapMode(t.wrapT)),t._openGLRenderWindow.getWebgl2()&&t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_R,e.getOpenGLWrapMode(t.wrapR)),t.context.bindTexture(t.target,null)))},e.getTextureUnit=()=>t._openGLRenderWindow?t._openGLRenderWindow.getTextureUnitForTexture(e):-1,e.activate=()=>{t._openGLRenderWindow.activateTexture(e),e.bind()},e.deactivate=()=>{t._openGLRenderWindow&&t._openGLRenderWindow.deactivateTexture(e)},e.releaseGraphicsResources=n=>{n&&t.handle&&(n.activateTexture(e),n.deactivateTexture(e),t.context.deleteTexture(t.handle),t._prevTexParams=null,t.handle=0,t.numberOfDimensions=0,t.target=0,t.internalFormat=0,t.format=0,t.openGLDataType=0,t.components=0,t.width=0,t.height=0,t.depth=0,t.allocatedGPUMemoryInBytes=0),t.shaderProgram&&(t.shaderProgram.releaseGraphicsResources(n),t.shaderProgram=null)},e.bind=()=>{t.context.bindTexture(t.target,t.handle),t.autoParameters&&e.getMTime()>t.sendParametersTime.getMTime()&&e.sendParameters()},e.isBound=()=>{let e=!1;if(t.context&&t.handle){let n=0;t.target===t.context.TEXTURE_2D?n=t.context.TEXTURE_BINDING_2D:xd(&quot;impossible case&quot;),e=t.context.getIntegerv(n)===t.handle}return e},e.sendParameters=()=>{t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_S,e.getOpenGLWrapMode(t.wrapS)),t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_T,e.getOpenGLWrapMode(t.wrapT)),t._openGLRenderWindow.getWebgl2()&&t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_R,e.getOpenGLWrapMode(t.wrapR)),t.context.texParameteri(t.target,t.context.TEXTURE_MIN_FILTER,e.getOpenGLFilterMode(t.minificationFilter)),t.context.texParameteri(t.target,t.context.TEXTURE_MAG_FILTER,e.getOpenGLFilterMode(t.magnificationFilter)),t._openGLRenderWindow.getWebgl2()&&(t.context.texParameteri(t.target,t.context.TEXTURE_BASE_LEVEL,t.baseLevel),t.context.texParameteri(t.target,t.context.TEXTURE_MAX_LEVEL,t.maxLevel)),t.sendParametersTime.modified()},e.getInternalFormat=(n,r)=>(t._forceInternalFormat||(t.internalFormat=e.getDefaultInternalFormat(n,r)),t.internalFormat||yd(`Unable to find suitable internal format for T=${n} NC= ${r}`),[t.context.R32F,t.context.RG32F,t.context.RGB32F,t.context.RGBA32F].includes(t.internalFormat)&&!t.context.getExtension(&quot;OES_texture_float_linear&quot;)&&xd(&quot;Failed to load OES_texture_float_linear. Texture filtering is not available for *32F internal formats.&quot;),t.internalFormat),e.getDefaultInternalFormat=(n,o)=>{let a=0;return a=t._openGLRenderWindow.getDefaultTextureInternalFormat(n,o,r(),e.useHalfFloat()),a||(a||(yd(&quot;Unsupported internal texture type!&quot;),yd(`Unable to find suitable internal format for T=${n} NC= ${o}`)),a)},e.useHalfFloat=()=>t.enableUseHalfFloat&&t.canUseHalfFloat,e.setInternalFormat=n=>{t._forceInternalFormat=!0,n!==t.internalFormat&&(t.internalFormat=n,e.modified())},e.getFormat=(n,r)=>(t.format=e.getDefaultFormat(n,r),t.format),e.getDefaultFormat=(e,n)=>{if(t._openGLRenderWindow.getWebgl2())switch(n){case 1:return t.context.RED;case 2:return t.context.RG;case 3:default:return t.context.RGB;case 4:return t.context.RGBA}else switch(n){case 1:return t.context.LUMINANCE;case 2:return t.context.LUMINANCE_ALPHA;case 3:default:return t.context.RGB;case 4:return t.context.RGBA}},e.resetFormatAndType=()=>{t._prevTexParams=null,t.format=0,t.internalFormat=0,t._forceInternalFormat=!1,t.openGLDataType=0},e.getDefaultDataType=n=>{const o=e.useHalfFloat();if(t._openGLRenderWindow.getWebgl2())switch(n){case Td.UNSIGNED_CHAR:return t.context.UNSIGNED_BYTE;case r()&&!o&&Td.SHORT:return t.context.SHORT;case r()&&!o&&Td.UNSIGNED_SHORT:return t.context.UNSIGNED_SHORT;case o&&Td.SHORT:case o&&Td.UNSIGNED_SHORT:return t.context.HALF_FLOAT;case Td.FLOAT:case Td.VOID:default:return t.context.FLOAT}switch(n){case Td.UNSIGNED_CHAR:return t.context.UNSIGNED_BYTE;case Td.FLOAT:case Td.VOID:default:if(t.context.getExtension(&quot;OES_texture_float&quot;)&&t.context.getExtension(&quot;OES_texture_float_linear&quot;))return t.context.FLOAT;{const e=t.context.getExtension(&quot;OES_texture_half_float&quot;);if(e&&t.context.getExtension(&quot;OES_texture_half_float_linear&quot;))return e.HALF_FLOAT_OES}return t.context.UNSIGNED_BYTE}},e.getOpenGLDataType=function(n){let r=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return t.openGLDataType&&!r||(t.openGLDataType=e.getDefaultDataType(n)),t.openGLDataType},e.getShiftAndScale=()=>{let e=0,n=1;switch(t.openGLDataType){case t.context.BYTE:n=127.5,e=n-128;break;case t.context.UNSIGNED_BYTE:n=255,e=0;break;case t.context.SHORT:n=32767.5,e=n-32768;break;case t.context.UNSIGNED_SHORT:n=65536,e=0;break;case t.context.INT:n=2147483647.5,e=n-2147483648;break;case t.context.UNSIGNED_INT:n=4294967295,e=0;case t.context.FLOAT:}return{shift:e,scale:n}},e.getOpenGLFilterMode=e=>{switch(e){case vd.NEAREST:return t.context.NEAREST;case vd.LINEAR:return t.context.LINEAR;case vd.NEAREST_MIPMAP_NEAREST:return t.context.NEAREST_MIPMAP_NEAREST;case vd.NEAREST_MIPMAP_LINEAR:return t.context.NEAREST_MIPMAP_LINEAR;case vd.LINEAR_MIPMAP_NEAREST:return t.context.LINEAR_MIPMAP_NEAREST;case vd.LINEAR_MIPMAP_LINEAR:return t.context.LINEAR_MIPMAP_LINEAR;default:return t.context.NEAREST}},e.getOpenGLWrapMode=e=>{switch(e){case hd.CLAMP_TO_EDGE:return t.context.CLAMP_TO_EDGE;case hd.REPEAT:return t.context.REPEAT;case hd.MIRRORED_REPEAT:return t.context.MIRRORED_REPEAT;default:return t.context.CLAMP_TO_EDGE}},e.updateArrayDataTypeForGL=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]&&arguments[2],o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[];const a=[];let s=t.width*t.height*t.components;r&&(s*=t.depth);const l=!!o.length;if(e!==Td.FLOAT&&t.openGLDataType===t.context.FLOAT)for(let e=0;e<n.length;e++)if(n[e])if(l)a.push(i(n[e],o,Float32Array));else{const t=n[e].length>s?n[e].subarray(0,s):n[e];a.push(new Float32Array(t))}else a.push(null);if(e!==Td.UNSIGNED_CHAR&&t.openGLDataType===t.context.UNSIGNED_BYTE)for(let e=0;e<n.length;e++)if(n[e])if(l)a.push(i(n[e],o,Uint8Array));else{const t=n[e].length>s?n[e].subarray(0,s):n[e];a.push(new Uint8Array(t))}else a.push(null);let c=!1;if(t._openGLRenderWindow.getWebgl2())c=t.openGLDataType===t.context.HALF_FLOAT;else{const e=t.context.getExtension(&quot;OES_texture_half_float&quot;);c=e&&t.openGLDataType===e.HALF_FLOAT_OES}if(c)for(let e=0;e<n.length;e++)if(n[e]){const t=l?i(n[e],o):n[e],r=new Uint16Array(l?t.length:s),c=r.length;for(let e=0;e<c;e++)r[e]=Sd(t[e]);a.push(r)}else a.push(null);if(0===a.length)for(let e=0;e<n.length;e++)a.push(l&&n[e]?i(n[e],o):n[e]);return a},e.create2DFromRaw=function(){let{width:n=Cd(&quot;width&quot;),height:o=Cd(&quot;height&quot;),numComps:a=Cd(&quot;numComps&quot;),dataType:i=Cd(&quot;dataType&quot;),data:c=Cd(&quot;data&quot;),flip:u=!1}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};if(e.getOpenGLDataType(i,!0),e.getInternalFormat(i,a),e.getFormat(i,a),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_2D,t.components=a,t.width=n,t.height=o,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind();const d=[c],p=s(e.updateArrayDataTypeForGL(i,d));return t.context.pixelStorei(t.context.UNPACK_FLIP_Y_WEBGL,u),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(i)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),null!=p[0]&&t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,p[0])):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,p[0]),t.generateMipmap&&t.context.generateMipmap(t.target),u&&t.context.pixelStorei(t.context.UNPACK_FLIP_Y_WEBGL,!1),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*a*t._openGLRenderWindow.getDefaultTextureByteSize(i,r(),e.useHalfFloat()),e.deactivate(),!0},e.createCubeFromRaw=function(){let{width:n=Cd(&quot;width&quot;),height:o=Cd(&quot;height&quot;),numComps:a=Cd(&quot;numComps&quot;),dataType:i=Cd(&quot;dataType&quot;),data:c=Cd(&quot;data&quot;)}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};if(e.getOpenGLDataType(i),e.getInternalFormat(i,a),e.getFormat(i,a),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_CUBE_MAP,t.components=a,t.width=n,t.height=o,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),t.maxLevel=c.length/6-1,e.createTexture(),e.bind();const u=s(e.updateArrayDataTypeForGL(i,c)),d=[];let p=t.width,f=t.height;for(let e=0;e<u.length;e++){e%6==0&&0!==e&&(p/=2,f/=2),d[e]=at(i,f*p*t.components);for(let n=0;n<f;++n){const r=n*p*t.components,o=(f-n-1)*p*t.components;d[e].set(u[e].slice(o,o+p*t.components),r)}}t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(i)&&t.context.texStorage2D(t.target,6,t.internalFormat,t.width,t.height);for(let e=0;e<6;e++){let n=0,r=t.width,o=t.height;for(;r>=1&&o>=1;){let a=null;n<=t.maxLevel&&(a=d[6*n+e]),l(i)?null!=a&&t.context.texSubImage2D(t.context.TEXTURE_CUBE_MAP_POSITIVE_X+e,n,0,0,r,o,t.format,t.openGLDataType,a):t.context.texImage2D(t.context.TEXTURE_CUBE_MAP_POSITIVE_X+e,n,t.internalFormat,r,o,0,t.format,t.openGLDataType,a),n++,r/=2,o/=2}}return t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*a*t._openGLRenderWindow.getDefaultTextureByteSize(i,r(),e.useHalfFloat()),e.deactivate(),!0},e.createDepthFromRaw=function(){let{width:n=Cd(&quot;width&quot;),height:o=Cd(&quot;height&quot;),dataType:a=Cd(&quot;dataType&quot;),data:i=Cd(&quot;data&quot;)}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};return e.getOpenGLDataType(a),t.format=t.context.DEPTH_COMPONENT,t._openGLRenderWindow.getWebgl2()?a===Td.FLOAT?t.internalFormat=t.context.DEPTH_COMPONENT32F:t.internalFormat=t.context.DEPTH_COMPONENT16:t.internalFormat=t.context.DEPTH_COMPONENT,t.internalFormat&&t.format&&t.openGLDataType?(t.target=t.context.TEXTURE_2D,t.components=1,t.width=n,t.height=o,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind(),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(a)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),null!=i&&t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,i)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,i),t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(a,r(),e.useHalfFloat()),e.deactivate(),!0):(bd(&quot;Failed to determine texture parameters.&quot;),!1)},e.create2DFromImage=n=>{if(e.getOpenGLDataType(Td.UNSIGNED_CHAR),e.getInternalFormat(Td.UNSIGNED_CHAR,4),e.getFormat(Td.UNSIGNED_CHAR,4),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_2D,t.components=4,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind();const o=!(t._openGLRenderWindow.getWebgl2()||Oo(n.width)&&Oo(n.height));let a=n,i=n.width,s=n.height,c=!0;const u=window.chrome;if(o||u){const e=new OffscreenCanvas(wo(n.width),wo(n.height));i=e.width,s=e.height;const t=e.getContext(&quot;2d&quot;);t.translate(0,e.height),t.scale(1,-1),t.drawImage(n,0,0,n.width,n.height,0,0,e.width,e.height),a=e,c=!1}return t.width=i,t.height=s,t.context.pixelStorei(t.context.UNPACK_FLIP_Y_WEBGL,c),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(Td.UNSIGNED_CHAR)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,a)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,a),t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(Td.UNSIGNED_CHAR,r(),e.useHalfFloat()),e.deactivate(),!0},e.create2DFromImageBitmap=n=>(e.getOpenGLDataType(Td.UNSIGNED_CHAR),e.getInternalFormat(Td.UNSIGNED_CHAR,4),e.getFormat(Td.UNSIGNED_CHAR,4),t.internalFormat&&t.format&&t.openGLDataType?(t.target=t.context.TEXTURE_2D,t.components=4,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind(),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),t.width=n.width,t.height=n.height,l(Td.UNSIGNED_CHAR)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,n)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,n),t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(Td.UNSIGNED_CHAR,r(),e.useHalfFloat()),e.deactivate(),!0):(bd(&quot;Failed to determine texture parameters.&quot;),!1)),e.create2DFilterableFromRaw=function(){let{width:t=Cd(&quot;width&quot;),height:n=Cd(&quot;height&quot;),numComps:r=Cd(&quot;numComps&quot;),dataType:o=Cd(&quot;dataType&quot;),data:a=Cd(&quot;data&quot;),preferSizeOverAccuracy:i=!1,ranges:s}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};return e.create2DFilterableFromDataArray({width:t,height:n,dataArray:xs.newInstance({numberOfComponents:r,dataType:o,values:a,ranges:s}),preferSizeOverAccuracy:i})},e.create2DFilterableFromDataArray=function(){let{width:t=Cd(&quot;width&quot;),height:n=Cd(&quot;height&quot;),dataArray:r=Cd(&quot;dataArray&quot;),preferSizeOverAccuracy:o=!1}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};const{numComps:a,dataType:i,data:s}=c(r,o);e.create2DFromRaw({width:t,height:n,numComps:a,dataType:i,data:s})},e.updateVolumeInfoForGL=(n,o)=>{let a=!1;const i=e.useHalfFloat();t.volumeInfo?.scale&&t.volumeInfo?.offset||(t.volumeInfo={scale:new Array(o),offset:new Array(o)});for(let e=0;e<o;++e)t.volumeInfo.scale[e]=1,t.volumeInfo.offset[e]=0;if(r()&&!i&&n===Td.SHORT){for(let e=0;e<o;++e)t.volumeInfo.scale[e]=32767;a=!0}if(r()&&!i&&n===Td.UNSIGNED_SHORT){for(let e=0;e<o;++e)t.volumeInfo.scale[e]=65535;a=!0}if(n===Td.UNSIGNED_CHAR){for(let e=0;e<o;++e)t.volumeInfo.scale[e]=255;a=!0}return(n===Td.FLOAT||i&&(n===Td.SHORT||n===Td.UNSIGNED_SHORT))&&(a=!0),a},e.create3DFromRaw=function(){let{width:i=Cd(&quot;width&quot;),height:c=Cd(&quot;height&quot;),depth:u=Cd(&quot;depth&quot;),numComps:d=Cd(&quot;numComps&quot;),dataType:p=Cd(&quot;dataType&quot;),data:f=Cd(&quot;data&quot;),updatedExtents:g=[]}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},m=p,h=f;if(!e.updateVolumeInfoForGL(m,d)&&h){const e=i*c*u,n=structuredClone(t.volumeInfo),r=new Float32Array(e*d);t.volumeInfo.offset=n.offset,t.volumeInfo.scale=n.scale;let o=0;const a=n.scale.map((e=>1/e));for(let t=0;t<e;t++)for(let e=0;e<d;e++)r[o]=(h[o]-n.offset[e])*a[e],o++;m=Td.FLOAT,h=r}if(e.getOpenGLDataType(m),e.getInternalFormat(m,d),e.getFormat(m,d),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_3D,t.components=d,t.width=i,t.height=c,t.depth=u,t.numberOfDimensions=3,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind();const v=g.length>0,T=!v||!ke(t._prevTexParams,n()),y=[h],b=s(e.updateArrayDataTypeForGL(m,y,!0,T?[]:g));if(t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),T)l(m)?(t.context.texStorage3D(t.target,1,t.internalFormat,t.width,t.height,t.depth),null!=b[0]&&t.context.texSubImage3D(t.target,0,0,0,0,t.width,t.height,t.depth,t.format,t.openGLDataType,b[0])):t.context.texImage3D(t.target,0,t.internalFormat,t.width,t.height,t.depth,0,t.format,t.openGLDataType,b[0]),t._prevTexParams=n();else if(v){const e=b[0];let n=0;for(let r=0;r<g.length;r++){const i=g[r],s=o(i),l=a(i),c=new e.constructor(e.buffer,n,l);n+=c.byteLength,t.context.texSubImage3D(t.target,0,i[0],i[2],i[4],s[0],s[1],s[2],t.format,t.openGLDataType,c)}}return t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(m,r(),e.useHalfFloat()),e.deactivate(),!0},e.create3DFilterableFromRaw=function(){let{width:t=Cd(&quot;width&quot;),height:n=Cd(&quot;height&quot;),depth:r=Cd(&quot;depth&quot;),numComps:o=Cd(&quot;numComps&quot;),dataType:a=Cd(&quot;dataType&quot;),data:i=Cd(&quot;data&quot;),preferSizeOverAccuracy:s=!1,ranges:l,updatedExtents:c=[]}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};return e.create3DFilterableFromDataArray({width:t,height:n,depth:r,dataArray:xs.newInstance({numberOfComponents:o,dataType:a,values:i,ranges:l}),preferSizeOverAccuracy:s,updatedExtents:c})},e.create3DFilterableFromDataArray=function(){let{width:n=Cd(&quot;width&quot;),height:r=Cd(&quot;height&quot;),depth:o=Cd(&quot;depth&quot;),dataArray:a=Cd(&quot;dataArray&quot;),preferSizeOverAccuracy:i=!1,updatedExtents:s=[]}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};const{numComps:u,dataType:d,data:p,scaleOffsets:f}=c(a,i),g=[],m=[];for(let e=0;e<u;++e)g[e]=0,m[e]=1;if(t.volumeInfo={scale:m,offset:g,dataComputedScale:f.scale,dataComputedOffset:f.offset,width:n,height:r,depth:o},t._openGLRenderWindow.getWebgl2())return e.create3DFromRaw({width:n,height:r,depth:o,numComps:u,dataType:d,data:p,updatedExtents:s});const h=n*r*o,v=structuredClone(f);let T=(e,t,n,r,o)=>{e[t]=n},y=Td.UNSIGNED_CHAR;if(d===Td.UNSIGNED_CHAR)for(let e=0;e<u;++e)v.offset[e]=0,v.scale[e]=255;else t.context.getExtension(&quot;OES_texture_float&quot;)&&t.context.getExtension(&quot;OES_texture_float_linear&quot;)?(y=Td.FLOAT,T=(e,t,n,r,o)=>{e[t]=(n-r)/o}):(y=Td.UNSIGNED_CHAR,T=(e,t,n,r,o)=>{e[t]=255*(n-r)/o});if(e.getOpenGLDataType(y),e.getInternalFormat(y,u),e.getFormat(y,u),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_2D,t.components=u,t.depth=1,t.numberOfDimensions=2;let b=t.context.getParameter(t.context.MAX_TEXTURE_SIZE);b>4096&&(y===Td.FLOAT||u>=3)&&(b=4096);let x=1,C=1;h>b*b&&(x=Math.ceil(Math.sqrt(h/(b*b))),C=x);let S=Math.sqrt(h)/x;S=wo(S);const A=Math.floor(S*x/n),I=Math.ceil(o/A),w=wo(r*I/C);let O;t.width=S,t.height=w,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind(),t.volumeInfo.xreps=A,t.volumeInfo.yreps=I,t.volumeInfo.xstride=x,t.volumeInfo.ystride=C,t.volumeInfo.offset=v.offset,t.volumeInfo.scale=v.scale;const P=S*w*u;O=y===Td.FLOAT?new Float32Array(P):new Uint8Array(P);let R=0;const M=Math.floor(n/x),E=Math.floor(r/C);for(let e=0;e<I;e++){const a=Math.min(A,o-e*A),i=u*(t.width-a*Math.floor(n/x));for(let t=0;t<E;t++){for(let o=0;o<a;o++){const a=u*((e*A+o)*n*r+C*t*n);for(let e=0;e<M;e++)for(let t=0;t<u;t++)T(O,R,p[a+x*e*u+t],v.offset[t],v.scale[t]),R++}R+=i}}return t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(y)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),null!=O&&t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,O)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,O),e.deactivate(),!0},e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))},e.getMaximumTextureSize=e=>e&&e.isCurrent()?e.getIntegerv(e.MAX_TEXTURE_SIZE):-1,e.enableUseHalfFloat=e=>{t.enableUseHalfFloat=e}}const Id={_openGLRenderWindow:null,_forceInternalFormat:!1,_prevTexParams:null,context:null,handle:0,sendParametersTime:null,textureBuildTime:null,numberOfDimensions:0,target:0,format:0,openGLDataType:0,components:0,width:0,height:0,depth:0,autoParameters:!0,wrapS:hd.CLAMP_TO_EDGE,wrapT:hd.CLAMP_TO_EDGE,wrapR:hd.CLAMP_TO_EDGE,minificationFilter:vd.NEAREST,magnificationFilter:vd.NEAREST,minLOD:-1e3,maxLOD:1e3,baseLevel:0,maxLevel:1e3,generateMipmap:!1,oglNorm16Ext:null,allocatedGPUMemoryInBytes:0,enableUseHalfFloat:!0,canUseHalfFloat:!1};function wd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Id,n),qt.extend(e,t,n),t.sendParametersTime={},ht(t.sendParametersTime,{mtime:0}),t.textureBuildTime={},ht(t.textureBuildTime,{mtime:0}),xt(e,t,[&quot;format&quot;,&quot;openGLDataType&quot;]),Ct(e,t,[&quot;keyMatrixTime&quot;,&quot;minificationFilter&quot;,&quot;magnificationFilter&quot;,&quot;wrapS&quot;,&quot;wrapT&quot;,&quot;wrapR&quot;,&quot;generateMipmap&quot;,&quot;oglNorm16Ext&quot;]),Tt(e,t,[&quot;width&quot;,&quot;height&quot;,&quot;volumeInfo&quot;,&quot;components&quot;,&quot;handle&quot;,&quot;target&quot;,&quot;allocatedGPUMemoryInBytes&quot;]),wt(0,t,[&quot;openGLRenderWindow&quot;]),Ad(e,t)}const Od=Mt(wd,&quot;vtkOpenGLTexture&quot;);var Pd={newInstance:Od,extend:wd,...dd};Jt(&quot;vtkTexture&quot;,Od);var Rd=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkPolyDataVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\nattribute vec4 vertexMC;\\n\\n// frag position in VC\\n//VTK::PositionVC::Dec\\n\\n// optional normal declaration\\n//VTK::Normal::Dec\\n\\n// extra lighting parameters\\n//VTK::Light::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// material property values\\n//VTK::Color::Dec\\n\\n// clipping plane vars\\n//VTK::Clip::Dec\\n\\n// camera and actor matrix values\\n//VTK::Camera::Dec\\n\\n// Apple Bug\\n//VTK::PrimID::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\nvoid main()\\n{\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Clip::Impl\\n\\n  //VTK::PrimID::Impl\\n\\n  //VTK::PositionVC::Impl\\n\\n  //VTK::Light::Impl\\n\\n  //VTK::Picking::Impl\\n}\\n&quot;,Md=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkPolyDataFS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// Template for the polydata mappers fragment shader\\n\\nuniform int PrimitiveIDOffset;\\n\\n// VC position of this fragment\\n//VTK::PositionVC::Dec\\n\\n// optional color passed in from the vertex shader, vertexColor\\n//VTK::Color::Dec\\n\\n// optional surface normal declaration\\n//VTK::Normal::Dec\\n\\n// extra lighting parameters\\n//VTK::Light::Dec\\n\\n// define vtkImageLabelOutlineOn\\n//VTK::ImageLabelOutlineOn\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\n// Depth Peeling Support\\n//VTK::DepthPeeling::Dec\\n\\n// clipping plane vars\\n//VTK::Clip::Dec\\n\\n// label outline \\n//VTK::LabelOutline::Dec\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\n// Apple Bug\\n//VTK::PrimID::Dec\\n\\n// handle coincident offsets\\n//VTK::Coincident::Dec\\n\\n//VTK::ZBuffer::Dec\\n\\n//VTK::LabelOutlineHelperFunction\\n\\nvoid main()\\n{\\n  // VC position of this fragment. This should not branch/return/discard.\\n  //VTK::PositionVC::Impl\\n\\n  // Place any calls that require uniform flow (e.g. dFdx) here.\\n  //VTK::UniformFlow::Impl\\n\\n  // Set gl_FragDepth here (gl_FragCoord.z by default)\\n  //VTK::Depth::Impl\\n\\n  // Early depth peeling abort:\\n  //VTK::DepthPeeling::PreColor\\n\\n  // Apple Bug\\n  //VTK::PrimID::Impl\\n\\n  //VTK::Clip::Impl\\n\\n  //VTK::Color::Impl\\n\\n  // Generate the normal if we are not passed in one\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Light::Impl\\n\\n  if (gl_FragData[0].a <= 0.0)\\n    {\\n    discard;\\n    }\\n\\n  //VTK::DepthPeeling::Impl\\n\\n  //VTK::Picking::Impl\\n\\n  // handle coincident offsets\\n  //VTK::Coincident::Impl\\n\\n  //VTK::ZBuffer::Impl\\n\\n  //VTK::RenderPassFragmentShader::Impl\\n}\\n&quot;,Ed=function(e,t){e.replaceShaderCoincidentOffset=(n,r,o)=>{const a=e.getCoincidentParameters(r,o);if(a&&(0!==a.factor||0!==a.offset)){let e=n.Fragment;e=td.substitute(e,&quot;//VTK::Coincident::Dec&quot;,[&quot;uniform float cfactor;&quot;,&quot;uniform float coffset;&quot;]).result,t.context.getExtension(&quot;EXT_frag_depth&quot;)&&(0!==a.factor?(e=td.substitute(e,&quot;//VTK::UniformFlow::Impl&quot;,[&quot;float cscale = length(vec2(dFdx(gl_FragCoord.z),dFdy(gl_FragCoord.z)));&quot;,&quot;//VTK::UniformFlow::Impl&quot;],!1).result,e=td.substitute(e,&quot;//VTK::Depth::Impl&quot;,&quot;gl_FragDepthEXT = gl_FragCoord.z + cfactor*cscale + 0.000016*coffset;&quot;).result):e=td.substitute(e,&quot;//VTK::Depth::Impl&quot;,&quot;gl_FragDepthEXT = gl_FragCoord.z + 0.000016*coffset;&quot;).result),t._openGLRenderWindow.getWebgl2()&&(0!==a.factor?(e=td.substitute(e,&quot;//VTK::UniformFlow::Impl&quot;,[&quot;float cscale = length(vec2(dFdx(gl_FragCoord.z),dFdy(gl_FragCoord.z)));&quot;,&quot;//VTK::UniformFlow::Impl&quot;],!1).result,e=td.substitute(e,&quot;//VTK::Depth::Impl&quot;,&quot;gl_FragDepth = gl_FragCoord.z + cfactor*cscale + 0.000016*coffset;&quot;).result):e=td.substitute(e,&quot;//VTK::Depth::Impl&quot;,&quot;gl_FragDepth = gl_FragCoord.z + 0.000016*coffset;&quot;).result),n.Fragment=e}}},Vd=function(e,t){e.applyShaderReplacements=(e,t,n)=>{let r=null;if(t&&(r=t.ShaderReplacements),r)for(let t=0;t<r.length;t++){const o=r[t];if(n&&o.replaceFirst||!n&&!o.replaceFirst){const t=o.shaderType,n=e[t],r=td.substitute(n,o.originalValue,o.replacementValue,o.replaceAll);e[t]=r.result}}},e.buildShaders=(n,r,o)=>{e.getReplacedShaderTemplate(n,r,o),t.lastRenderPassShaderReplacement=t.currentRenderPass?t.currentRenderPass.getShaderReplacement():null,t.lastRenderPassShaderReplacement&&t.lastRenderPassShaderReplacement(n);const a=t.renderable.getViewSpecificProperties().OpenGL;e.applyShaderReplacements(n,a,!0),e.replaceShaderValues(n,r,o),e.applyShaderReplacements(n,a)},e.getReplacedShaderTemplate=(n,r,o)=>{const a=t.renderable.getViewSpecificProperties().OpenGL;e.getShaderTemplate(n,r,o);let i=n.Vertex;if(a){const e=a.VertexShaderCode;void 0!==e&&&quot;&quot;!==e&&(i=e)}n.Vertex=i;let s=n.Fragment;if(a){const e=a.FragmentShaderCode;void 0!==e&&&quot;&quot;!==e&&(s=e)}n.Fragment=s;let l=n.Geometry;if(a){const e=a.GeometryShaderCode;void 0!==e&&(l=e)}n.Geometry=l}};const{FieldAssociations:Dd}=Us,{primTypes:Ld}=ld,{Representation:Bd,Shading:Nd}=os,{ScalarMode:Fd}=Gl,{Filter:_d,Wrap:kd}=Pd,{vtkErrorMacro:Gd}=Ht,Ud={type:&quot;StartEvent&quot;},zd={type:&quot;EndEvent&quot;},{CoordinateSystem:Wd}=Ki;const Hd={context:null,VBOBuildTime:0,VBOBuildString:null,primitives:null,primTypes:null,shaderRebuildString:null,tmpMat4:null,ambientColor:[],diffuseColor:[],specularColor:[],lightColor:[],lightDirection:[],lastHaveSeenDepthRequest:!1,haveSeenDepthRequest:!1,lastSelectionState:Al.MIN_KNOWN_PASS-1,selectionStateChanged:null,selectionWebGLIdsToVTKIds:null,pointPicking:!1};function jd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Hd,n),qt.extend(e,t,n),Ed(e,t,n),Vd(e,t,n),t.primitives=[],t.primTypes=Ld,t.tmpMat3=fe(new Float64Array(9)),t.tmpMat4=m(new Float64Array(16));for(let e=Ld.Start;e<Ld.End;e++)t.primitives[e]=ld.newInstance(),t.primitives[e].setPrimitiveType(e),t.primitives[e].set({lastLightComplexity:0,lastLightCount:0,lastSelectionPass:!1},!0);Ct(e,t,[&quot;context&quot;]),t.VBOBuildTime={},ht(t.VBOBuildTime,{mtime:0}),t.selectionStateChanged={},ht(t.selectionStateChanged,{mtime:0}),function(e,t){function n(e,t,n){return t.identity(n),e.reduce(((e,n,r)=>0===r?n?t.copy(e,n):t.identity(e):n?t.multiply(e,e,n):e),n)}t.classHierarchy.push(&quot;vtkOpenGLPolyDataMapper&quot;),e.buildPass=n=>{n&&(t.currentRenderPass=null,t.openGLActor=e.getFirstAncestorOfType(&quot;vtkOpenGLActor&quot;),t._openGLRenderer=t.openGLActor.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t.openGLCamera=t._openGLRenderer.getViewNodeFor(t._openGLRenderer.getRenderable().getActiveCamera()))},e.translucentPass=(n,r)=>{n&&(t.currentRenderPass=r,e.render())},e.zBufferPass=n=>{n&&(t.haveSeenDepthRequest=!0,t.renderDepth=!0,e.render(),t.renderDepth=!1)},e.opaqueZBufferPass=t=>e.zBufferPass(t),e.opaquePass=t=>{t&&e.render()},e.render=()=>{const n=t._openGLRenderWindow.getContext();if(t.context!==n){t.context=n;for(let e=Ld.Start;e<Ld.End;e++)t.primitives[e].setOpenGLRenderWindow(t._openGLRenderWindow)}const r=t.openGLActor.getRenderable(),o=t._openGLRenderer.getRenderable();e.renderPiece(o,r)},e.getShaderTemplate=(e,t,n)=>{e.Vertex=Rd,e.Fragment=Md,e.Geometry=&quot;&quot;},e.replaceShaderColor=(e,n,r)=>{let o=e.Vertex,a=e.Geometry,i=e.Fragment;const s=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);let l=[&quot;uniform float ambient;&quot;,&quot;uniform float diffuse;&quot;,&quot;uniform float specular;&quot;,&quot;uniform float opacityUniform; // the fragment opacity&quot;,&quot;uniform vec3 ambientColorUniform;&quot;,&quot;uniform vec3 diffuseColorUniform;&quot;];s&&(l=l.concat([&quot;uniform vec3 specularColorUniform;&quot;,&quot;uniform float specularPowerUniform;&quot;]));let c=[&quot;vec3 ambientColor;&quot;,&quot;  vec3 diffuseColor;&quot;,&quot;  float opacity;&quot;];s&&(c=c.concat([&quot;  vec3 specularColor;&quot;,&quot;  float specularPower;&quot;])),c=c.concat([&quot;  ambientColor = ambientColorUniform;&quot;,&quot;  diffuseColor = diffuseColorUniform;&quot;,&quot;  opacity = opacityUniform;&quot;]),s&&(c=c.concat([&quot;  specularColor = specularColorUniform;&quot;,&quot;  specularPower = specularPowerUniform;&quot;])),0===t.lastBoundBO.getCABO().getColorComponents()||t.drawingEdges||(l=l.concat([&quot;varying vec4 vertexColorVSOutput;&quot;]),o=td.substitute(o,&quot;//VTK::Color::Dec&quot;,[&quot;attribute vec4 scalarColor;&quot;,&quot;varying vec4 vertexColorVSOutput;&quot;]).result,o=td.substitute(o,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorVSOutput =  scalarColor;&quot;]).result,a=td.substitute(a,&quot;//VTK::Color::Dec&quot;,[&quot;in vec4 vertexColorVSOutput[];&quot;,&quot;out vec4 vertexColorGSOutput;&quot;]).result,a=td.substitute(a,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorGSOutput = vertexColorVSOutput[i];&quot;]).result),0===t.lastBoundBO.getCABO().getColorComponents()||t.drawingEdges?(t.renderable.getAreScalarsMappedFromCells()||t.renderable.getInterpolateScalarsBeforeMapping())&&t.renderable.getColorCoordinates()&&!t.drawingEdges?i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,c.concat([&quot;  vec4 texColor = texture2D(texture1, tcoordVCVSOutput.st);&quot;,&quot;  diffuseColor = texColor.rgb;&quot;,&quot;  ambientColor = texColor.rgb;&quot;,&quot;  opacity = opacity*texColor.a;&quot;])).result:(r.getBackfaceProperty()&&!t.drawingEdges&&(l=l.concat([&quot;uniform float opacityUniformBF; // the fragment opacity&quot;,&quot;uniform float ambientIntensityBF; // the material ambient&quot;,&quot;uniform float diffuseIntensityBF; // the material diffuse&quot;,&quot;uniform vec3 ambientColorUniformBF; // ambient material color&quot;,&quot;uniform vec3 diffuseColorUniformBF; // diffuse material color&quot;]),s?(l=l.concat([&quot;uniform float specularIntensityBF; // the material specular intensity&quot;,&quot;uniform vec3 specularColorUniformBF; // intensity weighted color&quot;,&quot;uniform float specularPowerUniformBF;&quot;]),c=c.concat([&quot;if (gl_FrontFacing == false) {&quot;,&quot;  ambientColor = ambientIntensityBF * ambientColorUniformBF;&quot;,&quot;  diffuseColor = diffuseIntensityBF * diffuseColorUniformBF;&quot;,&quot;  specularColor = specularIntensityBF * specularColorUniformBF;&quot;,&quot;  specularPower = specularPowerUniformBF;&quot;,&quot;  opacity = opacityUniformBF; }&quot;])):c=c.concat([&quot;if (gl_FrontFacing == false) {&quot;,&quot;  ambientColor = ambientIntensityBF * ambientColorUniformBF;&quot;,&quot;  diffuseColor = diffuseIntensityBF * diffuseColorUniformBF;&quot;,&quot;  opacity = opacityUniformBF; }&quot;])),t.haveCellScalars&&!t.drawingEdges&&(l=l.concat([&quot;uniform samplerBuffer texture1;&quot;])),i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,c).result):i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,c.concat([&quot;  diffuseColor = vertexColorVSOutput.rgb;&quot;,&quot;  ambientColor = vertexColorVSOutput.rgb;&quot;,&quot;  opacity = opacity*vertexColorVSOutput.a;&quot;])).result,i=td.substitute(i,&quot;//VTK::Color::Dec&quot;,l).result,e.Vertex=o,e.Geometry=a,e.Fragment=i},e.replaceShaderLight=(e,n,r)=>{let o=e.Fragment;const a=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;),i=t.lastBoundBO.getReferenceByName(&quot;lastLightCount&quot;);let s=[];switch(a){case 0:o=td.substitute(o,&quot;//VTK::Light::Impl&quot;,[&quot;  gl_FragData[0] = vec4(ambientColor * ambient + diffuseColor * diffuse, opacity);&quot;,&quot;  //VTK::Light::Impl&quot;],!1).result;break;case 1:o=td.substitute(o,&quot;//VTK::Light::Impl&quot;,[&quot;  float df = max(0.0, normalVCVSOutput.z);&quot;,&quot;  float sf = pow(df, specularPower);&quot;,&quot;  vec3 diffuseL = df * diffuseColor;&quot;,&quot;  vec3 specularL = sf * specularColor;&quot;,&quot;  gl_FragData[0] = vec4(ambientColor * ambient + diffuseL * diffuse + specularL * specular, opacity);&quot;,&quot;  //VTK::Light::Impl&quot;],!1).result;break;case 2:for(let e=0;e<i;++e)s=s.concat([`uniform vec3 lightColor${e};`,`uniform vec3 lightDirectionVC${e}; // normalized`,`uniform vec3 lightHalfAngleVC${e}; // normalized`]);o=td.substitute(o,&quot;//VTK::Light::Dec&quot;,s).result,s=[&quot;vec3 diffuseL = vec3(0,0,0);&quot;,&quot;  vec3 specularL = vec3(0,0,0);&quot;,&quot;  float df;&quot;];for(let e=0;e<i;++e)s=s.concat([`  df = max(0.0, dot(normalVCVSOutput, -lightDirectionVC${e}));`,`  diffuseL += ((df) * lightColor${e});`,`  if (dot(normalVCVSOutput, lightDirectionVC${e}) < 0.0)`,&quot;    {&quot;,`    float sf = sign(df)*pow(max(1e-5,\\n                                              dot(reflect(lightDirectionVC${e},normalVCVSOutput),\\n                                                  normalize(-vertexVC.xyz))),\\n                                         specularPower);`,`    specularL += (sf * lightColor${e});`,&quot;    }&quot;]);s=s.concat([&quot;  diffuseL = diffuseL * diffuseColor;&quot;,&quot;  specularL = specularL * specularColor;&quot;,&quot;  gl_FragData[0] = vec4(ambientColor * ambient + diffuseL * diffuse + specularL * specular, opacity);&quot;,&quot;  //VTK::Light::Impl&quot;]),o=td.substitute(o,&quot;//VTK::Light::Impl&quot;,s,!1).result;break;case 3:for(let e=0;e<i;++e)s=s.concat([`uniform vec3 lightColor${e};`,`uniform vec3 lightDirectionVC${e}; // normalized`,`uniform vec3 lightHalfAngleVC${e}; // normalized`,`uniform vec3 lightPositionVC${e};`,`uniform vec3 lightAttenuation${e};`,`uniform float lightConeAngle${e};`,`uniform float lightExponent${e};`,`uniform int lightPositional${e};`]);o=td.substitute(o,&quot;//VTK::Light::Dec&quot;,s).result,s=[&quot;vec3 diffuseL = vec3(0,0,0);&quot;,&quot;  vec3 specularL = vec3(0,0,0);&quot;,&quot;  vec3 vertLightDirectionVC;&quot;,&quot;  float attenuation;&quot;,&quot;  float df;&quot;];for(let e=0;e<i;++e)s=s.concat([&quot;  attenuation = 1.0;&quot;,`  if (lightPositional${e} == 0)`,&quot;    {&quot;,`      vertLightDirectionVC = lightDirectionVC${e};`,&quot;    }&quot;,&quot;  else&quot;,&quot;    {&quot;,`    vertLightDirectionVC = vertexVC.xyz - lightPositionVC${e};`,&quot;    float distanceVC = length(vertLightDirectionVC);&quot;,&quot;    vertLightDirectionVC = normalize(vertLightDirectionVC);&quot;,&quot;    attenuation = 1.0 /&quot;,`      (lightAttenuation${e}.x`,`       + lightAttenuation${e}.y * distanceVC`,`       + lightAttenuation${e}.z * distanceVC * distanceVC);`,&quot;    // per OpenGL standard cone angle is 90 or less for a spot light&quot;,`    if (lightConeAngle${e} <= 90.0)`,&quot;      {&quot;,`      float coneDot = dot(vertLightDirectionVC, lightDirectionVC${e});`,&quot;      // if inside the cone&quot;,`      if (coneDot >= cos(radians(lightConeAngle${e})))`,&quot;        {&quot;,`        attenuation = attenuation * pow(coneDot, lightExponent${e});`,&quot;        }&quot;,&quot;      else&quot;,&quot;        {&quot;,&quot;        attenuation = 0.0;&quot;,&quot;        }&quot;,&quot;      }&quot;,&quot;    }&quot;,&quot;    df = max(0.0, attenuation*dot(normalVCVSOutput, -vertLightDirectionVC));&quot;,`    diffuseL += ((df) * lightColor${e});`,&quot;    if (dot(normalVCVSOutput, vertLightDirectionVC) < 0.0)&quot;,&quot;      {&quot;,`      float sf = sign(df)*attenuation*pow(max(1e-5,\\n                                                           dot(reflect(lightDirectionVC${e},\\n                                                                       normalVCVSOutput),\\n                                                               normalize(-vertexVC.xyz))),\\n                                                       specularPower);`,`    specularL += ((sf) * lightColor${e});`,&quot;    }&quot;]);s=s.concat([&quot;  diffuseL = diffuseL * diffuseColor;&quot;,&quot;  specularL = specularL * specularColor;&quot;,&quot;  gl_FragData[0] = vec4(ambientColor * ambient + diffuseL * diffuse + specularL * specular, opacity);&quot;,&quot;  //VTK::Light::Impl&quot;]),o=td.substitute(o,&quot;//VTK::Light::Impl&quot;,s,!1).result;break;default:Gd(&quot;bad light complexity&quot;)}e.Fragment=o},e.replaceShaderNormal=(e,n,r)=>{if(t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;)>0){let n=e.Vertex,o=e.Geometry,a=e.Fragment;t.lastBoundBO.getCABO().getNormalOffset()?(n=td.substitute(n,&quot;//VTK::Normal::Dec&quot;,[&quot;attribute vec3 normalMC;&quot;,&quot;uniform mat3 normalMatrix;&quot;,&quot;varying vec3 normalVCVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::Normal::Impl&quot;,[&quot;normalVCVSOutput = normalMatrix * normalMC;&quot;]).result,o=td.substitute(o,&quot;//VTK::Normal::Dec&quot;,[&quot;in vec3 normalVCVSOutput[];&quot;,&quot;out vec3 normalVCGSOutput;&quot;]).result,o=td.substitute(o,&quot;//VTK::Normal::Impl&quot;,[&quot;normalVCGSOutput = normalVCVSOutput[i];&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Dec&quot;,[&quot;varying vec3 normalVCVSOutput;&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Impl&quot;,[&quot;vec3 normalVCVSOutput = normalize(normalVCVSOutput);&quot;,&quot;  if (gl_FrontFacing == false) { normalVCVSOutput = -normalVCVSOutput; }&quot;]).result):t.haveCellNormals?(a=td.substitute(a,&quot;//VTK::Normal::Dec&quot;,[&quot;uniform mat3 normalMatrix;&quot;,&quot;uniform samplerBuffer textureN;&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Impl&quot;,[&quot;vec3 normalVCVSOutput = normalize(normalMatrix *&quot;,&quot;    texelFetchBuffer(textureN, gl_PrimitiveID + PrimitiveIDOffset).xyz);&quot;,&quot;  if (gl_FrontFacing == false) { normalVCVSOutput = -normalVCVSOutput; }&quot;]).result):t.lastBoundBO.getOpenGLMode(r.getProperty().getRepresentation())===t.context.LINES?(a=td.substitute(a,&quot;//VTK::UniformFlow::Impl&quot;,[&quot;  vec3 fdx = dFdx(vertexVC.xyz);&quot;,&quot;  vec3 fdy = dFdy(vertexVC.xyz);&quot;,&quot;  //VTK::UniformFlow::Impl&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Impl&quot;,[&quot;vec3 normalVCVSOutput;&quot;,&quot;  if (abs(fdx.x) > 0.0)&quot;,&quot;    { fdx = normalize(fdx); normalVCVSOutput = normalize(cross(vec3(fdx.y, -fdx.x, 0.0), fdx)); }&quot;,&quot;  else { fdy = normalize(fdy); normalVCVSOutput = normalize(cross(vec3(fdy.y, -fdy.x, 0.0), fdy));}&quot;]).result):(a=td.substitute(a,&quot;//VTK::Normal::Dec&quot;,[&quot;uniform int cameraParallel;&quot;]).result,a=td.substitute(a,&quot;//VTK::UniformFlow::Impl&quot;,[&quot;  vec3 fdx = dFdx(vertexVC.xyz);&quot;,&quot;  vec3 fdy = dFdy(vertexVC.xyz);&quot;,&quot;  //VTK::UniformFlow::Impl&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Impl&quot;,[&quot;  fdx = normalize(fdx);&quot;,&quot;  fdy = normalize(fdy);&quot;,&quot;  vec3 normalVCVSOutput = normalize(cross(fdx,fdy));&quot;,&quot;  if (cameraParallel == 1 && normalVCVSOutput.z < 0.0) { normalVCVSOutput = -1.0*normalVCVSOutput; }&quot;,&quot;  if (cameraParallel == 0 && dot(normalVCVSOutput,vertexVC.xyz) > 0.0) { normalVCVSOutput = -1.0*normalVCVSOutput; }&quot;]).result),e.Vertex=n,e.Geometry=o,e.Fragment=a}},e.replaceShaderPositionVC=(e,n,r)=>{t.lastBoundBO.replaceShaderPositionVC(e,n,r);let o=e.Vertex,a=e.Geometry,i=e.Fragment;t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;)>0?(o=td.substitute(o,&quot;//VTK::PositionVC::Dec&quot;,[&quot;varying vec4 vertexVCVSOutput;&quot;]).result,o=td.substitute(o,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vertexVCVSOutput = MCVCMatrix * vertexMC;&quot;,&quot;  gl_Position = MCPCMatrix * vertexMC;&quot;]).result,o=td.substitute(o,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Dec&quot;,[&quot;in vec4 vertexVCVSOutput[];&quot;,&quot;out vec4 vertexVCGSOutput;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vertexVCGSOutput = vertexVCVSOutput[i];&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Dec&quot;,[&quot;varying vec4 vertexVCVSOutput;&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vec4 vertexVC = vertexVCVSOutput;&quot;]).result):(o=td.substitute(o,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;]).result,o=td.substitute(o,&quot;//VTK::PositionVC::Impl&quot;,[&quot;  gl_Position = MCPCMatrix * vertexMC;&quot;]).result),e.Vertex=o,e.Geometry=a,e.Fragment=i},e.replaceShaderTCoord=(e,n,r)=>{if(t.lastBoundBO.getCABO().getTCoordOffset()){let n=e.Vertex,r=e.Geometry,o=e.Fragment;if(t.drawingEdges)return;n=td.substitute(n,&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCVSOutput = tcoordMC;&quot;).result;const a=t.openGLActor.getActiveTextures();let i=2,s=2;if(a&&a.length>0&&(i=a[0].getComponents(),a[0].getTarget()===t.context.TEXTURE_CUBE_MAP&&(s=3)),t.renderable.getColorTextureMap()&&(i=t.renderable.getColorTextureMap().getPointData().getScalars().getNumberOfComponents(),s=2),2===s){if(n=td.substitute(n,&quot;//VTK::TCoord::Dec&quot;,&quot;attribute vec2 tcoordMC; varying vec2 tcoordVCVSOutput;&quot;).result,r=td.substitute(r,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec2 tcoordVCVSOutput[];&quot;,&quot;out vec2 tcoordVCGSOutput;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCGSOutput = tcoordVCVSOutput[i];&quot;).result,o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;varying vec2 tcoordVCVSOutput;&quot;,&quot;uniform sampler2D texture1;&quot;]).result,a&&a.length>=1)switch(i){case 1:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.r;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.r;&quot;]).result;break;case 2:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.r;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.r;&quot;,&quot;  opacity = opacity * tcolor.g;&quot;]).result;break;default:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.rgb;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.rgb;&quot;,&quot;  opacity = opacity * tcolor.a;&quot;]).result}}else switch(n=td.substitute(n,&quot;//VTK::TCoord::Dec&quot;,&quot;attribute vec3 tcoordMC; varying vec3 tcoordVCVSOutput;&quot;).result,r=td.substitute(r,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec3 tcoordVCVSOutput[];&quot;,&quot;out vec3 tcoordVCGSOutput;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCGSOutput = tcoordVCVSOutput[i];&quot;).result,o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;varying vec3 tcoordVCVSOutput;&quot;,&quot;uniform samplerCube texture1;&quot;]).result,i){case 1:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.r;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.r;&quot;]).result;break;case 2:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.r;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.r;&quot;,&quot;  opacity = opacity * tcolor.g;&quot;]).result;break;default:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.rgb;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.rgb;&quot;,&quot;  opacity = opacity * tcolor.a;&quot;]).result}e.Vertex=n,e.Geometry=r,e.Fragment=o}},e.replaceShaderClip=(e,n,r)=>{let o=e.Vertex,a=e.Fragment;if(t.renderable.getNumberOfClippingPlanes()){const e=t.renderable.getNumberOfClippingPlanes();o=td.substitute(o,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,`uniform vec4 clipPlanes[${e}];`,`varying float clipDistancesVSOutput[${e}];`]).result,o=td.substitute(o,&quot;//VTK::Clip::Impl&quot;,[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], vertexMC);&quot;,&quot;    }&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,`varying float clipDistancesVSOutput[${e}];`]).result,a=td.substitute(a,&quot;//VTK::Clip::Impl&quot;,[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    if (clipDistancesVSOutput[planeNum] < 0.0) discard;&quot;,&quot;    }&quot;]).result}e.Vertex=o,e.Fragment=a},e.getCoincidentParameters=(e,n)=>{let r={factor:0,offset:0};const o=n.getProperty();if(t.renderable.getResolveCoincidentTopology()==gl.PolygonOffset||o.getEdgeVisibility()&&o.getRepresentation()===Bd.SURFACE){const e=t.lastBoundBO.getPrimitiveType();e===Ld.Points||o.getRepresentation()===Bd.POINTS?r=t.renderable.getCoincidentTopologyPointOffsetParameter():e===Ld.Lines||o.getRepresentation()===Bd.WIREFRAME?r=t.renderable.getCoincidentTopologyLineOffsetParameters():e!==Ld.Tris&&e!==Ld.TriStrips||(r=t.renderable.getCoincidentTopologyPolygonOffsetParameters()),e!==Ld.TrisEdges&&e!==Ld.TriStripsEdges||(r=t.renderable.getCoincidentTopologyPolygonOffsetParameters(),r.factor/=2,r.offset/=2)}const a=t._openGLRenderer.getSelector();return a&&a.getFieldAssociation()===Dd.FIELD_ASSOCIATION_POINTS&&(r.offset-=2),r},e.replaceShaderPicking=(e,n,r)=>{let o=e.Fragment,a=e.Vertex;if(o=td.substitute(o,&quot;//VTK::Picking::Dec&quot;,[&quot;uniform int picking;&quot;,&quot;//VTK::Picking::Dec&quot;]).result,t._openGLRenderer.getSelector()){switch(t.lastSelectionState!==Al.ID_LOW24&&t.lastSelectionState!==Al.ID_HIGH24||(a=td.substitute(a,&quot;//VTK::Picking::Dec&quot;,[&quot;flat out int vertexIDVSOutput;\\n&quot;,&quot;uniform int VertexIDOffset;\\n&quot;]).result,a=td.substitute(a,&quot;//VTK::Picking::Impl&quot;,&quot;  vertexIDVSOutput = gl_VertexID + VertexIDOffset;\\n&quot;).result,o=td.substitute(o,&quot;//VTK::Picking::Dec&quot;,&quot;flat in int vertexIDVSOutput;\\n&quot;).result,o=td.substitute(o,&quot;//VTK::Picking::Impl&quot;,[&quot;  int idx = vertexIDVSOutput;&quot;,&quot;//VTK::Picking::Impl&quot;]).result),t.lastSelectionState){case Al.ID_LOW24:o=td.substitute(o,&quot;//VTK::Picking::Impl&quot;,&quot;  gl_FragData[0] = vec4(float(idx%256)/255.0, float((idx/256)%256)/255.0, float((idx/65536)%256)/255.0, 1.0);&quot;).result;break;case Al.ID_HIGH24:o=td.substitute(o,&quot;//VTK::Picking::Impl&quot;,&quot;  gl_FragData[0] = vec4(float((idx/16777216)%256)/255.0, 0.0, 0.0, 1.0);&quot;).result;break;default:o=td.substitute(o,&quot;//VTK::Picking::Dec&quot;,&quot;uniform vec3 mapperIndex;&quot;).result,o=td.substitute(o,&quot;//VTK::Picking::Impl&quot;,&quot;  gl_FragData[0] = picking != 0 ? vec4(mapperIndex,1.0) : gl_FragData[0];&quot;).result}e.Fragment=o,e.Vertex=a}},e.replaceShaderValues=(n,r,o)=>{if(e.replaceShaderColor(n,r,o),e.replaceShaderNormal(n,r,o),e.replaceShaderLight(n,r,o),e.replaceShaderTCoord(n,r,o),e.replaceShaderPicking(n,r,o),e.replaceShaderClip(n,r,o),e.replaceShaderCoincidentOffset(n,r,o),e.replaceShaderPositionVC(n,r,o),t.haveSeenDepthRequest){let e=n.Fragment;e=td.substitute(e,&quot;//VTK::ZBuffer::Dec&quot;,&quot;uniform int depthRequest;&quot;).result,e=td.substitute(e,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float iz = floor(gl_FragCoord.z*65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result,n.Fragment=e}},e.getNeedToRebuildShaders=(e,n,r)=>{let o=0,a=0;const i=e.getPrimitiveType(),s=t.currentInput;let l=!1;const c=s.getPointData().getNormals(),u=s.getCellData().getNormals(),d=r.getProperty().getInterpolation()===Nd.FLAT,p=r.getProperty().getRepresentation(),f=e.getOpenGLMode(p,i);if(f===t.context.TRIANGLES||u&&!c||!d&&c?l=!0:d||f!==t.context.LINES||(l=!0),r.getProperty().getLighting()&&l){o=0;const e=n.getLightsByReference();for(let t=0;t<e.length;++t){const n=e[t];n.getSwitch()>0&&(a++,0===o&&(o=1)),1===o&&(a>1||1!==n.getIntensity()||!n.lightTypeIsHeadLight())&&(o=2),o<3&&n.getPositional()&&(o=3)}}let g=!1;const m=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;),h=t.lastBoundBO.getReferenceByName(&quot;lastLightCount&quot;);return m===o&&h===a||(t.lastBoundBO.set({lastLightComplexity:o},!0),t.lastBoundBO.set({lastLightCount:a},!0),g=!0),(!t.currentRenderPass&&t.lastRenderPassShaderReplacement||t.currentRenderPass&&t.currentRenderPass.getShaderReplacement()!==t.lastRenderPassShaderReplacement)&&(g=!0),!!(t.lastHaveSeenDepthRequest!==t.haveSeenDepthRequest||e.getShaderSourceTime().getMTime()<t.renderable.getMTime()||e.getShaderSourceTime().getMTime()<t.currentInput.getMTime()||e.getShaderSourceTime().getMTime()<t.selectionStateChanged.getMTime()||g)&&(t.lastHaveSeenDepthRequest=t.haveSeenDepthRequest,!0)},e.invokeShaderCallbacks=(e,n,r)=>{const o=t.renderable.getViewSpecificProperties().ShadersCallbacks;o&&o.forEach((t=>{t.callback(t.userData,e,n,r)}))},e.setMapperShaderParameters=(n,r,o)=>{if(n.getProgram().isUniformUsed(&quot;PrimitiveIDOffset&quot;)&&n.getProgram().setUniformi(&quot;PrimitiveIDOffset&quot;,t.primitiveIDOffset),n.getProgram().isUniformUsed(&quot;VertexIDOffset&quot;)&&n.getProgram().setUniformi(&quot;VertexIDOffset&quot;,t.vertexIDOffset),n.getCABO().getElementCount()&&(t.VBOBuildTime.getMTime()>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())){const e=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);n.getProgram().isAttributeUsed(&quot;vertexMC&quot;)&&(n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;vertexMC&quot;,n.getCABO().getVertexOffset(),n.getCABO().getStride(),t.context.FLOAT,3,!1)||Gd(&quot;Error setting vertexMC in shader VAO.&quot;)),n.getProgram().isAttributeUsed(&quot;normalMC&quot;)&&n.getCABO().getNormalOffset()&&e>0?n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;normalMC&quot;,n.getCABO().getNormalOffset(),n.getCABO().getStride(),t.context.FLOAT,3,!1)||Gd(&quot;Error setting normalMC in shader VAO.&quot;):n.getVAO().removeAttributeArray(&quot;normalMC&quot;),t.renderable.getCustomShaderAttributes().forEach(((e,r)=>{n.getProgram().isAttributeUsed(`${e}MC`)&&(n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),`${e}MC`,n.getCABO().getCustomData()[r].offset,n.getCABO().getStride(),t.context.FLOAT,n.getCABO().getCustomData()[r].components,!1)||Gd(`Error setting ${e}MC in shader VAO.`))})),n.getProgram().isAttributeUsed(&quot;tcoordMC&quot;)&&n.getCABO().getTCoordOffset()?n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;tcoordMC&quot;,n.getCABO().getTCoordOffset(),n.getCABO().getStride(),t.context.FLOAT,n.getCABO().getTCoordComponents(),!1)||Gd(&quot;Error setting tcoordMC in shader VAO.&quot;):n.getVAO().removeAttributeArray(&quot;tcoordMC&quot;),n.getProgram().isAttributeUsed(&quot;scalarColor&quot;)&&n.getCABO().getColorComponents()?n.getVAO().addAttributeArray(n.getProgram(),n.getCABO().getColorBO(),&quot;scalarColor&quot;,n.getCABO().getColorOffset(),n.getCABO().getColorBOStride(),t.context.UNSIGNED_BYTE,4,!0)||Gd(&quot;Error setting scalarColor in shader VAO.&quot;):n.getVAO().removeAttributeArray(&quot;scalarColor&quot;),n.getAttributeUpdateTime().modified()}if(t.renderable.getNumberOfClippingPlanes()){const e=t.renderable.getNumberOfClippingPlanes(),r=[],a=n.getCABO().getCoordShiftAndScaleEnabled()?n.getCABO().getInverseShiftAndScaleMatrix():null,i=a?p(t.tmpMat4,o.getMatrix()):o.getMatrix();a&&(h(i,i),b(i,i,a),h(i,i));for(let n=0;n<e;n++){const e=[];t.renderable.getClippingPlaneInDataCoords(i,n,e);for(let t=0;t<4;t++)r.push(e[t])}n.getProgram().setUniformi(&quot;numClipPlanes&quot;,e),n.getProgram().setUniform4fv(&quot;clipPlanes&quot;,r)}t.internalColorTexture&&n.getProgram().isUniformUsed(&quot;texture1&quot;)&&n.getProgram().setUniformi(&quot;texture1&quot;,t.internalColorTexture.getTextureUnit());const a=t.openGLActor.getActiveTextures();if(a)for(let e=0;e<a.length;++e){const t=a[e].getTextureUnit(),r=`texture${t+1}`;n.getProgram().isUniformUsed(r)&&n.getProgram().setUniformi(r,t)}if(t.haveSeenDepthRequest&&n.getProgram().setUniformi(&quot;depthRequest&quot;,t.renderDepth?1:0),n.getProgram().isUniformUsed(&quot;coffset&quot;)){const t=e.getCoincidentParameters(r,o);n.getProgram().setUniformf(&quot;coffset&quot;,t.offset),n.getProgram().isUniformUsed(&quot;cfactor&quot;)&&n.getProgram().setUniformf(&quot;cfactor&quot;,t.factor)}n.setMapperShaderParameters(r,o,t._openGLRenderer.getTiledSizeAndOrigin());const i=t._openGLRenderer.getSelector();n.getProgram().setUniform3fArray(&quot;mapperIndex&quot;,i?i.getPropColorValue():[0,0,0]),n.getProgram().setUniformi(&quot;picking&quot;,i?i.getCurrentPass()+1:0)},e.setLightingShaderParameters=(e,n,r)=>{const o=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);if(o<2)return;const a=e.getProgram();let i=0;const s=n.getLightsByReference();for(let e=0;e<s.length;++e){const r=s[e];if(r.getSwitch()>0){const e=r.getColorByReference(),o=r.getIntensity();t.lightColor[0]=e[0]*o,t.lightColor[1]=e[1]*o,t.lightColor[2]=e[2]*o;const s=r.getDirection(),l=n.getActiveCamera().getViewMatrix(),c=[...s];r.lightTypeIsSceneLight()&&(c[0]=l[0]*s[0]+l[1]*s[1]+l[2]*s[2],c[1]=l[4]*s[0]+l[5]*s[1]+l[6]*s[2],c[2]=l[8]*s[0]+l[9]*s[1]+l[10]*s[2],Fo(c)),t.lightDirection[0]=c[0],t.lightDirection[1]=c[1],t.lightDirection[2]=c[2],Fo(t.lightDirection),a.setUniform3fArray(`lightColor${i}`,t.lightColor),a.setUniform3fArray(`lightDirectionVC${i}`,t.lightDirection),i++}}if(o<3)return;const l=n.getActiveCamera().getViewMatrix();h(l,l),i=0;for(let e=0;e<s.length;++e){const t=s[e];if(t.getSwitch()>0){const e=t.getTransformedPosition(),n=new Float64Array(3);In(n,e,l),a.setUniform3fArray(`lightAttenuation${i}`,t.getAttenuationValuesByReference()),a.setUniformi(`lightPositional${i}`,t.getPositional()),a.setUniformf(`lightExponent${i}`,t.getExponent()),a.setUniformf(`lightConeAngle${i}`,t.getConeAngle()),a.setUniform3fArray(`lightPositionVC${i}`,[n[0],n[1],n[2]]),i++}}},e.setCameraShaderParameters=(e,a,i)=>{const s=e.getProgram(),l=t.openGLCamera.getKeyMatrices(a),c=a.getActiveCamera(),u=t.openGLCamera.getKeyMatrixTime().getMTime(),d=s.getLastCameraMTime(),p=e.getCABO().getCoordShiftAndScaleEnabled()?e.getCABO().getInverseShiftAndScaleMatrix():null,f=i.getIsIdentity(),g=f?{mcwc:null,normalMatrix:null}:t.openGLActor.getKeyMatrices();if(i.getCoordinateSystem()===Wd.DISPLAY){const e=t._openGLRenderer.getTiledSizeAndOrigin();m(t.tmpMat4),t.tmpMat4[0]=2/e.usize,t.tmpMat4[12]=-1,t.tmpMat4[5]=2/e.vsize,t.tmpMat4[13]=-1,b(t.tmpMat4,t.tmpMat4,p),s.setUniformMatrix(&quot;MCPCMatrix&quot;,t.tmpMat4)}else s.setUniformMatrix(&quot;MCPCMatrix&quot;,n([l.wcpc,g.mcwc,p],r,t.tmpMat4));s.isUniformUsed(&quot;MCVCMatrix&quot;)&&s.setUniformMatrix(&quot;MCVCMatrix&quot;,n([l.wcvc,g.mcwc,p],r,t.tmpMat4)),s.isUniformUsed(&quot;normalMatrix&quot;)&&s.setUniformMatrix3x3(&quot;normalMatrix&quot;,n([l.normalMatrix,g.normalMatrix],o,t.tmpMat3)),d!==u&&(s.isUniformUsed(&quot;cameraParallel&quot;)&&s.setUniformi(&quot;cameraParallel&quot;,c.getParallelProjection()),s.setLastCameraMTime(u)),f||s.setLastCameraMTime(0)},e.setPropertyShaderParameters=(e,n,r)=>{const o=e.getProgram();let a=r.getProperty(),i=a.getOpacity(),s=t.drawingEdges?a.getEdgeColorByReference():a.getAmbientColorByReference(),l=t.drawingEdges?a.getEdgeColorByReference():a.getDiffuseColorByReference(),c=t.drawingEdges?1:a.getAmbient(),u=t.drawingEdges?0:a.getDiffuse(),d=t.drawingEdges?0:a.getSpecular();const p=a.getSpecularPower();o.setUniformf(&quot;opacityUniform&quot;,i),o.setUniform3fArray(&quot;ambientColorUniform&quot;,s),o.setUniform3fArray(&quot;diffuseColorUniform&quot;,l),o.setUniformf(&quot;ambient&quot;,c),o.setUniformf(&quot;diffuse&quot;,u);const f=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);if(f<1)return;let g=a.getSpecularColorByReference();if(o.setUniform3fArray(&quot;specularColorUniform&quot;,g),o.setUniformf(&quot;specularPowerUniform&quot;,p),o.setUniformf(&quot;specular&quot;,d),o.isUniformUsed(&quot;ambientIntensityBF&quot;)){if(a=r.getBackfaceProperty(),i=a.getOpacity(),s=a.getAmbientColor(),c=a.getAmbient(),l=a.getDiffuseColor(),u=a.getDiffuse(),g=a.getSpecularColor(),d=a.getSpecular(),o.setUniformf(&quot;ambientIntensityBF&quot;,c),o.setUniformf(&quot;diffuseIntensityBF&quot;,u),o.setUniformf(&quot;opacityUniformBF&quot;,i),o.setUniform3fArray(&quot;ambientColorUniformBF&quot;,s),o.setUniform3fArray(&quot;diffuseColorUniformBF&quot;,l),f<1)return;o.setUniformf(&quot;specularIntensityBF&quot;,d),o.setUniform3fArray(&quot;specularColorUniformBF&quot;,g),o.setUniformf(&quot;specularPowerUniformBF&quot;,p)}},e.updateMaximumPointCellIds=(e,n)=>{const r=t._openGLRenderer.getSelector();if(r){if(t.selectionWebGLIdsToVTKIds?.points?.length){const e=t.selectionWebGLIdsToVTKIds.points.length;r.setMaximumPointId(e-1)}if(t.selectionWebGLIdsToVTKIds?.cells?.length){const e=t.selectionWebGLIdsToVTKIds.cells.length;r.setMaximumCellId(e-1)}r.getFieldAssociation()===Dd.FIELD_ASSOCIATION_POINTS&&(t.pointPicking=!0)}},e.renderPieceStart=(n,r)=>{t.primitiveIDOffset=0,t.vertexIDOffset=0;const o=function(e){const t=e.getSelector();return t?t.getCurrentPass():Al.MIN_KNOWN_PASS-1}(t._openGLRenderer);t.lastSelectionState!==o&&(t.selectionStateChanged.modified(),t.lastSelectionState=o),t._openGLRenderer.getSelector()&&t._openGLRenderer.getSelector().renderProp(r),e.updateBufferObjects(n,r),t.renderable.getColorTextureMap()&&t.internalColorTexture.activate(),t.lastBoundBO=null},e.renderPieceDraw=(n,r)=>{const o=r.getProperty().getRepresentation(),a=r.getProperty().getEdgeVisibility()&&o===Bd.SURFACE,i=t._openGLRenderer.getSelector(),s=i&&i.getFieldAssociation()===Dd.FIELD_ASSOCIATION_POINTS&&(t.lastSelectionState===Al.ID_LOW24||t.lastSelectionState===Al.ID_HIGH24);for(let i=Ld.Start;i<Ld.End;i++)t.primitives[i].setPointPicking(s),t.primitives[i].getCABO().getElementCount()&&(t.drawingEdges=a&&(i===Ld.TrisEdges||i===Ld.TriStripsEdges),t.drawingEdges&&(t.renderDepth||t.lastSelectionState>=0)||(t.lastBoundBO=t.primitives[i],t.primitiveIDOffset+=t.primitives[i].drawArrays(n,r,o,e),t.vertexIDOffset+=t.primitives[i].getCABO().getElementCount()))},e.renderPieceFinish=(e,n)=>{t.LastBoundBO&&t.LastBoundBO.getVAO().release(),t.renderable.getColorTextureMap()&&t.internalColorTexture.deactivate()},e.renderPiece=(n,r)=>{if(e.invokeEvent(Ud),t.renderable.getStatic()||t.renderable.update(),t.currentInput=t.renderable.getInputData(),e.invokeEvent(zd),!t.currentInput)return void Gd(&quot;No input!&quot;);if(!t.currentInput.getPoints||!t.currentInput.getPoints().getNumberOfValues())return;const o=t.context,a=r.getProperty().getBackfaceCulling(),i=r.getProperty().getFrontfaceCulling();a||i?i?(t._openGLRenderWindow.enableCullFace(),o.cullFace(o.FRONT)):(t._openGLRenderWindow.enableCullFace(),o.cullFace(o.BACK)):t._openGLRenderWindow.disableCullFace(),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r)},e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n),e.updateMaximumPointCellIds()},e.getNeedToRebuildBufferObjects=(n,r)=>{const o=t.VBOBuildTime.getMTime();return o<e.getMTime()||o<t.renderable.getMTime()||o<r.getMTime()||o<t.currentInput.getMTime()},e.buildBufferObjects=(e,n)=>{const r=t.currentInput;if(null===r)return;t.renderable.mapScalars(r,1);const o=t.renderable.getColorMapColors();t.haveCellScalars=!1;const a=t.renderable.getScalarMode();t.renderable.getScalarVisibility()&&(a!==Fd.USE_CELL_DATA&&a!==Fd.USE_CELL_FIELD_DATA&&a!==Fd.USE_FIELD_DATA&&r.getPointData().getScalars()||a===Fd.USE_POINT_FIELD_DATA||!o||(t.haveCellScalars=!0));let i=n.getProperty().getInterpolation()!==Nd.FLAT?r.getPointData().getNormals():null;null===i&&r.getCellData().getNormals()&&(t.haveCellNormals=!0,i=r.getCellData().getNormals());const s=n.getProperty().getRepresentation();let l=r.getPointData().getTCoords();t.openGLActor.getActiveTextures()||(l=null);let c=!1;if(t.renderable.getColorCoordinates()){l=t.renderable.getColorCoordinates(),c=t.renderable.getAreScalarsMappedFromCells(),t.internalColorTexture||(t.internalColorTexture=Pd.newInstance({resizable:!0}));const e=t.internalColorTexture;e.setMinificationFilter(_d.NEAREST),e.setMagnificationFilter(_d.NEAREST),e.setWrapS(kd.CLAMP_TO_EDGE),e.setWrapT(kd.CLAMP_TO_EDGE),e.setOpenGLRenderWindow(t._openGLRenderWindow);const n=t.renderable.getColorTextureMap(),r=n.getExtent(),o=n.getPointData().getScalars();e.create2DFromRaw({width:r[1]-r[0]+1,height:r[3]-r[2]+1,numComps:o.getNumberOfComponents(),dataType:o.getDataType(),data:o.getData()}),e.activate(),e.sendParameters(),e.deactivate()}const u=`${r.getMTime()}A${s}B${r.getMTime()}C${i?i.getMTime():1}D${o?o.getMTime():1}E${n.getProperty().getEdgeVisibility()}F${l?l.getMTime():1}`;if(t.VBOBuildString!==u){const e={points:r.getPoints(),normals:i,tcoords:l,colors:o,cellOffset:0,vertexOffset:0,useTCoordsPerCell:c,haveCellScalars:t.haveCellScalars,haveCellNormals:t.haveCellNormals,customAttributes:t.renderable.getCustomShaderAttributes().map((e=>r.getPointData().getArrayByName(e)))};t.renderable.getPopulateSelectionSettings()&&(t.selectionWebGLIdsToVTKIds={points:null,cells:null});const a=[{inRep:&quot;verts&quot;,cells:r.getVerts()},{inRep:&quot;lines&quot;,cells:r.getLines()},{inRep:&quot;polys&quot;,cells:r.getPolys()},{inRep:&quot;strips&quot;,cells:r.getStrips()},{inRep:&quot;polys&quot;,cells:r.getPolys()},{inRep:&quot;strips&quot;,cells:r.getStrips()}],d=n.getProperty().getEdgeVisibility()&&s===Bd.SURFACE;for(let n=Ld.Start;n<Ld.End;n++)n!==Ld.TrisEdges&&n!==Ld.TriStripsEdges?(e.cellOffset+=t.primitives[n].getCABO().createVBO(a[n].cells,a[n].inRep,s,e,t.selectionWebGLIdsToVTKIds),e.vertexOffset+=t.primitives[n].getCABO().getElementCount()):d?t.primitives[n].getCABO().createVBO(a[n].cells,a[n].inRep,Bd.WIREFRAME,{...e,tcoords:null,colors:null,haveCellScalars:!1,haveCellNormals:!1}):t.primitives[n].releaseGraphicsResources();t.renderable.getPopulateSelectionSettings()&&t.renderable.setSelectionWebGLIdsToVTKIds(t.selectionWebGLIdsToVTKIds),t.VBOBuildString=u}t.VBOBuildTime.modified()},e.getAllocatedGPUMemoryInBytes=()=>{let e=0;return t.primitives.forEach((t=>{e+=t.getAllocatedGPUMemoryInBytes()})),e}}(e,t)}const Kd=Mt(jd,&quot;vtkOpenGLPolyDataMapper&quot;);var $d={newInstance:Kd,extend:jd};Jt(&quot;vtkMapper&quot;,Kd);const qd=1,{primTypes:Xd}=ld,{Filter:Yd,Wrap:Zd}=Pd,{vtkErrorMacro:Qd}=Ht,Jd={type:&quot;StartEvent&quot;},ep={type:&quot;EndEvent&quot;},tp={context:null,VBOBuildTime:0,VBOBuildString:null,primitives:null,primTypes:null,shaderRebuildString:null};const np=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,tp,n),qt.extend(e,t,n),Ed(e,t,n),Vd(e,t,n),t.primitives=[],t.primTypes=Xd,t.tmpMat4=m(new Float64Array(16));for(let e=Xd.Start;e<Xd.End;e++)t.primitives[e]=ld.newInstance(),t.primitives[e].setPrimitiveType(e),t.primitives[e].set({lastLightComplexity:0,lastLightCount:0,lastSelectionPass:!1},!0);Ct(e,t,[&quot;context&quot;]),t.VBOBuildTime={},ht(t.VBOBuildTime,{mtime:0}),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLPolyDataMapper2D&quot;),e.buildPass=n=>{n&&(t.openGLActor2D=e.getFirstAncestorOfType(&quot;vtkOpenGLActor2D&quot;),t._openGLRenderer=t.openGLActor2D.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t.openGLCamera=t._openGLRenderer.getViewNodeFor(t._openGLRenderer.getRenderable().getActiveCamera()))},e.overlayPass=t=>{t&&e.render()},e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkPolyData2DVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\n// all variables that represent positions or directions have a suffix\\n// indicating the coordinate system they are in. The possible values are\\n// MC - Model Coordinates\\n// WC - WC world coordinates\\n// VC - View Coordinates\\n// DC - Display Coordinates\\n\\nin vec4 vertexWC;\\n\\n// frag position in VC\\n//VTK::PositionVC::Dec\\n\\n// material property values\\n//VTK::Color::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// Apple Bug\\n//VTK::PrimID::Dec\\n\\nuniform mat4 WCVCMatrix;  // World to view matrix\\n\\nvoid main()\\n{\\n  // Apple Bug\\n  //VTK::PrimID::Impl\\n\\n  gl_Position = WCVCMatrix*vertexWC;\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::PositionVC::Impl\\n}\\n&quot;,e.Fragment=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkPolyData2DFS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\nuniform int PrimitiveIDOffset;\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// Scalar coloring\\n//VTK::Color::Dec\\n\\n// Depth Peeling\\n//VTK::DepthPeeling::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\n// Apple Bug\\n//VTK::PrimID::Dec\\n\\nvoid main()\\n{\\n  // Apple Bug\\n  //VTK::PrimID::Impl\\n\\n  //VTK::Color::Impl\\n  //VTK::TCoord::Impl\\n\\n  //VTK::DepthPeeling::Impl\\n  //VTK::Picking::Impl\\n\\n  if (gl_FragData[0].a <= 0.0)\\n    {\\n    discard;\\n    }\\n}\\n&quot;,e.Geometry=&quot;&quot;},e.render=()=>{const n=t._openGLRenderWindow.getContext();if(t.context!==n){t.context=n;for(let e=Xd.Start;e<Xd.End;e++)t.primitives[e].setOpenGLRenderWindow(t._openGLRenderWindow)}const r=t.openGLActor2D.getRenderable(),o=t._openGLRenderer.getRenderable();e.renderPiece(o,r)},e.renderPiece=(n,r)=>{if(e.invokeEvent(Jd),t.renderable.getStatic()||t.renderable.update(),t.currentInput=t.renderable.getInputData(),e.invokeEvent(ep),!t.currentInput)return void Qd(&quot;No input!&quot;);if(!t.currentInput.getPoints||!t.currentInput.getPoints().getNumberOfValues())return;const o=t.context;t._openGLRenderWindow.enableCullFace(),o.cullFace(o.BACK),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r)},e.renderPieceStart=(n,r)=>{t.primitiveIDOffset=0,t._openGLRenderer.getSelector()&&(t._openGLRenderer.getSelector().getCurrentPass(),t._openGLRenderer.getSelector().renderProp(r)),t.renderable.getColorTextureMap()&&t.internalColorTexture.activate(),e.updateBufferObjects(n,r),t.lastBoundBO=null},e.getNeedToRebuildShaders=(e,n,r)=>e.getShaderSourceTime().getMTime()<t.renderable.getMTime()||e.getShaderSourceTime().getMTime()<t.currentInput.getMTime(),e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n)},e.getNeedToRebuildBufferObjects=(n,r)=>{const o=t.VBOBuildTime.getMTime();return!!(o<e.getMTime()||o<t._openGLRenderWindow.getMTime()||o<t.renderable.getMTime()||o<r.getMTime()||o<t.currentInput.getMTime()||t.renderable.getTransformCoordinate()&&o<n.getMTime())},e.buildBufferObjects=(e,n)=>{const r=t.currentInput;if(null===r)return;t.renderable.mapScalars(r,n.getProperty().getOpacity());const o=t.renderable.getColorMapColors(),a=n.getProperty().getRepresentation();let i=r.getPointData().getTCoords();t.openGLActor2D.getActiveTextures()||(i=null);let s=!1;if(t.renderable.getColorCoordinates()){i=t.renderable.getColorCoordinates(),s=t.renderable.getAreScalarsMappedFromCells(),t.internalColorTexture||(t.internalColorTexture=Pd.newInstance({resizable:!0}));const e=t.internalColorTexture;e.setMinificationFilter(Yd.NEAREST),e.setMagnificationFilter(Yd.NEAREST),e.setWrapS(Zd.CLAMP_TO_EDGE),e.setWrapT(Zd.CLAMP_TO_EDGE),e.setOpenGLRenderWindow(t._openGLRenderWindow);const n=t.renderable.getColorTextureMap(),r=n.getExtent(),o=n.getPointData().getScalars();e.create2DFromRaw({width:r[1]-r[0]+1,height:r[3]-r[2]+1,numComps:o.getNumberOfComponents(),dataType:o.getDataType(),data:o.getData()}),e.activate(),e.sendParameters(),e.deactivate()}const l=t.renderable.getTransformCoordinate(),c=e.getRenderWindow().getViews()[0].getViewportSize(e),u=`${r.getMTime()}A${a}B${r.getMTime()}C${o?o.getMTime():1}D${i?i.getMTime():1}E${l?e.getMTime():1}F${c}`;if(t.VBOBuildString!==u){let n=r.getPoints();if(l){const t=Yl.newInstance(),r=n.getNumberOfPoints();t.setNumberOfPoints(r);const o=[];for(let a=0;a<r;++a){n.getPoint(a,o),l.setValue(o);const r=l.getComputedDoubleViewportValue(e);t.setPoint(a,r[0],r[1],0)}n=t}const c={points:n,tcoords:i,colors:o,cellOffset:0,useTCoordsPerCell:s,haveCellScalars:t.renderable.getAreScalarsMappedFromCells(),customAttributes:t.renderable.getCustomShaderAttributes().map((e=>r.getPointData().getArrayByName(e)))};c.cellOffset+=t.primitives[Xd.Points].getCABO().createVBO(r.getVerts(),&quot;verts&quot;,a,c),c.cellOffset+=t.primitives[Xd.Lines].getCABO().createVBO(r.getLines(),&quot;lines&quot;,a,c),c.cellOffset+=t.primitives[Xd.Tris].getCABO().createVBO(r.getPolys(),&quot;polys&quot;,a,c),c.cellOffset+=t.primitives[Xd.TriStrips].getCABO().createVBO(r.getStrips(),&quot;strips&quot;,a,c),t.VBOBuildTime.modified(),t.VBOBuildString=u}},e.renderPieceDraw=(n,r)=>{const o=r.getProperty().getRepresentation();t.context.depthMask(!0);for(let a=Xd.Start;a<Xd.End;a++)t.primitives[a].getCABO().getElementCount()&&(t.lastBoundBO=t.primitives[a],t.primitiveIDOffset+=t.primitives[a].drawArrays(n,r,o,e))},e.renderPieceFinish=(e,n)=>{t.lastBoundBO&&t.lastBoundBO.getVAO().release(),t.renderable.getColorTextureMap()&&t.internalColorTexture.deactivate()},e.replaceShaderValues=(t,n,r)=>{e.replaceShaderColor(t,n,r),e.replaceShaderTCoord(t,n,r),e.replaceShaderPicking(t,n,r),e.replaceShaderPositionVC(t,n,r)},e.replaceShaderColor=(e,n,r)=>{let o=e.Vertex,a=e.Geometry,i=e.Fragment,s=[&quot;uniform vec3 diffuseColorUniform;&quot;,&quot;uniform float opacityUniform;&quot;],l=[&quot;vec3 diffuseColor = diffuseColorUniform;&quot;,&quot;float opacity = opacityUniform;&quot;];0!==t.lastBoundBO.getCABO().getColorComponents()?(s=s.concat([&quot;varying vec4 vertexColorVSOutput;&quot;]),o=td.substitute(o,&quot;//VTK::Color::Dec&quot;,[&quot;attribute vec4 scalarColor;&quot;,&quot;varying vec4 vertexColorVSOutput;&quot;]).result,o=td.substitute(o,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorVSOutput =  scalarColor;&quot;]).result,a=td.substitute(a,&quot;//VTK::Color::Dec&quot;,[&quot;in vec4 vertexColorVSOutput[];&quot;,&quot;out vec4 vertexColorGSOutput;&quot;]).result,a=td.substitute(a,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorGSOutput = vertexColorVSOutput[i];&quot;]).result,i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,l.concat([&quot;  diffuseColor = vertexColorVSOutput.rgb;&quot;,&quot;  opacity = opacity*vertexColorVSOutput.a;&quot;])).result):t.renderable.getAreScalarsMappedFromCells()&&(l=l.concat([&quot;  vec4 texColor = texture2D(texture1, tcoordVCVSOutput.st);&quot;,&quot;  diffuseColor = texColor.rgb;&quot;,&quot;  opacity = opacity*texColor.a;&quot;])),l=l.concat([&quot;gl_FragData[0] = vec4(diffuseColor, opacity);&quot;]),i=td.substitute(i,&quot;//VTK::Color::Dec&quot;,s).result,i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,l).result,e.Vertex=o,e.Geometry=a,e.Fragment=i},e.replaceShaderTCoord=(e,n,r)=>{if(t.lastBoundBO.getCABO().getTCoordOffset()){let n=e.Vertex,r=e.Geometry,o=e.Fragment;const a=t.lastBoundBO.getCABO().getTCoordComponents();1===a?(n=td.substitute(n,&quot;//VTK::TCoord::Dec&quot;,[&quot;in float tcoordMC;&quot;,&quot;out float tcoordVCVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::TCoord::Impl&quot;,[&quot;tcoordVCVSOutput = tcoordMC;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Dec&quot;,[&quot;in float tcoordVCVSOutput[];\\n&quot;,&quot;out float tcoordVCGSOutput;&quot;]).result,r=td.substitute(r,[&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCGSOutput = tcoordVCVSOutput[i];&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;in float tcoordVCVSOutput;&quot;,&quot;uniform sampler2D texture1;&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;gl_FragData[0] = gl_FragData[0]*texture2D(texture1, vec2(tcoordVCVSOutput,0));&quot;]).result):2===a&&(n=td.substitute(n,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec2 tcoordMC;&quot;,&quot;out vec2 tcoordVCVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::TCoord::Impl&quot;,[&quot;tcoordVCVSOutput = tcoordMC;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec2 tcoordVCVSOutput[];\\n&quot;,&quot;out vec2 tcoordVCGSOutput;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Impl&quot;,[&quot;tcoordVCGSOutput = tcoordVCVSOutput[i];&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec2 tcoordVCVSOutput;&quot;,&quot;uniform sampler2D texture1;&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;gl_FragData[0] = gl_FragData[0]*texture2D(texture1, tcoordVCVSOutput.st);&quot;]).result),t.renderable.getAreScalarsMappedFromCells()&&(r=td.substitute(r,&quot;//VTK::PrimID::Impl&quot;,[&quot;gl_PrimitiveID = gl_PrimitiveIDIn;&quot;]).result),e.Vertex=n,e.Geometry=r,e.Fragment=o}},e.replaceShaderPicking=(e,t,n)=>{let r=e.Fragment;r=td.substitute(r,&quot;//VTK::Picking::Dec&quot;,[&quot;uniform vec3 mapperIndex;&quot;,&quot;uniform int picking;&quot;]).result,r=td.substitute(r,&quot;//VTK::Picking::Impl&quot;,&quot;  gl_FragData[0] = picking != 0 ? vec4(mapperIndex,1.0) : gl_FragData[0];&quot;).result,e.Fragment=r},e.replaceShaderPositionVC=(e,n,r)=>{t.lastBoundBO.replaceShaderPositionVC(e,n,r)},e.invokeShaderCallbacks=(e,n,r)=>{const o=t.renderable.getViewSpecificProperties().ShadersCallbacks;o&&o.forEach((t=>{t.callback(t.userData,e,n,r)}))},e.setMapperShaderParameters=(e,n,r)=>{if(e.getProgram().isUniformUsed(&quot;PrimitiveIDOffset&quot;)&&e.getProgram().setUniformi(&quot;PrimitiveIDOffset&quot;,t.primitiveIDOffset),e.getProgram().isAttributeUsed(&quot;vertexWC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;vertexWC&quot;,e.getCABO().getVertexOffset(),e.getCABO().getStride(),t.context.FLOAT,3,!1)||Qd(&quot;Error setting vertexWC in shader VAO.&quot;)),e.getCABO().getElementCount()&&(t.VBOBuildTime.getMTime()>e.getAttributeUpdateTime().getMTime()||e.getShaderSourceTime().getMTime()>e.getAttributeUpdateTime().getMTime())){t.renderable.getCustomShaderAttributes().forEach(((n,r)=>{e.getProgram().isAttributeUsed(`${n}MC`)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),`${n}MC`,e.getCABO().getCustomData()[r].offset,e.getCABO().getStride(),t.context.FLOAT,e.getCABO().getCustomData()[r].components,!1)||Qd(`Error setting ${n}MC in shader VAO.`))})),e.getProgram().isAttributeUsed(&quot;tcoordMC&quot;)&&e.getCABO().getTCoordOffset()?e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;tcoordMC&quot;,e.getCABO().getTCoordOffset(),e.getCABO().getStride(),t.context.FLOAT,e.getCABO().getTCoordComponents(),!1)||Qd(&quot;Error setting tcoordMC in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;tcoordMC&quot;),e.getProgram().isAttributeUsed(&quot;scalarColor&quot;)&&e.getCABO().getColorComponents()?e.getVAO().addAttributeArray(e.getProgram(),e.getCABO().getColorBO(),&quot;scalarColor&quot;,e.getCABO().getColorOffset(),e.getCABO().getColorBOStride(),t.context.UNSIGNED_BYTE,4,!0)||Qd(&quot;Error setting scalarColor in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;scalarColor&quot;),t.internalColorTexture&&e.getProgram().isUniformUsed(&quot;texture1&quot;)&&t.internalColorTexture.getTextureUnit()>-1&&e.getProgram().setUniformi(&quot;texture1&quot;,t.internalColorTexture.getTextureUnit());const o=t.openGLActor2D.getActiveTextures();if(o)for(let t=0;t<o.length;++t){const n=o[t].getTextureUnit(),r=`texture${n+1}`;e.getProgram().isUniformUsed(r)&&e.getProgram().setUniformi(r,n)}e.setMapperShaderParameters(n,r,t._openGLRenderer.getTiledSizeAndOrigin());const a=t._openGLRenderer.getSelector();e.getProgram().setUniform3fArray(&quot;mapperIndex&quot;,a?a.getPropColorValue():[0,0,0]),e.getProgram().setUniformi(&quot;picking&quot;,a?a.getCurrentPass()+1:0)}},e.setPropertyShaderParameters=(e,n,r)=>{const o=t.renderable.getColorMapColors();if(!o||0===o.getNumberOfComponents()){const t=e.getProgram(),n=r.getProperty(),o=n.getOpacity();t.setUniformf(&quot;opacityUniform&quot;,o);const a=n.getColor();t.setUniform3fArray(&quot;diffuseColorUniform&quot;,a)}},e.setLightingShaderParameters=(e,t,n)=>{},e.setCameraShaderParameters=(e,n,o)=>{const a=e.getProgram(),i=e.getCABO().getCoordShiftAndScaleEnabled()?e.getCABO().getInverseShiftAndScaleMatrix():null,s=n.getRenderWindow().getViews()[0].getViewportSize(n),l=n.getViewport(),c=o.getActualPositionCoordinate().getComputedDoubleViewportValue(n),u=[0,0,1,1],d=[0,0,1,1];if(d[0]=l[0]>=u[0]?l[0]:u[0],d[1]=l[1]>=u[1]?l[1]:u[1],d[2]=l[2]<=u[2]?l[2]:u[2],d[3]=l[3]<=u[3]?l[3]:u[3],d[0]>=d[2])return;if(d[1]>=d[3])return;s[0]=yo(s[0]*(d[2]-d[0])/(l[2]-l[0])),s[1]=yo(s[1]*(d[3]-d[1])/(l[3]-l[1]));const p=t._openGLRenderer.getParent().getSize(),f=yo(c[0]-(d[0]-l[0])*p[0]),g=yo(c[1]-(d[1]-l[1])*p[1]),v=-f;let T=-f+s[0];const y=-g;let b=-g+s[1];v===T&&(T=v+1),y===b&&(b=y+1);const x=m(new Float64Array(16));var C,S,A;x[0]=2/(T-v),x[5]=2/(b-y),x[3]=-1*(T+v)/(T-v),x[7]=-1*(b+y)/(b-y),x[10]=0,x[11]=o.getProperty().getDisplayLocation()===qd?-1:1,x[15]=1,h(x,x),a.setUniformMatrix(&quot;WCVCMatrix&quot;,(C=[x,i],S=r,A=t.tmpMat4,S.identity(A),C.reduce(((e,t,n)=>0===n?t?S.copy(e,t):S.identity(e):t?S.multiply(e,e,t):e),A)))},e.getAllocatedGPUMemoryInBytes=()=>{let e=0;return t.primitives.forEach((t=>{e+=t.getAllocatedGPUMemoryInBytes()})),e}}(e,t)}),&quot;vtkOpenGLPolyDataMapper2D&quot;);Jt(&quot;vtkMapper2D&quot;,np);var rp={Orientation:{HORIZONTAL:&quot;horizontal&quot;,VERTICAL:&quot;vertical&quot;,AUTO:&quot;auto&quot;}};const{VectorMode:op}=cl,{Orientation:ap}=rp;function ip(e,t,n){e.strokeStyle=t.strokeColor,e.lineWidth=t.strokeSize,e.fillStyle=t.fontColor;const r=t.fontSize??n;e.font=`${t.fontStyle} ${r}px ${t.fontFamily}`}function sp(e,t){return e=>{const n=e.getLastSize(),r=(n[0]/700)**.8,o=(n[1]/700)**.8,a=Math.min(r,o),i=e.getAxisTextStyle(),s=e.getTickTextStyle();Object.assign(i,t.axisTextStyle),Object.assign(s,t.tickTextStyle),void 0===i.fontSize&&(i.fontSize=Math.max(24*a,12)),void 0===s.fontSize&&(e.getLastAspectRatio()>1?s.fontSize=Math.max(20*a,10):s.fontSize=Math.max(16*a,10));const l=e.updateTextureAtlas();e.setTopTitle(!1);const c=e.getBoxSizeByReference();let u=!1;if(u=t.orientation===ap.VERTICAL||t.orientation!==ap.HORIZONTAL&&e.getLastAspectRatio()>1,u)e.setTickLabelPixelOffset(.3*s.fontSize),l.titleWidth<=l.tickWidth+e.getTickLabelPixelOffset()+.8*s.fontSize?(e.setTopTitle(!0),e.setAxisTitlePixelOffset(.2*s.fontSize),c[0]=2*(l.tickWidth+e.getTickLabelPixelOffset()+.8*s.fontSize)/n[0],e.setBoxPosition([.98-c[0],-.92])):(e.setAxisTitlePixelOffset(.2*s.fontSize),c[0]=2*(l.titleHeight+e.getAxisTitlePixelOffset()+l.tickWidth+e.getTickLabelPixelOffset()+.8*s.fontSize)/n[0],e.setBoxPosition([.99-c[0],-.92])),c[1]=Math.max(1.2,Math.min(1.84/o,1.84));else{e.setAxisTitlePixelOffset(1.2*s.fontSize),e.setTickLabelPixelOffset(.1*s.fontSize);const t=2*(.8*s.fontSize+l.titleHeight+e.getAxisTitlePixelOffset())/n[1],r=2*l.tickWidth/n[0];c[0]=Math.min(1.9,Math.max(1.4,1.4*r*(e.getTicks().length+3))),c[1]=t,e.setBoxPosition([-.5*c[0],-.97])}e.recomputeBarSegments(l)}}function lp(e,t){return e=>{const t=e.getLastTickBounds(),n=ro().domain([t[0],t[1]]),r=n.ticks(5),o=n.tickFormat(5);e.setTicks(r),e.setTickStrings(r.map(o))}}const cp=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{renderable:null};Object.assign(t,{},n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;axisTitlePixelOffset&quot;,&quot;tickLabelPixelOffset&quot;,&quot;renderable&quot;,&quot;topTitle&quot;,&quot;ticks&quot;,&quot;tickStrings&quot;,&quot;tickPositions&quot;]),Wt.get(e,t,[&quot;lastSize&quot;,&quot;lastAspectRatio&quot;,&quot;lastTickBounds&quot;,&quot;axisTextStyle&quot;,&quot;tickTextStyle&quot;,&quot;barActor&quot;,&quot;tmActor&quot;]),Wt.getArray(e,t,[&quot;boxPosition&quot;,&quot;boxSize&quot;]),Wt.setArray(e,t,[&quot;boxPosition&quot;,&quot;boxSize&quot;],2),t.forceUpdate=!1,t.lastRebuildTime={},Wt.obj(t.lastRebuildTime,{mtime:0}),t.lastSize=[-1,-1],t.tmCanvas=document.createElement(&quot;canvas&quot;),t.tmContext=t.tmCanvas.getContext(&quot;2d&quot;),t._tmAtlas=new Map,t.barMapper=Gl.newInstance(),t.barMapper.setInterpolateScalarsBeforeMapping(!0),t.barMapper.setUseLookupTableScalarRange(!0),t.polyData=gu.newInstance(),t.barMapper.setInputData(t.polyData),t.barActor=ss.newInstance(),t.barActor.setMapper(t.barMapper),t.tmPolyData=gu.newInstance(),t.tmMapper=Gl.newInstance(),t.tmMapper.setInputData(t.tmPolyData),t.tmTexture=vu.newInstance({resizable:!0}),t.tmTexture.setInterpolate(!1),t.tmActor=ss.newInstance({parentProp:e}),t.tmActor.setMapper(t.tmMapper),t.tmActor.addTexture(t.tmTexture),t.barPosition=[0,0],t.barSize=[0,0],t.boxPosition=[.88,-.92],t.boxSize=[.1,1.1],t.lastTickBounds=[],function(e,t){t.classHierarchy.push(&quot;vtkScalarBarActorHelper&quot;),e.setRenderable=n=>{t.renderable!==n&&(t.renderable=n,t.barActor.setProperty(n.getProperty()),t.barActor.setParentProp(n),t.barActor.setCoordinateSystemToDisplay(),t.tmActor.setProperty(n.getProperty()),t.tmActor.setParentProp(n),t.tmActor.setCoordinateSystemToDisplay(),t.generateTicks=n.generateTicks,t.axisTextStyle={...n.getAxisTextStyle()},t.tickTextStyle={...n.getTickTextStyle()},e.modified())},e.updateAPISpecificData=(n,r,o)=>{t.lastSize[0]===n[0]&&t.lastSize[1]===n[1]||(t.lastSize[0]=n[0],t.lastSize[1]=n[1],t.lastAspectRatio=n[0]/n[1],t.forceUpdate=!0);const a=t.renderable.getScalarsToColors();if(a&&t.renderable.getVisibility()&&(t.barMapper.setLookupTable(a),t.camera=r,t.renderWindow=o,t.forceUpdate||Math.max(a.getMTime(),e.getMTime(),t.renderable.getMTime())>t.lastRebuildTime.getMTime())){const n=a.getMappingRange();if(t.lastTickBounds=[...n],t.renderable.getGenerateTicks()(e),t.renderable.getAutomated())t.renderable.getAutoLayout()(e);else{t.axisTextStyle={...t.renderable.getAxisTextStyle()},t.tickTextStyle={...t.renderable.getTickTextStyle()},t.barPosition=[...t.renderable.getBarPosition()],t.barSize=[...t.renderable.getBarSize()],t.boxPosition=[...t.renderable.getBoxPosition()],t.boxSize=[...t.renderable.getBoxSize()],t.axisTitlePixelOffset=t.renderable.getAxisTitlePixelOffset(),t.tickLabelPixelOffset=t.renderable.getTickLabelPixelOffset();const n=e.updateTextureAtlas();e.recomputeBarSegments(n)}e.updatePolyDataForLabels(),e.updatePolyDataForBarSegments(),t.lastRebuildTime.modified(),t.forceUpdate=!1}},e.updateTextureAtlas=()=>{t.tmContext.textBaseline=&quot;bottom&quot;,t.tmContext.textAlign=&quot;left&quot;;const n={},r=new Map;let o=0,a=1;ip(t.tmContext,t.axisTextStyle,18);let i=t.tmContext.measureText(t.renderable.getAxisLabel()),s={height:i.actualBoundingBoxAscent+2,startingHeight:a,width:i.width+2,textStyle:t.axisTextStyle};r.set(t.renderable.getAxisLabel(),s),a+=s.height,o=s.width,n.titleWidth=s.width,n.titleHeight=s.height,n.tickWidth=0,n.tickHeight=0,ip(t.tmContext,t.tickTextStyle,14);const l=[...e.getTickStrings(),&quot;NaN&quot;,&quot;Below&quot;,&quot;Above&quot;];for(let e=0;e<l.length;e++)r.has(l[e])||(i=t.tmContext.measureText(l[e]),s={height:i.actualBoundingBoxAscent+2,startingHeight:a,width:i.width+2,textStyle:t.tickTextStyle},r.set(l[e],s),a+=s.height,o<s.width&&(o=s.width),n.tickWidth<s.width&&(n.tickWidth=s.width),n.tickHeight<s.height&&(n.tickHeight=s.height));return o=wo(o),a=wo(a),r.forEach((e=>{e.tcoords=[0,(a-e.startingHeight-e.height)/a,e.width/o,(a-e.startingHeight-e.height)/a,e.width/o,(a-e.startingHeight)/a,0,(a-e.startingHeight)/a]})),t.tmCanvas.width=o,t.tmCanvas.height=a,t.tmContext.textBaseline=&quot;bottom&quot;,t.tmContext.textAlign=&quot;left&quot;,t.tmContext.clearRect(0,0,o,a),r.forEach(((e,n)=>{const r=e.textStyle===t.axisTextStyle?18:14;ip(t.tmContext,e.textStyle,r),t.tmContext.fillText(n,1,e.startingHeight+e.height-1)})),t.tmTexture.setCanvas(t.tmCanvas),t.tmTexture.modified(),t._tmAtlas=r,n},e.computeBarSize=e=>{t.vertical=t.boxSize[1]>t.boxSize[0];const n=2*e.tickHeight/t.lastSize[1],r=[1,1];if(t.vertical){const o=2*(e.tickWidth+t.tickLabelPixelOffset)/t.lastSize[0];if(t.topTitle){const n=2*(e.titleHeight+t.axisTitlePixelOffset)/t.lastSize[1];t.barSize[0]=t.boxSize[0]-o,t.barSize[1]=t.boxSize[1]-n}else{const n=2*(e.titleHeight+t.axisTitlePixelOffset)/t.lastSize[0];t.barSize[0]=t.boxSize[0]-n-o,t.barSize[1]=t.boxSize[1]}t.barPosition[0]=t.boxPosition[0]+o,t.barPosition[1]=t.boxPosition[1],r[1]=n}else{const n=(2*e.tickWidth-8)/t.lastSize[0],o=2*(e.titleHeight+t.axisTitlePixelOffset)/t.lastSize[1];t.barSize[0]=t.boxSize[0],t.barPosition[0]=t.boxPosition[0],t.barSize[1]=t.boxSize[1]-o,t.barPosition[1]=t.boxPosition[1],r[0]=n}return r},e.recomputeBarSegments=n=>{const r=e.computeBarSize(n);t.barSegments=[];const o=[0,0],a=t.vertical?1:0,i=t.vertical?.01:.02;function s(e,n){t.barSegments.push({corners:[[...o],[o[0]+r[0],o[1]],[o[0]+r[0],o[1]+r[1]],[o[0],o[1]+r[1]]],scalars:n,title:e}),o[a]+=r[a]+i}t.renderable.getDrawNanAnnotation()&&t.renderable.getScalarsToColors().getNanColor()&&s(&quot;NaN&quot;,[NaN,NaN,NaN,NaN]),t.renderable.getDrawBelowRangeSwatch()&&t.renderable.getScalarsToColors().getUseBelowRangeColor?.()&&s(&quot;Below&quot;,[-.1,-.1,-.1,-.1]);const l=t.renderable.getScalarsToColors().getUseAboveRangeColor?.();o[a]+=i;const c=r[a];r[a]=l?1-2*i-r[a]-o[a]:1-i-o[a],s(&quot;ticks&quot;,t.vertical?[0,0,.995,.995]:[0,.995,.995,0]),t.renderable.getDrawAboveRangeSwatch()&&l&&(r[a]=c,o[a]+=i,s(&quot;Above&quot;,[1.1,1.1,1.1,1.1]))};const n=new Float64Array(3);e.createPolyDataForOneLabel=(e,r,o,a,i,s)=>{const l=t._tmAtlas.get(e);if(!l)return;let c=s.ptIdx,u=s.cellIdx;n[0]=(.5*r[0]+.5)*t.lastSize[0],n[1]=(.5*r[1]+.5)*t.lastSize[1],n[2]=r[2],n[0]+=i[0],n[1]+=i[1];const d=[],p=&quot;vertical&quot;===a?[1,0]:[0,1];&quot;vertical&quot;===a?(d[0]=l.width,d[1]=-l.height,&quot;middle&quot;===o[0]?n[1]-=l.width/2:&quot;right&quot;===o[0]&&(n[1]-=l.width),&quot;middle&quot;===o[1]?n[0]+=l.height/2:&quot;top&quot;===o[1]&&(n[0]+=l.height)):(d[0]=l.width,d[1]=l.height,&quot;middle&quot;===o[0]?n[0]-=l.width/2:&quot;right&quot;===o[0]&&(n[0]-=l.width),&quot;middle&quot;===o[1]?n[1]-=l.height/2:&quot;top&quot;===o[1]&&(n[1]-=l.height)),s.points[3*c]=n[0],s.points[3*c+1]=n[1],s.points[3*c+2]=n[2],s.tcoords[2*c]=l.tcoords[0],s.tcoords[2*c+1]=l.tcoords[1],c++,n[p[0]]+=d[0],s.points[3*c]=n[0],s.points[3*c+1]=n[1],s.points[3*c+2]=n[2],s.tcoords[2*c]=l.tcoords[2],s.tcoords[2*c+1]=l.tcoords[3],c++,n[p[1]]+=d[1],s.points[3*c]=n[0],s.points[3*c+1]=n[1],s.points[3*c+2]=n[2],s.tcoords[2*c]=l.tcoords[4],s.tcoords[2*c+1]=l.tcoords[5],c++,n[p[0]]-=d[0],s.points[3*c]=n[0],s.points[3*c+1]=n[1],s.points[3*c+2]=n[2],s.tcoords[2*c]=l.tcoords[6],s.tcoords[2*c+1]=l.tcoords[7],c++,s.polys[4*u]=3,s.polys[4*u+1]=c-4,s.polys[4*u+2]=c-3,s.polys[4*u+3]=c-2,u++,s.polys[4*u]=3,s.polys[4*u+1]=c-4,s.polys[4*u+2]=c-2,s.polys[4*u+3]=c-1,s.ptIdx+=4,s.cellIdx+=2};const r=new Float64Array(3);e.updatePolyDataForLabels=()=>{const n=e.getTickStrings().length+t.barSegments.length,o=4*n,a=2*n,i=new Float64Array(3*o),s=new Uint16Array(4*a),l=new Float32Array(2*o),c={ptIdx:0,cellIdx:0,polys:s,points:i,tcoords:l},u=t.vertical?0:1,d=t.vertical?1:0;r[2]=-.99;const p=t.vertical?[&quot;right&quot;,&quot;middle&quot;]:[&quot;middle&quot;,&quot;bottom&quot;];let f=[0,1];const g=[0,0];t.vertical?(g[0]=-t.tickLabelPixelOffset,t.topTitle?(r[0]=t.boxPosition[0]+.5*t.boxSize[0],r[1]=t.barPosition[1]+t.barSize[1],e.createPolyDataForOneLabel(t.renderable.getAxisLabel(),r,[&quot;middle&quot;,&quot;bottom&quot;],&quot;horizontal&quot;,[0,t.axisTitlePixelOffset],c)):(r[0]=t.barPosition[0]+t.barSize[0],r[1]=t.barPosition[1]+.5*t.barSize[1],e.createPolyDataForOneLabel(t.renderable.getAxisLabel(),r,[&quot;middle&quot;,&quot;top&quot;],&quot;vertical&quot;,[t.axisTitlePixelOffset,0],c)),f=[-1,0]):(g[1]=t.tickLabelPixelOffset,r[0]=t.barPosition[0]+.5*t.barSize[0],r[1]=t.barPosition[1]+t.barSize[1],e.createPolyDataForOneLabel(t.renderable.getAxisLabel(),r,[&quot;middle&quot;,&quot;bottom&quot;],&quot;horizontal&quot;,[0,t.axisTitlePixelOffset],c)),r[u]=t.barPosition[u]+(.5*f[u]+.5)*t.barSize[u],r[d]=t.barPosition[d]+.5*t.barSize[d];let m=null;for(let n=0;n<t.barSegments.length;n++){const o=t.barSegments[n];&quot;ticks&quot;===o.title?m=o:(r[d]=t.barPosition[d]+.5*t.barSize[d]*(o.corners[2][d]+o.corners[0][d]),e.createPolyDataForOneLabel(o.title,r,p,&quot;horizontal&quot;,g,c))}const h=t.barPosition[d]+t.barSize[d]*m.corners[0][d],v=t.barSize[d]*(m.corners[2][d]-m.corners[0][d]),T=e.getTicks(),y=e.getTickStrings(),b=e.getTickPositions();for(let n=0;n<T.length;n++){const o=b?b[n]:(T[n]-t.lastTickBounds[0])/(t.lastTickBounds[1]-t.lastTickBounds[0]);r[d]=h+v*o,e.createPolyDataForOneLabel(y[n],r,p,&quot;horizontal&quot;,g,c)}const x=xs.newInstance({numberOfComponents:2,values:l,name:&quot;TextureCoordinates&quot;});t.tmPolyData.getPointData().setTCoords(x),t.tmPolyData.getPoints().setData(i,3),t.tmPolyData.getPoints().modified(),t.tmPolyData.getPolys().setData(s,1),t.tmPolyData.getPolys().modified(),t.tmPolyData.modified()},e.updatePolyDataForBarSegments=()=>{const e=t.renderable.getScalarsToColors();let n=0;t.renderable.getDrawNanAnnotation()&&e.getNanColor()&&(n+=1),t.renderable.getDrawBelowRangeSwatch()&&e.getUseBelowRangeColor?.()&&(n+=1),t.renderable.getDrawAboveRangeSwatch()&&e.getUseAboveRangeColor?.()&&(n+=1);const o=4*(1+n),a=o;let i=1;e.getVectorMode()===op.COMPONENT&&(i=e.getVectorComponent()+1);const s=new Float64Array(3*o),l=new Uint16Array(5*a),c=new Float32Array(o*i);let u=0,d=0;for(let e=0;e<t.barSegments.length;e++){const n=t.barSegments[e];for(let e=0;e<4;e++){r[0]=t.barPosition[0]+n.corners[e][0]*t.barSize[0],r[1]=t.barPosition[1]+n.corners[e][1]*t.barSize[1],s[3*u]=(.5*r[0]+.5)*t.lastSize[0],s[3*u+1]=(.5*r[1]+.5)*t.lastSize[1],s[3*u+2]=r[2];for(let r=0;r<i;r++)c[u*i+r]=t.lastTickBounds[0]+n.scalars[e]*(t.lastTickBounds[1]-t.lastTickBounds[0]);u++}l[5*d]=4,l[5*d+1]=u-4,l[5*d+2]=u-3,l[5*d+3]=u-2,l[5*d+4]=u-1,d++}const p=xs.newInstance({numberOfComponents:i,values:c,name:&quot;Scalars&quot;});t.polyData.getPointData().setScalars(p),t.polyData.getPoints().setData(s,3),t.polyData.getPoints().modified(),t.polyData.getPolys().setData(l,1),t.polyData.getPolys().modified(),t.polyData.modified()}}(e,t)}),&quot;vtkScalarBarActorHelper&quot;);function up(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,function(e){return{automated:!0,autoLayout:null,axisLabel:&quot;Scalar Value&quot;,barPosition:[0,0],barSize:[0,0],boxPosition:[.88,-.92],boxSize:[.1,1.1],scalarToColors:null,axisTitlePixelOffset:36,axisTextStyle:{fontColor:&quot;white&quot;,fontStyle:&quot;normal&quot;,fontSize:void 0,fontFamily:&quot;serif&quot;},tickLabelPixelOffset:14,tickTextStyle:{fontColor:&quot;white&quot;,fontStyle:&quot;normal&quot;,fontSize:void 0,fontFamily:&quot;serif&quot;},generateTicks:null,drawNanAnnotation:!0,drawBelowRangeSwatch:!0,drawAboveRangeSwatch:!0,orientation:null,...e}}(n)),t.autoLayout||(t.autoLayout=sp(0,t)),t.generateTicks||(t.generateTicks=lp()),ss.extend(e,t,n),e.getProperty().setDiffuse(0),e.getProperty().setAmbient(1),Wt.setGet(e,t,[&quot;automated&quot;,&quot;autoLayout&quot;,&quot;axisTitlePixelOffset&quot;,&quot;axisLabel&quot;,&quot;scalarsToColors&quot;,&quot;tickLabelPixelOffset&quot;,&quot;generateTicks&quot;,&quot;drawNanAnnotation&quot;,&quot;drawBelowRangeSwatch&quot;,&quot;drawAboveRangeSwatch&quot;,&quot;orientation&quot;]),Wt.get(e,t,[&quot;axisTextStyle&quot;,&quot;tickTextStyle&quot;]),Wt.getArray(e,t,[&quot;barPosition&quot;,&quot;barSize&quot;,&quot;boxPosition&quot;,&quot;boxSize&quot;]),Wt.setArray(e,t,[&quot;barPosition&quot;,&quot;barSize&quot;,&quot;boxPosition&quot;,&quot;boxSize&quot;],2),function(e,t){t.classHierarchy.push(&quot;vtkScalarBarActor&quot;),e.setTickTextStyle=n=>{t.tickTextStyle={...t.tickTextStyle,...n},e.modified()},e.setAxisTextStyle=n=>{t.axisTextStyle={...t.axisTextStyle,...n},e.modified()},e.setOrientationToHorizontal=()=>e.setOrientation(ap.HORIZONTAL),e.setOrientationToVertical=()=>e.setOrientation(ap.VERTICAL),e.resetAutoLayoutToDefault=()=>{e.setAutoLayout(sp(0,t))},e.resetGenerateTicksToDefault=()=>{e.setGenerateTicks(lp())}}(e,t)}var dp={newInstance:Wt.newInstance(up,&quot;vtkScalarBarActor&quot;),extend:up,newScalarBarActorHelper:cp,...rp};const pp={};const fp=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,pp,n),qt.extend(e,t,n),t.scalarBarActorHelper=dp.newScalarBarActorHelper(),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLScalarBarActor&quot;),e.buildPass=n=>{n&&(t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getParent(),t.scalarBarActorHelper.getRenderable()||t.scalarBarActorHelper.setRenderable(t.renderable),e.prepareNodes(),e.addMissingNode(t.scalarBarActorHelper.getBarActor()),e.addMissingNode(t.scalarBarActorHelper.getTmActor()),e.removeUnusedNodes())},e.opaquePass=(e,n)=>{if(e){const e=t._openGLRenderer?t._openGLRenderer.getRenderable().getActiveCamera():null,n=t._openGLRenderer.getTiledSizeAndOrigin();t.scalarBarActorHelper.updateAPISpecificData([n.usize,n.vsize],e,t._openGLRenderWindow.getRenderable())}}}(e,t)}),&quot;vtkOpenGLScalarBarActor&quot;);Jt(&quot;vtkScalarBarActor&quot;,fp);const{vtkErrorMacro:gp}=Ht,mp={context:null};const hp=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,mp,n),qt.extend(e,t,n),t.openGLTexture=Pd.newInstance(),t.tris=ld.newInstance(),t.keyMatrixTime={},ht(t.keyMatrixTime,{mtime:0}),t.keyMatrices={normalMatrix:fe(new Float64Array(9)),mcwc:m(new Float64Array(16))},Ct(e,t,[&quot;context&quot;]),Tt(e,t,[&quot;activeTextures&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLSkybox&quot;),e.buildPass=n=>{if(n){t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getParent(),t.context=t._openGLRenderWindow.getContext(),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow),t.openGLTexture.setOpenGLRenderWindow(t._openGLRenderWindow);const n=t._openGLRenderer.getRenderable();t.openGLCamera=t._openGLRenderer.getViewNodeFor(n.getActiveCamera())}},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;n.incrementOpaqueActorCount()}},e.opaquePass=(n,r)=>{if(n&&!t._openGLRenderer.getSelector()){e.updateBufferObjects(),t.context.depthMask(!0),t._openGLRenderWindow.getShaderCache().readyShaderProgram(t.tris.getProgram()),t.openGLTexture.render(t._openGLRenderWindow);const n=t.openGLTexture.getTextureUnit();t.tris.getProgram().setUniformi(&quot;sbtexture&quot;,n);const r=t._openGLRenderer.getRenderable(),o=t.openGLCamera.getKeyMatrices(r),a=new Float64Array(16);if(v(a,o.wcpc),t.tris.getProgram().setUniformMatrix(&quot;IMCPCMatrix&quot;,a),&quot;box&quot;===t.lastFormat){const e=r.getActiveCamera().getPosition();t.tris.getProgram().setUniform3f(&quot;camPos&quot;,e[0],e[1],e[2])}t.tris.getVAO().bind(),t.context.drawArrays(t.context.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release(),t.openGLTexture.deactivate()}},e.updateBufferObjects=()=>{if(!t.tris.getCABO().getElementCount()){const e=new Float32Array(12);for(let t=0;t<4;t++)e[3*t]=t%2*2-1,e[3*t+1]=t>1?1:-1,e[3*t+2]=1;const n=xs.newInstance({numberOfComponents:3,values:e});n.setName(&quot;points&quot;);const r=new Uint16Array(8);r[0]=3,r[1]=0,r[2]=1,r[3]=3,r[4]=3,r[5]=0,r[6]=3,r[7]=2;const o=xs.newInstance({numberOfComponents:1,values:r});t.tris.getCABO().createVBO(o,&quot;polys&quot;,Zi.SURFACE,{points:n,cellOffset:0})}t.renderable.getFormat()!==t.lastFormat&&(t.lastFormat=t.renderable.getFormat(),&quot;box&quot;===t.lastFormat&&t.tris.setProgram(t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(&quot;//VTK::System::Dec\\n             attribute vec3 vertexMC;\\n             uniform mat4 IMCPCMatrix;\\n             varying vec3 TexCoords;\\n             void main () {\\n              gl_Position = vec4(vertexMC.xyz, 1.0);\\n              vec4 wpos = IMCPCMatrix * gl_Position;\\n              TexCoords = wpos.xyz/wpos.w;\\n             }&quot;,&quot;//VTK::System::Dec\\n             //VTK::Output::Dec\\n             varying vec3 TexCoords;\\n             uniform samplerCube sbtexture;\\n             uniform vec3 camPos;\\n             void main () {\\n               // skybox looks from inside out\\n               // which means we have to adjust\\n               // our tcoords. Otherwise text would\\n               // be flipped\\n               vec3 tc = normalize(TexCoords - camPos);\\n               if (abs(tc.z) < max(abs(tc.x),abs(tc.y)))\\n               {\\n                 tc = vec3(1.0, 1.0, -1.0) * tc;\\n               }\\n               else\\n               {\\n                 tc = vec3(-1.0, 1.0, 1.0) * tc;\\n               }\\n               gl_FragData[0] = textureCube(sbtexture, tc);\\n             }&quot;,&quot;&quot;)),&quot;background&quot;===t.lastFormat&&t.tris.setProgram(t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(&quot;//VTK::System::Dec\\n             attribute vec3 vertexMC;\\n             uniform mat4 IMCPCMatrix;\\n             varying vec2 TexCoords;\\n             void main () {\\n              gl_Position = vec4(vertexMC.xyz, 1.0);\\n              vec4 wpos = IMCPCMatrix * gl_Position;\\n              TexCoords = vec2(vertexMC.x, vertexMC.y)*0.5 + 0.5;\\n             }&quot;,&quot;//VTK::System::Dec\\n             //VTK::Output::Dec\\n             varying vec2 TexCoords;\\n             uniform sampler2D sbtexture;\\n             void main () {\\n               gl_FragData[0] = texture2D(sbtexture, TexCoords);\\n             }&quot;,&quot;&quot;)),t.tris.getShaderSourceTime().modified(),t.tris.getVAO().bind(),t.tris.getVAO().addAttributeArray(t.tris.getProgram(),t.tris.getCABO(),&quot;vertexMC&quot;,t.tris.getCABO().getVertexOffset(),t.tris.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||gp(&quot;Error setting vertexMC in shader VAO.&quot;));const e=t.renderable.getTextures();e.length||gp(&quot;vtkSkybox requires a texture map&quot;),t.openGLTexture.getRenderable()!==e[0]&&(t.openGLTexture.releaseGraphicsResources(t._openGLRenderWindow),t.openGLTexture.setRenderable(e[0]))}}(e,t)}));Jt(&quot;vtkSkybox&quot;,hp);const{FieldAssociations:vp}=Us,Tp={fieldAssociation:vp.FIELD_ASSOCIATION_CELLS,captureZValues:!1};function yp(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Tp,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;fieldAssociation&quot;,&quot;captureZValues&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkHardwareSelector&quot;),e.getSourceDataAsync=async(e,t,n,r,o)=>{},e.selectAsync=async(t,n,r,o,a)=>{const i=await e.getSourceDataAsync(t,n,r,o,a);return i?i.generateSelection(n,r,o,a):[]}}(e,t)}var bp={newInstance:Wt.newInstance(yp,&quot;vtkHardwareSelector&quot;),extend:yp};const xp={glFramebuffer:null,colorBuffers:null,depthTexture:null,previousDrawBinding:0,previousReadBinding:0,previousDrawBuffer:0,previousReadBuffer:0,previousActiveFramebuffer:null};function Cp(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,xp,n),ht(e,t),t.colorBuffers&&et(&quot;you cannot initialize colorBuffers through the constructor. You should call setColorBuffer() instead.&quot;),t.colorBuffers=[],St(e,t,[&quot;colorBuffers&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkFramebuffer&quot;),e.getBothMode=()=>t.context.FRAMEBUFFER,e.saveCurrentBindingsAndBuffers=t=>{const n=void 0!==t?t:e.getBothMode();e.saveCurrentBindings(n),e.saveCurrentBuffers(n)},e.saveCurrentBindings=e=>{if(!t.context)return void et(&quot;you must set the OpenGLRenderWindow before calling saveCurrentBindings&quot;);const n=t.context;t.previousDrawBinding=n.getParameter(t.context.FRAMEBUFFER_BINDING),t.previousActiveFramebuffer=t._openGLRenderWindow.getActiveFramebuffer()},e.saveCurrentBuffers=e=>{},e.restorePreviousBindingsAndBuffers=t=>{const n=void 0!==t?t:e.getBothMode();e.restorePreviousBindings(n),e.restorePreviousBuffers(n)},e.restorePreviousBindings=e=>{if(!t.context)return void et(&quot;you must set the OpenGLRenderWindow before calling restorePreviousBindings&quot;);const n=t.context;n.bindFramebuffer(n.FRAMEBUFFER,t.previousDrawBinding),t._openGLRenderWindow.setActiveFramebuffer(t.previousActiveFramebuffer)},e.restorePreviousBuffers=e=>{},e.bind=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:null;null===n&&(n=t.context.FRAMEBUFFER),t.context.bindFramebuffer(n,t.glFramebuffer);for(let e=0;e<t.colorBuffers.length;e++)t.colorBuffers[e].bind();t._openGLRenderWindow.setActiveFramebuffer(e)},e.create=(e,n)=>{t.context?(t.glFramebuffer=t.context.createFramebuffer(),t.glFramebuffer.width=e,t.glFramebuffer.height=n):et(&quot;you must set the OpenGLRenderWindow before calling create&quot;)},e.setColorBuffer=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;const r=t.context;if(!r)return void et(&quot;you must set the OpenGLRenderWindow before calling setColorBuffer&quot;);let o=r.COLOR_ATTACHMENT0;if(n>0){if(!t._openGLRenderWindow.getWebgl2())return void et(&quot;Using multiple framebuffer attachments requires WebGL 2&quot;);o+=n}t.colorBuffers[n]=e,r.framebufferTexture2D(r.FRAMEBUFFER,o,r.TEXTURE_2D,e.getHandle(),0)},e.removeColorBuffer=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;const n=t.context;if(!n)return void et(&quot;you must set the OpenGLRenderWindow before calling removeColorBuffer&quot;);let r=n.COLOR_ATTACHMENT0;if(e>0){if(!t._openGLRenderWindow.getWebgl2())return void et(&quot;Using multiple framebuffer attachments requires WebGL 2&quot;);r+=e}n.framebufferTexture2D(n.FRAMEBUFFER,r,n.TEXTURE_2D,null,0),t.colorBuffers=t.colorBuffers.splice(e,1)},e.setDepthBuffer=e=>{if(t.context)if(t._openGLRenderWindow.getWebgl2()){const n=t.context;n.framebufferTexture2D(n.FRAMEBUFFER,n.DEPTH_ATTACHMENT,n.TEXTURE_2D,e.getHandle(),0)}else et(&quot;Attaching depth buffer textures to fbo requires WebGL 2&quot;);else et(&quot;you must set the OpenGLRenderWindow before calling setDepthBuffer&quot;)},e.removeDepthBuffer=()=>{if(t.context)if(t._openGLRenderWindow.getWebgl2()){const e=t.context;e.framebufferTexture2D(e.FRAMEBUFFER,e.DEPTH_ATTACHMENT,e.TEXTURE_2D,null,0)}else et(&quot;Attaching depth buffer textures to framebuffers requires WebGL 2&quot;);else et(&quot;you must set the OpenGLRenderWindow before calling removeDepthBuffer&quot;)},e.getGLFramebuffer=()=>t.glFramebuffer,e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))},e.releaseGraphicsResources=()=>{t.glFramebuffer&&t.context.deleteFramebuffer(t.glFramebuffer)},e.getSize=()=>null==t.glFramebuffer?null:[t.glFramebuffer.width,t.glFramebuffer.height],e.populateFramebuffer=()=>{if(!t.context)return void et(&quot;you must set the OpenGLRenderWindow before calling populateFrameBuffer&quot;);e.bind();const n=t.context,r=Pd.newInstance();r.setOpenGLRenderWindow(t._openGLRenderWindow),r.setMinificationFilter(ud.LINEAR),r.setMagnificationFilter(ud.LINEAR),r.create2DFromRaw({width:t.glFramebuffer.width,height:t.glFramebuffer.height,numComps:4,dataType:cs.UNSIGNED_CHAR,data:null}),e.setColorBuffer(r),t.depthTexture=n.createRenderbuffer(),n.bindRenderbuffer(n.RENDERBUFFER,t.depthTexture),n.renderbufferStorage(n.RENDERBUFFER,n.DEPTH_COMPONENT16,t.glFramebuffer.width,t.glFramebuffer.height),n.framebufferRenderbuffer(n.FRAMEBUFFER,n.DEPTH_ATTACHMENT,n.RENDERBUFFER,t.depthTexture)},e.getColorTexture=()=>t.colorBuffers[0]}(e,t)}var Sp={newInstance:Mt(Cp,&quot;vtkFramebuffer&quot;),extend:Cp};const Ap={contentType:-1,fieldType:-1,properties:null,selectionList:[]};function Ip(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ap,n),Wt.obj(e,t),t.properties={},Wt.setGet(e,t,[&quot;contentType&quot;,&quot;fieldType&quot;,&quot;properties&quot;,&quot;selectionList&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkSelectionNode&quot;),e.getBounds=()=>t.points.getBounds()}(e,t)}var wp={newInstance:Wt.newInstance(Ip,&quot;vtkSelectionNode&quot;),extend:Ip,SelectionContent:{GLOBALIDS:0,PEDIGREEIDS:1,VALUES:2,INDICES:3,FRUSTUM:4,LOCATIONS:5,THRESHOLDS:6,BLOCKS:7,QUERY:8},SelectionField:{CELL:0,POINT:1,FIELD:2,VERTEX:3,EDGE:4,ROW:5}};const{PassTypes:Op}=Il,{SelectionContent:Pp,SelectionField:Rp}=wp,{FieldAssociations:Mp}=Us,{vtkErrorMacro:Ep}=Wt;function Vp(e){return`${e.propID} ${e.compositeID}`}function Dp(e,t,n,r){return n?n[4*(t*(r[2]-r[0]+1)+e)+3]:0}function Lp(e,t,n,r){if(!n)return 0;const o=4*(t*(r[2]-r[0]+1)+e),a=n[o],i=n[o+1];return 256*(256*n[o+2]+i)+a}function Bp(e,t){let n=t;return n<<=24,n|=e,n}function Np(e,t,n,r){const o=n<0?0:n;if(0===o){if(r[0]=t[0],r[1]=t[1],t[0]<e.area[0]||t[0]>e.area[2]||t[1]<e.area[1]||t[1]>e.area[3])return null;const n=[t[0]-e.area[0],t[1]-e.area[1]],o=Lp(n[0],n[1],e.pixBuffer[Op.ACTOR_PASS],e.area);if(o<=0||o-1>=e.props.length)return null;const a={valid:!0};a.propID=o-1,a.prop=e.props[a.propID];let i=Lp(n[0],n[1],e.pixBuffer[Op.COMPOSITE_INDEX_PASS],e.area);if((i<0||i>16777215)&&(i=0),a.compositeID=i-1,e.captureZValues){const r=4*(n[1]*(e.area[2]-e.area[0]+1)+n[0]);a.zValue=(256*e.zBuffer[r]+e.zBuffer[r+1])/65535,a.displayPosition=t}if(e.pixBuffer[Op.ID_LOW24]&&0===Dp(n[0],n[1],e.pixBuffer[Op.ID_LOW24],e.area))return a;const s=Lp(n[0],n[1],e.pixBuffer[Op.ID_LOW24],e.area),l=Lp(n[0],n[1],e.pixBuffer[Op.ID_HIGH24],e.area);return a.attributeID=Bp(s,l),a}const a=[t[0],t[1]],i=[0,0];let s=Np(e,t,0,r);if(s&&s.valid)return s;for(let t=1;t<o;++t){for(let n=a[1]>t?a[1]-t:0;n<=a[1]+t;++n){if(i[1]=n,a[0]>=t&&(i[0]=a[0]-t,s=Np(e,i,0,r),s&&s.valid))return s;if(i[0]=a[0]+t,s=Np(e,i,0,r),s&&s.valid)return s}for(let n=a[0]>=t?a[0]-(t-1):0;n<=a[0]+(t-1);++n){if(i[0]=n,a[1]>=t&&(i[1]=a[1]-t,s=Np(e,i,0,r),s&&s.valid))return s;if(i[1]=a[1]+t,s=Np(e,i,0,r),s&&s.valid)return s}}return r[0]=t[0],r[1]=t[1],null}function Fp(e,t,n,r,o){const a=[];let i=0;return t.forEach(((t,s)=>{const l=wp.newInstance();switch(l.setContentType(Pp.INDICES),e){case Mp.FIELD_ASSOCIATION_CELLS:l.setFieldType(Rp.CELL);break;case Mp.FIELD_ASSOCIATION_POINTS:l.setFieldType(Rp.POINT);break;default:Ep(&quot;Unknown field association&quot;)}l.getProperties().propID=t.info.propID,l.getProperties().prop=t.info.prop,l.getProperties().compositeID=t.info.compositeID,l.getProperties().attributeID=t.info.attributeID,l.getProperties().pixelCount=t.pixelCount,n&&(l.getProperties().displayPosition=[t.info.displayPosition[0],t.info.displayPosition[1],t.info.zValue],l.getProperties().worldPosition=o.displayToWorld(t.info.displayPosition[0],t.info.displayPosition[1],t.info.zValue,r)),l.setSelectionList(t.attributeIDs),a[i]=l,i++})),a}const _p={area:void 0,currentPass:-1,propColorValue:null,props:null,maximumPointId:0,maximumCellId:0,idOffset:1};function kp(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,_p,n),bp.extend(e,t,n),t.propColorValue=[0,0,0],t.props=[],t.area||(t.area=[0,0,0,0]),Wt.setGetArray(e,t,[&quot;area&quot;],4),Wt.setGet(e,t,[&quot;_renderer&quot;,&quot;currentPass&quot;,&quot;_openGLRenderWindow&quot;,&quot;maximumPointId&quot;,&quot;maximumCellId&quot;]),Wt.setGetArray(e,t,[&quot;propColorValue&quot;],3),Wt.moveToProtected(e,t,[&quot;renderer&quot;,&quot;openGLRenderWindow&quot;]),Wt.event(e,t,&quot;event&quot;),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLHardwareSelector&quot;),e.releasePixBuffers=()=>{t.rawPixBuffer=[],t.pixBuffer=[],t.zBuffer=null},e.beginSelection=()=>{t._openGLRenderer=t._openGLRenderWindow.getViewNodeFor(t._renderer),t.maxAttributeId=0;const n=t._openGLRenderWindow.getSize();if(t.framebuffer){t.framebuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.framebuffer.saveCurrentBindingsAndBuffers();const e=t.framebuffer.getSize();e&&e[0]===n[0]&&e[1]===n[1]?t.framebuffer.bind():(t.framebuffer.create(n[0],n[1]),t.framebuffer.populateFramebuffer())}else t.framebuffer=Sp.newInstance(),t.framebuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.framebuffer.saveCurrentBindingsAndBuffers(),t.framebuffer.create(n[0],n[1]),t.framebuffer.populateFramebuffer();if(t._openGLRenderer.clear(),t._openGLRenderer.setSelector(e),t.hitProps={},t.propPixels={},t.props=[],e.releasePixBuffers(),t.fieldAssociation===Mp.FIELD_ASSOCIATION_POINTS){const e=t._openGLRenderWindow.getContext(),n=e.isEnabled(e.BLEND);e.disable(e.BLEND),t._openGLRenderWindow.traverseAllPasses(),n&&e.enable(e.BLEND)}},e.endSelection=()=>{t.hitProps={},t._openGLRenderer.setSelector(null),t.framebuffer.restorePreviousBindingsAndBuffers()},e.preCapturePass=()=>{const e=t._openGLRenderWindow.getContext();t.originalBlending=e.isEnabled(e.BLEND),e.disable(e.BLEND)},e.postCapturePass=()=>{const e=t._openGLRenderWindow.getContext();t.originalBlending&&e.enable(e.BLEND)},e.select=()=>{let n=null;return e.captureBuffers()&&(n=e.generateSelection(t.area[0],t.area[1],t.area[2],t.area[3]),e.releasePixBuffers()),n},e.getSourceDataAsync=async(n,r,o,a,i)=>{if(t._renderer=n,void 0===r){const n=t._openGLRenderWindow.getSize();e.setArea(0,0,n[0]-1,n[1]-1)}else e.setArea(r,o,a,i);if(!e.captureBuffers())return!1;const s={area:[...t.area],pixBuffer:[...t.pixBuffer],captureZValues:t.captureZValues,zBuffer:t.zBuffer,props:[...t.props],fieldAssociation:t.fieldAssociation,renderer:n,openGLRenderWindow:t._openGLRenderWindow,generateSelection:function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return function(e,t,n,r,o){const a=Math.floor(t),i=Math.floor(n),s=Math.floor(r),l=Math.floor(o),c=new Map,u=[0,0];for(let t=i;t<=l;t++)for(let n=a;n<=s;n++){const r=Np(e,[n,t],0,u);if(r&&r.valid){const t=Vp(r);if(c.has(t)){const n=c.get(t);n.pixelCount++,e.captureZValues&&r.zValue<n.info.zValue&&(n.info=r),-1===n.attributeIDs.indexOf(r.attributeID)&&n.attributeIDs.push(r.attributeID)}else c.set(t,{info:r,pixelCount:1,attributeIDs:[r.attributeID]})}}return Fp(e.fieldAssociation,c,e.captureZValues,e.renderer,e.openGLRenderWindow)}(s,...t)}};return s},e.captureBuffers=()=>{if(!t._renderer||!t._openGLRenderWindow)return Ep(&quot;Renderer and view must be set before calling Select.&quot;),!1;t._openGLRenderer=t._openGLRenderWindow.getViewNodeFor(t._renderer),t._openGLRenderWindow.getRenderable().preRender(),e.invokeEvent({type:&quot;StartEvent&quot;}),t.originalBackground=t._renderer.getBackgroundByReference(),t._renderer.setBackground(0,0,0,0);const n=t._openGLRenderWindow.getRenderPasses();e.beginSelection();const r=[];for(t.currentPass=Op.MIN_KNOWN_PASS;t.currentPass<=Op.MAX_KNOWN_PASS;t.currentPass++)e.passRequired(t.currentPass)&&(e.preCapturePass(t.currentPass),t.captureZValues&&t.currentPass===Op.ACTOR_PASS&&&quot;function&quot;==typeof n[0].requestDepth&&&quot;function&quot;==typeof n[0].getFramebuffer?(n[0].requestDepth(),t._openGLRenderWindow.traverseAllPasses()):t._openGLRenderWindow.traverseAllPasses(),e.postCapturePass(t.currentPass),e.savePixelBuffer(t.currentPass),r.push(t.currentPass));return r.forEach((n=>{t.currentPass=n,e.processPixelBuffers()})),t.currentPass=Op.MAX_KNOWN_PASS,e.endSelection(),t._renderer.setBackground(t.originalBackground),e.invokeEvent({type:&quot;EndEvent&quot;}),!0},e.processPixelBuffers=()=>{t.props.forEach(((n,r)=>{e.isPropHit(r)&&n.processSelectorPixelBuffers(e,t.propPixels[r])}))},e.passRequired=e=>{if(e===Op.ID_HIGH24){if(t.fieldAssociation===Mp.FIELD_ASSOCIATION_POINTS)return t.maximumPointId>16777215;if(t.fieldAssociation===Mp.FIELD_ASSOCIATION_CELLS)return t.maximumCellId>16777215}return!0},e.savePixelBuffer=n=>{if(t.pixBuffer[n]=t._openGLRenderWindow.getPixelData(t.area[0],t.area[1],t.area[2],t.area[3]),!t.rawPixBuffer[n]){const e=(t.area[2]-t.area[0]+1)*(t.area[3]-t.area[1]+1)*4;t.rawPixBuffer[n]=new Uint8Array(e),t.rawPixBuffer[n].set(t.pixBuffer[n])}if(n===Op.ACTOR_PASS){if(t.captureZValues){const e=t._openGLRenderWindow.getRenderPasses();if(&quot;function&quot;==typeof e[0].requestDepth&&&quot;function&quot;==typeof e[0].getFramebuffer){const n=e[0].getFramebuffer();n.saveCurrentBindingsAndBuffers(),n.bind(),t.zBuffer=t._openGLRenderWindow.getPixelData(t.area[0],t.area[1],t.area[2],t.area[3]),n.restorePreviousBindingsAndBuffers()}}e.buildPropHitList(t.rawPixBuffer[n])}},e.buildPropHitList=e=>{let n=0;for(let r=0;r<=t.area[3]-t.area[1];r++)for(let o=0;o<=t.area[2]-t.area[0];o++){let a=Lp(o,r,e,t.area);a>0&&(a--,a in t.hitProps||(t.hitProps[a]=!0,t.propPixels[a]=[]),t.propPixels[a].push(4*n)),++n}},e.renderProp=n=>{t.currentPass===Op.ACTOR_PASS&&(e.setPropColorValueFromInt(t.props.length+1),t.props.push(n))},e.renderCompositeIndex=n=>{t.currentPass===Op.COMPOSITE_INDEX_PASS&&e.setPropColorValueFromInt(n+1)},e.renderAttributeId=e=>{e<0||(t.maxAttributeId=e>t.maxAttributeId?e:t.maxAttributeId)},e.passTypeToString=e=>Wt.enumToString(Op,e),e.isPropHit=e=>Boolean(t.hitProps[e]),e.setPropColorValueFromInt=e=>{t.propColorValue[0]=e%256/255,t.propColorValue[1]=Math.floor(e/256)%256/255,t.propColorValue[2]=Math.floor(e/65536)%256/255},e.getPixelInformation=(n,r,o)=>{const a=r<0?0:r;if(0===a){if(o[0]=n[0],o[1]=n[1],n[0]<t.area[0]||n[0]>t.area[2]||n[1]<t.area[1]||n[1]>t.area[3])return null;const e=[n[0]-t.area[0],n[1]-t.area[1]],r=Lp(e[0],e[1],t.pixBuffer[Op.ACTOR_PASS],t.area);if(r<=0||r-1>=t.props.length)return null;const a={valid:!0};a.propID=r-1,a.prop=t.props[a.propID];let i=Lp(e[0],e[1],t.pixBuffer[Op.COMPOSITE_INDEX_PASS],t.area);if((i<0||i>16777215)&&(i=0),a.compositeID=i-1,t.captureZValues){const r=4*(e[1]*(t.area[2]-t.area[0]+1)+e[0]);a.zValue=(256*t.zBuffer[r]+t.zBuffer[r+1])/65535,a.displayPosition=n}if(t.pixBuffer[Op.ID_LOW24]&&0===Dp(e[0],e[1],t.pixBuffer[Op.ID_LOW24],t.area))return a;const s=Lp(e[0],e[1],t.pixBuffer[Op.ID_LOW24],t.area),l=Lp(e[0],e[1],t.pixBuffer[Op.ID_HIGH24],t.area);return a.attributeID=Bp(s,l),a}const i=[n[0],n[1]],s=[0,0];let l=e.getPixelInformation(n,0,o);if(l&&l.valid)return l;for(let t=1;t<a;++t){for(let n=i[1]>t?i[1]-t:0;n<=i[1]+t;++n){if(s[1]=n,i[0]>=t&&(s[0]=i[0]-t,l=e.getPixelInformation(s,0,o),l&&l.valid))return l;if(s[0]=i[0]+t,l=e.getPixelInformation(s,0,o),l&&l.valid)return l}for(let n=i[0]>=t?i[0]-(t-1):0;n<=i[0]+(t-1);++n){if(s[0]=n,i[1]>=t&&(s[1]=i[1]-t,l=e.getPixelInformation(s,0,o),l&&l.valid))return l;if(s[1]=i[1]+t,l=e.getPixelInformation(s,0,o),l&&l.valid)return l}}return o[0]=n[0],o[1]=n[1],null},e.generateSelection=(n,r,o,a)=>{const i=Math.floor(n),s=Math.floor(r),l=Math.floor(o),c=Math.floor(a),u=new Map,d=[0,0];for(let n=s;n<=c;n++)for(let r=i;r<=l;r++){const o=[r,n],a=e.getPixelInformation(o,0,d);if(a&&a.valid){const e=Vp(a);if(u.has(e)){const n=u.get(e);n.pixelCount++,t.captureZValues&&a.zValue<n.info.zValue&&(n.info=a),-1===n.attributeIDs.indexOf(a.attributeID)&&n.attributeIDs.push(a.attributeID)}else u.set(e,{info:a,pixelCount:1,attributeIDs:[a.attributeID]})}}return Fp(t.fieldAssociation,u,t.captureZValues,t._renderer,t._openGLRenderWindow)},e.getRawPixelBuffer=e=>t.rawPixBuffer[e],e.getPixelBuffer=e=>t.pixBuffer[e],e.attach=(e,n)=>{t._openGLRenderWindow=e,t._renderer=n};const n=e.setArea;e.setArea=function(){return!!n(...arguments)&&(t.area[0]=Math.floor(t.area[0]),t.area[1]=Math.floor(t.area[1]),t.area[2]=Math.floor(t.area[2]),t.area[3]=Math.floor(t.area[3]),!0)}}(e,t)}var Gp={newInstance:Wt.newInstance(kp,&quot;vtkOpenGLHardwareSelector&quot;),extend:kp,...Il};const{vtkErrorMacro:Up}=Ht,{Representation:zp}=os,{ObjectType:Wp}=zu,{PassTypes:Hp}=Gp,jp={type:&quot;StartEvent&quot;},Kp={type:&quot;EndEvent&quot;};function $p(e,t,n){e[12]=(e[12]-t[0])*n[0],e[13]=(e[13]-t[1])*n[1],e[14]=(e[14]-t[2])*n[2],e[0]*=n[0],e[5]*=n[1],e[10]*=n[2]}const qp={normalMatrix:null,mcpcMatrix:null,mcwcMatrix:null};const Xp=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,qp,n),$d.extend(e,t,n),t.tmpMat3=fe(new Float64Array(9)),t.normalMatrix=fe(new Float64Array(9)),t.mcpcMatrix=m(new Float64Array(16)),t.mcvcMatrix=m(new Float64Array(16)),t.tmpColor=[],t.glyphBOBuildTime={},ht(t.glyphBOBuildTime,{mtime:0}),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLGlyph3DMapper&quot;);const n={...e};e.renderPiece=(n,r)=>{if(e.invokeEvent(jp),t.renderable.getStatic()||t.renderable.update(),t.currentInput=t.renderable.getInputData(1),e.invokeEvent(Kp),!t.currentInput)return void Up(&quot;No input!&quot;);if(!t.currentInput.getPoints||!t.currentInput.getPoints().getNumberOfValues())return;const o=t.context;t._openGLRenderWindow.getWebgl2()?(t.hardwareSupport=!0,t.extension=null):t.extension||(t.extension=t.context.getExtension(&quot;ANGLE_instanced_arrays&quot;),t.hardwareSupport=!!t.extension);const a=r.getProperty().getBackfaceCulling(),i=r.getProperty().getFrontfaceCulling();a||i?i?(t._openGLRenderWindow.enableCullFace(),o.cullFace(o.FRONT)):(t._openGLRenderWindow.enableCullFace(),o.cullFace(o.BACK)):t._openGLRenderWindow.disableCullFace(),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r)},e.multiply4x4WithOffset=(e,t,n,r)=>{const o=t[0],a=t[1],i=t[2],s=t[3],l=t[4],c=t[5],u=t[6],d=t[7],p=t[8],f=t[9],g=t[10],m=t[11],h=t[12],v=t[13],T=t[14],y=t[15];let b=n[r],x=n[r+1],C=n[r+2],S=n[r+3];e[0]=b*o+x*l+C*p+S*h,e[1]=b*a+x*c+C*f+S*v,e[2]=b*i+x*u+C*g+S*T,e[3]=b*s+x*d+C*m+S*y,b=n[r+4],x=n[r+5],C=n[r+6],S=n[r+7],e[4]=b*o+x*l+C*p+S*h,e[5]=b*a+x*c+C*f+S*v,e[6]=b*i+x*u+C*g+S*T,e[7]=b*s+x*d+C*m+S*y,b=n[r+8],x=n[r+9],C=n[r+10],S=n[r+11],e[8]=b*o+x*l+C*p+S*h,e[9]=b*a+x*c+C*f+S*v,e[10]=b*i+x*u+C*g+S*T,e[11]=b*s+x*d+C*m+S*y,b=n[r+12],x=n[r+13],C=n[r+14],S=n[r+15],e[12]=b*o+x*l+C*p+S*h,e[13]=b*a+x*c+C*f+S*v,e[14]=b*i+x*u+C*g+S*T,e[15]=b*s+x*d+C*m+S*y},e.replaceShaderNormal=(e,r,o)=>{if(t.hardwareSupport&&t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;)>0){let n=e.Vertex;t.lastBoundBO.getCABO().getNormalOffset()&&(n=td.substitute(n,&quot;//VTK::Normal::Dec&quot;,[&quot;attribute vec3 normalMC;&quot;,&quot;attribute mat3 gNormal;&quot;,&quot;uniform mat3 normalMatrix;&quot;,&quot;varying vec3 normalVCVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::Normal::Impl&quot;,[&quot;normalVCVSOutput = normalMatrix * gNormal * normalMC;&quot;]).result),e.Vertex=n}n.replaceShaderNormal(e,r,o)},e.replaceShaderClip=(e,r,o)=>{if(t.hardwareSupport){let n=e.Vertex,r=e.Fragment;if(t.renderable.getNumberOfClippingPlanes()){const e=t.renderable.getNumberOfClippingPlanes();n=td.substitute(n,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,`uniform vec4 clipPlanes[${e}];`,`varying float clipDistancesVSOutput[${e}];`]).result,n=td.substitute(n,&quot;//VTK::Clip::Impl&quot;,[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    vec4 gVertex = gMatrix * vertexMC;&quot;,&quot;    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], gVertex);&quot;,&quot;    }&quot;]).result,r=td.substitute(r,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,`varying float clipDistancesVSOutput[${e}];`]).result,r=td.substitute(r,&quot;//VTK::Clip::Impl&quot;,[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    if (clipDistancesVSOutput[planeNum] < 0.0) discard;&quot;,&quot;    }&quot;]).result}e.Vertex=n,e.Fragment=r}n.replaceShaderClip(e,r,o)},e.replaceShaderColor=(e,r,o)=>{if(t.hardwareSupport&&t.renderable.getColorArray()){let n=e.Vertex,r=e.Geometry,o=e.Fragment;const a=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);let i=[&quot;uniform float ambient;&quot;,&quot;uniform float diffuse;&quot;,&quot;uniform float specular;&quot;,&quot;uniform float opacityUniform; // the fragment opacity&quot;];a&&(i=i.concat([&quot;uniform vec3 specularColorUniform;&quot;,&quot;uniform float specularPowerUniform;&quot;]));let s=[&quot;vec3 ambientColor;&quot;,&quot;  vec3 diffuseColor;&quot;,&quot;  float opacity;&quot;];a&&(s=s.concat([&quot;  vec3 specularColor;&quot;,&quot;  float specularPower;&quot;])),s=s.concat([&quot;  opacity = opacityUniform;&quot;]),a&&(s=s.concat([&quot;  specularColor = specularColorUniform;&quot;,&quot;  specularPower = specularPowerUniform;&quot;])),t.drawingEdges||(i=i.concat([&quot;varying vec4 vertexColorVSOutput;&quot;]),n=td.substitute(n,&quot;//VTK::Color::Dec&quot;,[&quot;attribute vec4 gColor;&quot;,&quot;varying vec4 vertexColorVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorVSOutput = gColor;&quot;]).result,r=td.substitute(r,&quot;//VTK::Color::Dec&quot;,[&quot;in vec4 vertexColorVSOutput[];&quot;,&quot;out vec4 vertexColorGSOutput;&quot;]).result,r=td.substitute(r,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorGSOutput = vertexColorVSOutput[i];&quot;]).result,s=s.concat([&quot;  diffuseColor = vertexColorVSOutput.rgb;&quot;,&quot;  ambientColor = vertexColorVSOutput.rgb;&quot;,&quot;  opacity = opacity*vertexColorVSOutput.a;&quot;])),o=td.substitute(o,&quot;//VTK::Color::Impl&quot;,s).result,o=td.substitute(o,&quot;//VTK::Color::Dec&quot;,i).result,e.Vertex=n,e.Geometry=r,e.Fragment=o}n.replaceShaderColor(e,r,o)},e.replaceShaderPositionVC=(e,r,o)=>{if(t.hardwareSupport){let n=e.Vertex;t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;)>0?(n=td.substitute(n,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vec4 gVertexMC = gMatrix * vertexMC;&quot;,&quot;vertexVCVSOutput = MCVCMatrix * gVertexMC;&quot;,&quot;  gl_Position = MCPCMatrix * gVertexMC;&quot;]).result,n=td.substitute(n,&quot;//VTK::Camera::Dec&quot;,[&quot;attribute mat4 gMatrix;&quot;,&quot;uniform mat4 MCPCMatrix;&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result):(n=td.substitute(n,&quot;//VTK::Camera::Dec&quot;,[&quot;attribute mat4 gMatrix;&quot;,&quot;uniform mat4 MCPCMatrix;&quot;]).result,n=td.substitute(n,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vec4 gVertexMC = gMatrix * vertexMC;&quot;,&quot;  gl_Position = MCPCMatrix * gVertexMC;&quot;]).result),e.Vertex=n}n.replaceShaderPositionVC(e,r,o)},e.replaceShaderPicking=(e,r,o)=>{if(t.hardwareSupport){let t=e.Fragment,n=e.Vertex;n=td.substitute(n,&quot;//VTK::Picking::Dec&quot;,[&quot;attribute vec3 mapperIndexVS;&quot;,&quot;varying vec3 mapperIndexVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::Picking::Impl&quot;,&quot;  mapperIndexVSOutput = mapperIndexVS;&quot;).result,e.Vertex=n,t=td.substitute(t,&quot;//VTK::Picking::Dec&quot;,[&quot;varying vec3 mapperIndexVSOutput;&quot;,&quot;uniform vec3 mapperIndex;&quot;,&quot;uniform int picking;&quot;]).result,t=td.substitute(t,&quot;//VTK::Picking::Impl&quot;,[&quot;  vec4 pickColor = picking == 2 ? vec4(mapperIndexVSOutput,1.0) : vec4(mapperIndex,1.0);&quot;,&quot;  gl_FragData[0] = picking != 0 ? pickColor : gl_FragData[0];&quot;]).result,e.Fragment=t}else n.replaceShaderPicking(e,r,o)},e.updateGlyphShaderParameters=(n,r,o,a,i,s,l,c)=>{const u=o.getProgram();if(n){const e=t.normalMatrix,n=s,r=9*l,o=t.tmpMat3,a=e[0],i=e[1],c=e[2],d=e[3],p=e[4],f=e[5],g=e[6],m=e[7],h=e[8],v=n[r],T=n[r+1],y=n[r+2],b=n[r+3],x=n[r+4],C=n[r+5],S=n[r+6],A=n[r+7],I=n[r+8];o[0]=v*a+T*d+y*g,o[1]=v*i+T*p+y*m,o[2]=v*c+T*f+y*h,o[3]=b*a+x*d+C*g,o[4]=b*i+x*p+C*m,o[5]=b*c+x*f+C*h,o[6]=S*a+A*d+I*g,o[7]=S*i+A*p+I*m,o[8]=S*c+A*f+I*h,u.setUniformMatrix3x3(&quot;normalMatrix&quot;,t.tmpMat3)}if(e.multiply4x4WithOffset(t.tmpMat4,t.mcpcMatrix,i,16*l),u.setUniformMatrix(&quot;MCPCMatrix&quot;,t.tmpMat4),r&&(e.multiply4x4WithOffset(t.tmpMat4,t.mcvcMatrix,i,16*l),u.setUniformMatrix(&quot;MCVCMatrix&quot;,t.tmpMat4)),a){const e=a.getData();t.tmpColor[0]=e[4*l]/255,t.tmpColor[1]=e[4*l+1]/255,t.tmpColor[2]=e[4*l+2]/255,u.setUniform3fArray(&quot;ambientColorUniform&quot;,t.tmpColor),u.setUniform3fArray(&quot;diffuseColorUniform&quot;,t.tmpColor)}c&&u.setUniform3fArray(&quot;mapperIndex&quot;,c.getPropColorValue())},e.renderPieceDraw=(n,r)=>{const o=r.getProperty().getRepresentation(),a=t.context,i=r.getProperty().getEdgeVisibility()&&o===zp.SURFACE,s=t.openGLCamera.getKeyMatrices(n),l=t.openGLActor.getKeyMatrices();Te(t.normalMatrix,s.normalMatrix,l.normalMatrix),b(t.mcpcMatrix,s.wcpc,l.mcwc),b(t.mcvcMatrix,s.wcvc,l.mcwc);const c=t.renderable.getMatrixArray(),u=t.renderable.getNormalArray(),d=t.renderable.getColorArray(),p=c.length/16;let f=!1;t._openGLRenderer.getSelector()&&t._openGLRenderer.getSelector().getCurrentPass()===Hp.COMPOSITE_INDEX_PASS&&(f=!0);for(let s=t.primTypes.Start;s<t.primTypes.End;s++){const l=t.primitives[s].getCABO();if(l.getElementCount()){t.drawingEdges=i&&(s===t.primTypes.TrisEdges||s===t.primTypes.TriStripsEdges),t.lastBoundBO=t.primitives[s],t.primitives[s].updateShaders(n,r,e);const g=t.primitives[s].getProgram(),m=t.primitives[s].getOpenGLMode(o),h=g.isUniformUsed(&quot;normalMatrix&quot;),v=g.isUniformUsed(&quot;MCVCMatrix&quot;);if(t.hardwareSupport)t.extension?t.extension.drawArraysInstancedANGLE(m,0,l.getElementCount(),p):a.drawArraysInstanced(m,0,l.getElementCount(),p);else for(let n=0;n<p;++n)f&&t._openGLRenderer.getSelector().renderCompositeIndex(n),e.updateGlyphShaderParameters(h,v,t.primitives[s],d,c,u,n,f?t._openGLRenderer.getSelector():null),a.drawArrays(m,0,l.getElementCount())}}},e.setMapperShaderParameters=(e,r,o)=>{if(e.getCABO().getElementCount()&&(t.glyphBOBuildTime.getMTime()>e.getAttributeUpdateTime().getMTime()||e.getShaderSourceTime().getMTime()>e.getAttributeUpdateTime().getMTime()))return e.getProgram().isAttributeUsed(&quot;gMatrix&quot;)?e.getVAO().addAttributeMatrixWithDivisor(e.getProgram(),t.matrixBuffer,&quot;gMatrix&quot;,0,64,t.context.FLOAT,4,!1,1)||Up(&quot;Error setting gMatrix in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;gMatrix&quot;),e.getProgram().isAttributeUsed(&quot;gNormal&quot;)?e.getVAO().addAttributeMatrixWithDivisor(e.getProgram(),t.normalBuffer,&quot;gNormal&quot;,0,36,t.context.FLOAT,3,!1,1)||Up(&quot;Error setting gNormal in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;gNormal&quot;),e.getProgram().isAttributeUsed(&quot;gColor&quot;)?e.getVAO().addAttributeArrayWithDivisor(e.getProgram(),t.colorBuffer,&quot;gColor&quot;,0,4,t.context.UNSIGNED_BYTE,4,!0,1,!1)||Up(&quot;Error setting gColor in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;gColor&quot;),e.getProgram().isAttributeUsed(&quot;mapperIndexVS&quot;)?e.getVAO().addAttributeArrayWithDivisor(e.getProgram(),t.pickBuffer,&quot;mapperIndexVS&quot;,0,4,t.context.UNSIGNED_BYTE,4,!0,1,!1)||Up(&quot;Error setting mapperIndexVS in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;mapperIndexVS&quot;),n.setMapperShaderParameters(e,r,o),void e.getAttributeUpdateTime().modified();n.setMapperShaderParameters(e,r,o)},e.getNeedToRebuildBufferObjects=(e,r)=>(t.renderable.buildArrays(),t.VBOBuildTime.getMTime()<t.renderable.getBuildTime().getMTime()||n.getNeedToRebuildBufferObjects(e,r)),e.getNeedToRebuildShaders=(e,r,o)=>!!(n.getNeedToRebuildShaders(e,r,o)||e.getShaderSourceTime().getMTime()<t.renderable.getMTime()||e.getShaderSourceTime().getMTime()<t.currentInput.getMTime()),e.buildBufferObjects=(e,r)=>{const o=t.renderable.getMatrixArray(),a=t.renderable.getInputData(0).getPoints(),{useShiftAndScale:i,coordShift:s,coordScale:l}=Wu(a);if(t.hardwareSupport){const e=t.renderable.getNormalArray(),n=t.renderable.getColorArray();if(t.matrixBuffer||(t.matrixBuffer=zu.newInstance(),t.matrixBuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.normalBuffer=zu.newInstance(),t.normalBuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.colorBuffer=zu.newInstance(),t.colorBuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.pickBuffer=zu.newInstance(),t.pickBuffer.setOpenGLRenderWindow(t._openGLRenderWindow)),i){const e=o.buffer;for(let t=0;t<o.byteLength;t+=64)$p(new Float32Array(e,t,16),s,l)}if(t.renderable.getBuildTime().getMTime()>t.glyphBOBuildTime.getMTime()){t.matrixBuffer.upload(o,Wp.ARRAY_BUFFER),t.normalBuffer.upload(e,Wp.ARRAY_BUFFER),n?t.colorBuffer.upload(n.getData(),Wp.ARRAY_BUFFER):t.colorBuffer.releaseGraphicsResources();const r=o.length/16,a=new Uint8Array(4*r);for(let e=0;e<r;++e){let t=e+1;const n=4*e;a[n]=t%256,t-=a[n],t/=256,a[n+1]=t%256,t-=a[n+1],t/=256,a[n+2]=t%256,a[n+3]=255}t.pickBuffer.upload(a,Wp.ARRAY_BUFFER),t.glyphBOBuildTime.modified()}}if(n.buildBufferObjects(e,r),i)for(let e=ad.Start;e<ad.End;e++)t.primitives[e].getCABO().setCoordShiftAndScale(s,l)}}(e,t)}),&quot;vtkOpenGLGlyph3DMapper&quot;);Jt(&quot;vtkGlyph3DMapper&quot;,Xp);const{vtkErrorMacro:Yp}=Wt;class Zp{constructor(){this.segmentMapping={},this.segments=[null],this.faces=[]}addSegment(e){const t=e[0],n=e[e.length-1];if(t===n||e.length<2)return;const r=this.segmentMapping[t],o=this.segmentMapping[n];if(void 0!==r&&void 0!==o)if(Math.abs(r)===Math.abs(o)){const a=r<o?o:r,i=this.segments[a];if(r>0)for(let t=1;t<e.length-1;t++)i.push(e[t]);else for(let t=1;t<e.length-1;t++)i.unshift(e[e.length-1-t]);this.faces.push(i),this.segments[a]=null,this.segmentMapping[t]=void 0,this.segmentMapping[n]=void 0}else{const t=Math.abs(r),n=Math.abs(o),a=this.segments[t],i=this.segments[n];this.segments[t]=null,this.segments[n]=null,this.segmentMapping[a[0]]=void 0,this.segmentMapping[i[0]]=void 0,this.segmentMapping[a[a.length-1]]=void 0,this.segmentMapping[i[i.length-1]]=void 0,this.addSegment(e),this.addSegment(a),this.addSegment(i)}else if(void 0!==r){if(r>0){const t=this.segments[r];for(let n=1;n<e.length;n++)t.push(e[n]);this.segmentMapping[n]=r}else{const t=this.segments[-r];this.segmentMapping[n]=r;for(let n=1;n<e.length;n++)t.unshift(e[n])}this.segmentMapping[t]=void 0}else if(void 0!==o){if(o>0){const n=this.segments[o];for(let t=1;t<e.length;t++)n.push(e[e.length-1-t]);this.segmentMapping[t]=o}else{const n=this.segments[-o];this.segmentMapping[t]=o;for(let t=1;t<e.length;t++)n.unshift(e[e.length-t-1])}this.segmentMapping[n]=void 0}else{const r=this.segments.length;this.segments.push(e),this.segmentMapping[t]=-r,this.segmentMapping[n]=r}}}const Qp={};function Jp(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Qp,n),Wt.obj(e,t),Wt.algo(e,t,1,1),function(e,t){t.classHierarchy.push(&quot;vtkClosedPolyLineToSurfaceFilter&quot;),e.requestData=(e,t)=>{const n=e[0];if(!n)return void Yp(&quot;Invalid or missing input&quot;);const r=t[0]?.initialize()||gu.newInstance();r.shallowCopy(n);const o=new Zp,a=n.getLines().getData();let i=0;for(;i<a.length;){const e=a[i++],t=[];for(let n=0;n<e;n++)t.push(a[i+n]);o.addSegment(t),i+=e}const{faces:s}=o;let l=s.length;for(let e=0;e<s.length;e++)l+=s[e].length;const c=new Uint16Array(l);i=0;for(let e=0;e<s.length;e++){const t=s[e];c[i++]=t.length;for(let e=0;e<t.length;e++)c[i++]=t[e]}r.setPolys(Kl.newInstance({values:c,name:&quot;faces&quot;})),t[0]=r}}(e,t)}var ef={newInstance:Wt.newInstance(Jp,&quot;vtkClosedPolyLineToSurfaceFilter&quot;),extend:Jp};const{vtkErrorMacro:tf}=Ht;function nf(e,t){t.classHierarchy.push(&quot;vtkCutter&quot;);const n={...e};e.getMTime=()=>{let e=n.getMTime();return t.cutFunction?(e=Math.max(e,t.cutFunction.getMTime()),e):e},e.requestData=(e,n)=>{const r=e[0];if(!r)return void tf(&quot;Invalid or missing input&quot;);if(!t.cutFunction)return void tf(&quot;Missing cut function&quot;);const o=n[0]?.initialize()||gu.newInstance();(function(e,n){const r=e.getPoints(),o=r.getData(),a=e.getPointData(),i=r.getNumberOfPoints(),s=[],l=[],c=[],u={},d=a.getNumberOfArrays();for(let e=0;e<d;e++)u[a.getArrayName(e)]=[];(!t.cutScalars||t.cutScalars.length<i)&&(t.cutScalars=new Float32Array(i));let p=0,f=0;for(;p<o.length;)t.cutScalars[f++]=t.cutFunction.evaluateFunction(o[p++],o[p++],o[p++]);const g=[],m=new Array(3),h=new Array(3),v=[];for(const n=function(e){const t=e.getPolys().getData(),n=e.getStrips().getData(),r={cellSize:0,cell:[],done:!1,polyIdx:0,stripIdx:0,remainingStripLength:0,next(){if(r.polyIdx<t.length){r.cellSize=t[r.polyIdx];const e=r.polyIdx+1,n=e+r.cellSize;r.polyIdx=n;let o=0;for(let a=e;a<n;++a)r.cell[o++]=t[a]}else if(r.stripIdx<n.length){r.cellSize=3,0===r.remainingStripLength&&(r.remainingStripLength=n[r.stripIdx]-2,r.stripIdx+=3);const e=r.stripIdx-2,t=r.stripIdx+1;r.stripIdx++,r.remainingStripLength--;let o=0;for(let a=e;a<t;++a)r.cell[o++]=n[a]}else{if(r.done)throw new Error(&quot;Iterator is done&quot;);r.done=!0}}};return r.next(),r}(e);!n.done;n.next()){if(n.cellSize<=2)continue;for(let e=0;e<n.cellSize;)v[e]=t.cutScalars[n.cell[e++]];const e=v[0]>0;let r=!0;for(let t=1;t<n.cell.length;t++)if(v[t]>0!==e){r=!1;break}if(r)continue;const i=[];for(let e=0;e<n.cellSize;e++){const r=e+1===n.cellSize?0:e+1,s=v[e]>0;if(v[r]>0===s)continue;let l=e,c=r,u=v[c]-v[l];u<=0&&(l=r,c=e,u*=-1);let p=0;0!==u&&(p=(t.cutValue-v[l])/u);const f=n.cell[l],g=n.cell[c];m[0]=o[3*f],m[1]=o[3*f+1],m[2]=o[3*f+2],h[0]=o[3*g],h[1]=o[3*g+1],h[2]=o[3*g+2];const T=[m[0]+p*(h[0]-m[0]),m[1]+p*(h[1]-m[1]),m[2]+p*(h[2]-m[2])],y={};for(let e=0;e<d;e++){const t=a.getArrayByIndex(e),n=a.getArrayName(e),r=t.getData(),o=t.getNumberOfComponents(),i=new Array(o);for(let e=0;e<o;e++){const t=r[o*f+e],n=r[o*g+e];i.push(t+p*(n-t))}y[n]=i}i.push({pointEdge1:f,pointEdge2:g,intersectedPoint:T,intersectedArrays:y,newPointID:-1})}for(let e=0;e<i.length;e++){const t=i[e];let n=!1;for(let r=0;r<g.length;r++){const o=g[r],a=t.pointEdge1===o.pointEdge1&&t.pointEdge2===o.pointEdge2,s=t.intersectedPoint[0]===o.intersectedPoint[0]&&t.intersectedPoint[1]===o.intersectedPoint[1]&&t.intersectedPoint[2]===o.intersectedPoint[2];if(a||s){n=!0,i[e].newPointID=g[r].newPointID;break}}n||(s.push(t.intersectedPoint[0]),s.push(t.intersectedPoint[1]),s.push(t.intersectedPoint[2]),Object.keys(t.intersectedArrays).forEach((e=>{u[e].push(...t.intersectedArrays[e])})),i[e].newPointID=s.length/3-1,g.push(i[e]))}const p=i.length;2===p?l.push(p,i[0].newPointID,i[1].newPointID):p>2&&(c.push(p),i.forEach((e=>{c.push(e.newPointID)})))}n.getPoints().setData(it(r.getDataType(),s),3);const T=n.getPointData();for(let e=0;e<d;e++){const t=a.getArrayName(e),n=xs.newInstance({name:t,dataType:a.getArrayByIndex(e).getDataType(),values:u[t],numberOfComponents:a.getArrayByIndex(e).getNumberOfComponents()});T.addArray(n)}0!==l.length&&n.getLines().setData(Uint16Array.from(l)),0!==c.length&&n.getPolys().setData(Uint16Array.from(c))})(r,o),n[0]=o}}const rf={cutFunction:null,cutScalars:null,cutValue:0};function of(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,rf,n),ht(e,t),Ot(e,t,1,1),Ct(e,t,[&quot;cutFunction&quot;,&quot;cutValue&quot;]),nf(e,t)}var af={newInstance:Mt(of,&quot;vtkCutter&quot;),extend:of};const sf=e=>e,lf=1e-6;class cf{constructor(){let e=arguments.length>0&&void 0!==arguments[0]&&arguments[0];this.matrix=m(new Float64Array(16)),this.tmp=new Float64Array(3),this.angleConv=e?c:sf}rotateFromDirections(e,t){const n=new Float64Array(3),r=new Float64Array(3),o=new Float64Array(16);hn(n,e[0],e[1],e[2]),hn(r,t[0],t[1],t[2]),Cn(n,n),Cn(r,r);const a=Sn(n,r);return a>=1||(An(this.tmp,n,r),gn(this.tmp)<lf&&(An(this.tmp,[1,0,0],e),gn(this.tmp)<lf&&An(this.tmp,[0,1,0],e)),R(o,Math.acos(a),this.tmp),b(this.matrix,this.matrix,o)),this}rotate(e,t){return hn(this.tmp,...t),Cn(this.tmp,this.tmp),S(this.matrix,this.matrix,this.angleConv(e),this.tmp),this}rotateX(e){return A(this.matrix,this.matrix,this.angleConv(e)),this}rotateY(e){return I(this.matrix,this.matrix,this.angleConv(e)),this}rotateZ(e){return w(this.matrix,this.matrix,this.angleConv(e)),this}translate(e,t,n){return hn(this.tmp,e,t,n),x(this.matrix,this.matrix,this.tmp),this}scale(e,t,n){return hn(this.tmp,e,t,n),C(this.matrix,this.matrix,this.tmp),this}multiply(e){return b(this.matrix,this.matrix,e),this}multiply3x3(e){return b(this.matrix,this.matrix,[e[0],e[1],e[2],0,e[3],e[4],e[5],0,e[6],e[7],e[8],0,0,0,0,1]),this}invert(){return v(this.matrix,this.matrix),this}identity(){return m(this.matrix),this}apply(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:-1;if(Xo(ao,this.matrix))return this;const r=-1===n?e.length:t+3*n;for(let n=t;n<r;n+=3)hn(this.tmp,e[n],e[n+1],e[n+2]),In(this.tmp,this.tmp,this.matrix),e[n]=this.tmp[0],e[n+1]=this.tmp[1],e[n+2]=this.tmp[2];return this}getMatrix(){return this.matrix}setMatrix(e){return e&&16===e.length&&p(this.matrix,e),this}}var uf=function(){return new cf(!0)},df=function(){return new cf(!1)};const pf=[2,0,1,2,2,3,2,4,5,2,6,7,2,0,2,2,1,3,2,4,6,2,5,7,2,0,4,2,1,5,2,2,6,2,3,7],ff=[4,0,1,3,2,4,4,6,7,5,4,8,10,11,9,4,12,13,15,14,4,16,18,19,17,4,20,21,23,22],gf={xLength:1,yLength:1,zLength:1,pointType:&quot;Float64Array&quot;,generate3DTextureCoordinates:!1,generateFaces:!0,generateLines:!1};function mf(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,gf,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;xLength&quot;,&quot;yLength&quot;,&quot;zLength&quot;,&quot;generate3DTextureCoordinates&quot;,&quot;generateFaces&quot;,&quot;generateLines&quot;]),Wt.setGetArray(e,t,[&quot;center&quot;,&quot;rotations&quot;],3),Wt.setGetArray(e,t,[&quot;matrix&quot;],16),t._polys=Kl.newInstance({values:Uint16Array.from(ff)}),t._lineCells=Kl.newInstance({values:Uint16Array.from(pf)}),Wt.moveToProtected(e,t,[&quot;polys&quot;,&quot;lineCells&quot;]),Wt.algo(e,t,0,1),function(e,t){t.classHierarchy.push(&quot;vtkCubeSource&quot;),e.requestData=(e,n)=>{const r=n[0]?.initialize()||gu.newInstance();n[0]=r;const o=Wt.newTypedArray(t.pointType,72);r.getPoints().setData(o,3);const a=Wt.newTypedArray(t.pointType,72),i=xs.newInstance({name:&quot;Normals&quot;,values:a,numberOfComponents:3});r.getPointData().setNormals(i);let s=2;!0===t.generate3DTextureCoordinates&&(s=3);const l=Wt.newTypedArray(t.pointType,24*s),c=xs.newInstance({name:&quot;TextureCoordinates&quot;,values:l,numberOfComponents:s});r.getPointData().setTCoords(c);const u=[0,0,0],d=[0,0,0],p=[0,0];let f=0;u[0]=-t.xLength/2,d[0]=-1,d[1]=0,d[2]=0;for(let e=0;e<2;e++){u[1]=-t.yLength/2;for(let n=0;n<2;n++){p[1]=u[1]+.5,u[2]=-t.zLength/2;for(let r=0;r<2;r++)p[0]=(u[2]+.5)*(1-2*e),o[3*f]=u[0],o[3*f+1]=u[1],o[3*f+2]=u[2],a[3*f]=d[0],a[3*f+1]=d[1],a[3*f+2]=d[2],2===s?(l[f*s]=p[0],l[f*s+1]=p[1]):(l[f*s]=2*e-1,l[f*s+1]=2*n-1,l[f*s+2]=2*r-1),f++,u[2]+=t.zLength;u[1]+=t.yLength}u[0]+=t.xLength,d[0]+=2}u[1]=-t.yLength/2,d[1]=-1,d[0]=0,d[2]=0;for(let e=0;e<2;e++){u[0]=-t.xLength/2;for(let n=0;n<2;n++){p[0]=(u[0]+.5)*(2*e-1),u[2]=-t.zLength/2;for(let r=0;r<2;r++)p[1]=-1*(u[2]+.5),o[3*f]=u[0],o[3*f+1]=u[1],o[3*f+2]=u[2],a[3*f]=d[0],a[3*f+1]=d[1],a[3*f+2]=d[2],2===s?(l[f*s]=p[0],l[f*s+1]=p[1]):(l[f*s]=2*n-1,l[f*s+1]=2*e-1,l[f*s+2]=2*r-1),f++,u[2]+=t.zLength;u[0]+=t.xLength}u[1]+=t.yLength,d[1]+=2}u[2]=-t.zLength/2,d[2]=-1,d[0]=0,d[1]=0;for(let e=0;e<2;e++){u[1]=-t.yLength/2;for(let n=0;n<2;n++){p[1]=u[1]+.5,u[0]=-t.xLength/2;for(let r=0;r<2;r++)p[0]=(u[0]+.5)*(2*e-1),o[3*f]=u[0],o[3*f+1]=u[1],o[3*f+2]=u[2],a[3*f]=d[0],a[3*f+1]=d[1],a[3*f+2]=d[2],2===s?(l[f*s]=p[0],l[f*s+1]=p[1]):(l[f*s]=2*r-1,l[f*s+1]=2*n-1,l[f*s+2]=2*e-1),f++,u[0]+=t.xLength;u[1]+=t.yLength}u[2]+=t.zLength,d[2]+=2}if(t.rotations&&uf().rotateX(t.rotations[0]).rotateY(t.rotations[1]).rotateZ(t.rotations[2]).apply(o).apply(a),t.center&&df().translate(...t.center).apply(o),t.matrix){df().setMatrix(t.matrix).apply(o);const e=[t.matrix[0],t.matrix[1],t.matrix[2],0,t.matrix[4],t.matrix[5],t.matrix[6],0,t.matrix[8],t.matrix[9],t.matrix[10],0,0,0,0,1];df().setMatrix(e).apply(a)}t.generateFaces?r.getPolys().deepCopy(t._polys):r.getPolys().initialize(),t.generateLines?(r.getLines().deepCopy(t._lineCells),r.getPointData().setNormals(null)):r.getLines().initialize(),r.modified()},e.setBounds=function(){let t=[];if(Array.isArray(arguments.length<=0?void 0:arguments[0]))t=arguments.length<=0?void 0:arguments[0];else for(let e=0;e<arguments.length;e++)t.push(e<0||arguments.length<=e?void 0:arguments[e]);6===t.length&&(e.setXLength(t[1]-t[0]),e.setYLength(t[3]-t[2]),e.setZLength(t[5]-t[4]),e.setCenter([(t[0]+t[1])/2,(t[2]+t[3])/2,(t[4]+t[5])/2]))}}(e,t)}var hf={newInstance:Wt.newInstance(mf,&quot;vtkCubeSource&quot;),extend:mf};const{vtkErrorMacro:vf}=Wt,Tf={};function yf(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Tf,n),Wt.obj(e,t),Wt.algo(e,t,1,1),t._cubeSource=hf.newInstance(),Wt.moveToProtected(e,t,[&quot;cubeSource&quot;,&quot;tmpOut&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkImageDataOutlineFilter&quot;);const n={...e};e.requestData=(e,n)=>{const r=e[0];if(!r||!r.isA(&quot;vtkImageData&quot;))return void vf(&quot;Invalid or missing input&quot;);const o=r.getSpatialExtent();o?(t._cubeSource.setBounds(o),t._cubeSource.setMatrix(r.getIndexToWorld()),n[0]=t._cubeSource.getOutputData()):vf(&quot;Unable to fetch spatial extents of input image.&quot;)},e.getMTime=()=>Math.max(n.getMTime(),t._cubeSource.getMTime()),e.setGenerateFaces=t._cubeSource.setGenerateFaces,e.setGenerateLines=t._cubeSource.setGenerateLines,e.getGenerateFaces=t._cubeSource.getGenerateFaces,e.getGenerateLines=t._cubeSource.getGenerateLines}(e,t)}var bf={newInstance:Wt.newInstance(yf,&quot;vtkImageDataOutlineFilter&quot;),extend:yf};const{vtkWarningMacro:xf}=Wt;let Cf;const Sf={preMultiplyFlag:!1,matrix:[...ao]};function Af(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Sf,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;preMultiplyFlag&quot;]),Wt.setGetArray(e,t,[&quot;matrix&quot;],16),function(e,t){t.classHierarchy.push(&quot;vtkAbstractTransform&quot;,&quot;vtkHomogeneousTransform&quot;,&quot;vtkTransform&quot;),e.transformPoint=(e,n)=>(In(n,e,t.matrix),n),e.transformPoints=(e,n)=>{const r=new Float64Array(3),o=new Float64Array(3);for(let a=0;a<e.length;a+=3)r[0]=e[a],r[1]=e[a+1],r[2]=e[a+2],In(o,r,t.matrix),n[a]=o[0],n[a+1]=o[1],n[a+2]=o[2];return n},e.preMultiply=()=>{e.setPreMultiplyFlag(!0)},e.postMultiply=()=>{e.setPreMultiplyFlag(!1)},e.transformMatrix=(e,n)=>(t.preMultiplyFlag?b(n,t.matrix,e):b(n,e,t.matrix),n),e.transformMatrices=(e,n)=>{const r=new Float64Array(16),o=new Float64Array(16),a=t.preMultiplyFlag?()=>b(o,t.matrix,r):()=>b(o,r,t.matrix);for(let t=0;t<e.length;t+=16){for(let n=0;n<16;++n)r[n]=e[t+n];a();for(let e=0;e<16;++e)n[t+e]=o[e]}return n},e.getInverse=()=>Cf({matrix:Da.invertMatrix(Array.from(t.matrix),[],4),preMultiplyFlag:t.preMultiplyFlag}),e.translate=(n,r,o)=>{if(0===n&&0===r&&0===o)return;const a=u();O(a,[n,r,o]),t.preMultiplyFlag?b(t.matrix,t.matrix,a):b(t.matrix,a,t.matrix),e.modified()},e.rotateWXYZ=(n,r,o,a)=>{if(0===r&&0===o&&0===a)return void xf(&quot;No rotation applied, axis is zero vector.&quot;);if(0===n)return;const i=Da.radiansFromDegrees(n),s=Ba();Na(s,[r,o,a],i);const l=new Float64Array(16);G(l,s),t.preMultiplyFlag?b(t.matrix,t.matrix,l):b(t.matrix,l,t.matrix),e.modified()},e.rotateX=t=>{e.rotateWXYZ(t,1,0,0)},e.rotateY=t=>{e.rotateWXYZ(t,0,1,0)},e.rotateZ=t=>{e.rotateWXYZ(t,0,0,1)},e.scale=(n,r,o)=>{if(1===n&&1===r&&1===o)return;const a=u();P(a,[n,r,o]),t.preMultiplyFlag?b(t.matrix,t.matrix,a):b(t.matrix,a,t.matrix),e.modified()},e.transformNormal=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];const o=le(se(),t.matrix),a=se();me(a,o);const i=se();return ge(i,a),e.transformVector(n,r,i),Da.normalize(r),r},e.transformNormals=(n,r)=>{const o=n.getData(),a=r.getData(),i=[0,0,0],s=le(se(),t.matrix),l=se();me(l,s);const c=se();ge(c,l);for(let t=0;t<o.length;t+=3)i[0]=o[t],i[1]=o[t+1],i[2]=o[t+2],e.transformVector(i,i,c),Da.normalize(i),a[t]=i[0],a[t+1]=i[1],a[t+2]=i[2]},e.transformVector=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return wn(n,e,(arguments.length>2&&void 0!==arguments[2]?arguments[2]:null)||le(se(),t.matrix)),n},e.transformVectors=(t,n)=>{const r=t.getData(),o=n.getData(),a=[0,0,0];for(let t=0;t<r.length;t+=3)a[0]=r[t],a[1]=r[t+1],a[2]=r[t+2],e.transformVector(a,a),Da.normalize(a),o[t]=a[0],o[t+1]=a[1],o[t+2]=a[2]},e.transformPointsNormalsVectors=function(t,n,r,o,a,i){let s=arguments.length>6&&void 0!==arguments[6]?arguments[6]:null,l=arguments.length>7&&void 0!==arguments[7]?arguments[7]:null;const c=t.getNumberOfPoints(),u=s?.length??0,d=new Float64Array(3),p=new Float64Array(3),f=new Float64Array(3),g=new Float64Array(3);let m=!1,h=!1,v=!1;const T=[];for(let y=0;y<c;y++){if(t.getPoint(y,d),p.set(d),e.transformPoint(d,d),n.setPoint(y,...d),Da.areEquals(p,d)||(m=!0),a){const t=a.getData(),n=i.getData();d[0]=t[3*y],d[1]=t[3*y+1],d[2]=t[3*y+2],f.set(d),e.transformVector(d,d),n[3*y]=d[0],n[3*y+1]=d[1],n[3*y+2]=d[2],Da.areEquals(f,d)||(h=!0)}if(r){const t=r.getData(),n=o.getData();d[0]=t[3*y],d[1]=t[3*y+1],d[2]=t[3*y+2],g.set(d),e.transformNormal(d,d),n[3*y]=d[0],n[3*y+1]=d[1],n[3*y+2]=d[2],Da.areEquals(g,d)||(v=!0)}if(s)for(let t=0;t<u;t++){const n=s[t].getData(),r=l[t].getData();d[0]=n[3*y],d[1]=n[3*y+1],d[2]=n[3*y+2],f.set(d),e.transformVector(d,d),r[3*y]=d[0],r[3*y+1]=d[1],r[3*y+2]=d[2],Da.arrayEqual(f,d)||T.includes(t)||T.push(t)}}m&&n.modified(),h&&i.modified(),v&&o.modified(),T.forEach((e=>l[e].modified()))}}(e,t)}Cf=Wt.newInstance(Af,&quot;vtkTransform&quot;);var If={newInstance:Cf,extend:Af};function wf(e,t,n){return e.length>0?`${e.map((e=>e?.getMTime()??&quot;x&quot;)).join(&quot;/&quot;)}-${t}-${n}`:&quot;0&quot;}function Of(e,t){return`${t.getMTime()}`}const Pf={NEAREST:0,LINEAR:1};var Rf={InterpolationType:Pf};const{vtkErrorMacro:Mf}=Ht;function Ef(e,t,n){return t.identity(n),e.reduce(((e,n,r)=>0===r?n?t.copy(e,n):t.identity(e):n?t.multiply(e,e,n):e),n)}const Vf={VBOBuildTime:{},VBOBuildString:null,haveSeenDepthRequest:!1,lastHaveSeenDepthRequest:!1,lastIndependentComponents:!1,lastNumberOfComponents:0,lastMultiTexturePerVolumeEnabled:!1,lastSlabThickness:0,lastSlabTrapezoidIntegration:0,lastSlabType:-1,scalarTextures:[],_scalarTexturesCore:[],colorTexture:null,_colorTextureCore:null,pwfTexture:null,_pwfTextureCore:null,_externalOpenGLTexture:!1,resliceGeom:null,resliceGeomUpdateString:null,tris:null};const Df=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Vf,n),qt.extend(e,t,n),Ed(e,t,n),Vd(e,t,n),t.tris=ld.newInstance(),t.scalarTextures=[],t.colorTexture=null,t.pwfTexture=null,t.VBOBuildTime={},ht(t.VBOBuildTime),t.tmpMat4=m(new Float64Array(16)),t.outlineFilter=bf.newInstance(),t.outlineFilter.setGenerateFaces(!0),t.outlineFilter.setGenerateLines(!1),t.cubePolyData=gu.newInstance(),t.cutter=af.newInstance(),t.lineToSurfaceFilter=ef.newInstance(),t.transform=If.newInstance(),Tt(e,t,[&quot;scalarTextures&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLImageResliceMapper&quot;);const n=new Map;function o(t,r,o){r!==o&&(function(t,r){if(!r)return;const o=(n.get(r)??0)-1;o<=0?(t.unregisterGraphicsResourceUser(r,e),n.delete(r)):n.set(r,o)}(t,r),function(t,r){if(!r)return;const o=n.get(r)??0,a=o+1;n.set(r,a),o<=0&&t.registerGraphicsResourceUser(r,e)}(t,o))}function a(t){[...n.keys()].forEach((n=>t.unregisterGraphicsResourceUser(n,e)))}e.buildPass=n=>{if(n){t.currentRenderPass=null,t._openGLImageSlice=e.getFirstAncestorOfType(&quot;vtkOpenGLImageSlice&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;);const n=t._openGLRenderer.getRenderable();t._openGLCamera=t._openGLRenderer.getViewNodeFor(n.getActiveCamera());const r=t._openGLRenderWindow;t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),r&&!r.isDeleted()&&r!==t._openGLRenderWindow&&a(r),t.context=t._openGLRenderWindow.getContext(),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow)}},e.translucentPass=(n,r)=>{n&&(t.currentRenderPass=r,e.render())},e.zBufferPass=n=>{n&&(t.haveSeenDepthRequest=!0,t.renderDepth=!0,e.render(),t.renderDepth=!1)},e.opaqueZBufferPass=t=>e.zBufferPass(t),e.opaquePass=t=>{t&&e.render()},e.getCoincidentParameters=(e,n)=>t.renderable.getResolveCoincidentTopology()==gl.PolygonOffset?t.renderable.getCoincidentTopologyPolygonOffsetParameters():null,e.render=()=>{const n=t._openGLImageSlice.getRenderable(),r=t._openGLRenderer.getRenderable();e.renderPiece(r,n)},e.renderPiece=(n,r)=>{e.invokeEvent({type:&quot;StartEvent&quot;}),t.renderable.update();const o=t.renderable.getNumberOfInputPorts();t.currentValidInputs=[];for(let e=0;e<o;++e){const n=t.renderable.getInputData(e);n&&!n.isDeleted()&&t.currentValidInputs.push({imageData:n,inputIndex:e})}const a=t.currentValidInputs.length;if(a<=0)return void Mf(&quot;No input!&quot;);const i=t.currentValidInputs[0].imageData.getPointData().getScalars();t.multiTexturePerVolumeEnabled=a>1,t.numberOfComponents=t.multiTexturePerVolumeEnabled?a:i.getNumberOfComponents(),e.updateResliceGeometry(),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r),e.invokeEvent({type:&quot;EndEvent&quot;})},e.renderPieceStart=(n,r)=>{e.updateBufferObjects(n,r);const o=r.getProperties();t.currentValidInputs.forEach((e=>{let{inputIndex:n}=e;const r=o[n].getInterpolationType(),a=t.scalarTextures[n];r===Pf.NEAREST?(a.setMinificationFilter(ud.NEAREST),a.setMagnificationFilter(ud.NEAREST)):(a.setMinificationFilter(ud.LINEAR),a.setMagnificationFilter(ud.LINEAR))}));const a=t.currentValidInputs[0];o[a.inputIndex].getInterpolationType()===Pf.NEAREST?(t.colorTexture.setMinificationFilter(ud.NEAREST),t.colorTexture.setMagnificationFilter(ud.NEAREST),t.pwfTexture.setMinificationFilter(ud.NEAREST),t.pwfTexture.setMagnificationFilter(ud.NEAREST)):(t.colorTexture.setMinificationFilter(ud.LINEAR),t.colorTexture.setMagnificationFilter(ud.LINEAR),t.pwfTexture.setMinificationFilter(ud.LINEAR),t.pwfTexture.setMagnificationFilter(ud.LINEAR)),t.lastBoundBO=null},e.renderPieceDraw=(n,r)=>{const o=t.context,a=[...t.scalarTextures,t.colorTexture,t.pwfTexture];a.forEach((e=>e.activate())),e.updateShaders(t.tris,n,r),o.drawArrays(o.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release(),a.forEach((e=>e.deactivate()))},e.renderPieceFinish=(e,t)=>{},e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n)},e.getNeedToRebuildBufferObjects=(n,r)=>t.VBOBuildTime.getMTime()<e.getMTime()||t.VBOBuildTime.getMTime()<r.getMTime()||t.VBOBuildTime.getMTime()<t.renderable.getMTime()||t.VBOBuildTime.getMTime()<r.getProperty(t.currentValidInputs[0].inputIndex)?.getMTime()||t.currentValidInputs.some((e=>{let{imageData:n}=e;return t.VBOBuildTime.getMTime()<n.getMTime()}))||t.VBOBuildTime.getMTime()<t.resliceGeom.getMTime()||t.scalarTextures.length!==t.currentValidInputs.length||!t.scalarTextures.every((e=>!!e?.getHandle()))||!t.colorTexture?.getHandle()||!t.pwfTexture?.getHandle(),e.buildBufferObjects=(e,n)=>{const r=n.getProperties();t.currentValidInputs.forEach(((e,n)=>{let{imageData:a}=e;const i=a.getPointData().getScalars(),s=t._openGLRenderWindow.getGraphicsResourceForObject(i),l=Of(0,i),c=!s?.oglObject?.getHandle()||s?.hash!==l,u=r[n],d=u.getUpdatedExtents(),p=!!d.length;if(c&&!p){const e=Pd.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow);const r=a.getDimensions();e.setOglNorm16Ext(t.context.getExtension(&quot;EXT_texture_norm16&quot;)),e.resetFormatAndType(),e.create3DFilterableFromDataArray({width:r[0],height:r[1],depth:r[2],dataArray:i}),t._openGLRenderWindow.setGraphicsResourceForObject(i,e,l),t.scalarTextures[n]=e}else t.scalarTextures[n]=s.oglObject;if(p){u.setUpdatedExtents([]);const e=a.getDimensions();t.scalarTextures[n].create3DFilterableFromDataArray({width:e[0],height:e[1],depth:e[2],dataArray:i,updatedExtents:d})}o(t._openGLRenderWindow,t._scalarTexturesCore[n],i),t._scalarTexturesCore[n]=i}));const a=t.currentValidInputs[0],i=r[a.inputIndex],s=i.getIndependentComponents(),l=s?t.numberOfComponents:1,c=s?2*l:1,u=[];for(let e=0;e<l;++e)u.push(i.getRGBTransferFunction(e));const d=wf(u,s,l),p=i.getRGBTransferFunction(),f=t._openGLRenderWindow.getGraphicsResourceForObject(p);if(f?.oglObject?.getHandle()&&f?.hash===d)t.colorTexture=f.oglObject;else{let e=t.renderable.getColorTextureWidth();e<=0&&(e=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const n=new Uint8ClampedArray(e*c*3),r=Pd.newInstance();if(r.setOpenGLRenderWindow(t._openGLRenderWindow),p){const t=new Float32Array(3*e);for(let r=0;r<l;r++){const o=i.getRGBTransferFunction(r),a=o.getRange();if(o.getTable(a[0],a[1],e,t,1),s)for(let o=0;o<3*e;o++)n[r*e*6+o]=255*t[o],n[r*e*6+o+3*e]=255*t[o];else for(let o=0;o<3*e;o++)n[r*e*3+o]=255*t[o]}r.resetFormatAndType(),r.create2DFromRaw({width:e,height:c,numComps:3,dataType:cs.UNSIGNED_CHAR,data:n})}else{for(let t=0;t<3*e;++t){const r=255*t/(3*(e-1));for(let o=0;o<c;++o)n[o*e*3+t+0]=r,n[o*e*3+t+1]=r,n[o*e*3+t+2]=r}r.resetFormatAndType(),r.create2DFromRaw({width:e,height:1,numComps:3,dataType:cs.UNSIGNED_CHAR,data:n})}p&&t._openGLRenderWindow.setGraphicsResourceForObject(p,r,d),t.colorTexture=r}o(t._openGLRenderWindow,t._colorTextureCore,p),t._colorTextureCore=p;const g=[];for(let e=0;e<l;++e)g.push(i.getPiecewiseFunction(e));const m=wf(g,s,l),h=i.getPiecewiseFunction(),v=t._openGLRenderWindow.getGraphicsResourceForObject(h);if(v?.oglObject?.getHandle()&&v?.hash===m)t.pwfTexture=v.oglObject;else{let e=t.renderable.getOpacityTextureWidth();e<=0&&(e=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const n=e*c,r=new Uint8ClampedArray(n),o=Pd.newInstance();if(o.setOpenGLRenderWindow(t._openGLRenderWindow),h){const t=new Float32Array(n),r=new Float32Array(e);for(let n=0;n<l;++n){const o=i.getPiecewiseFunction(n);if(null===o)t.fill(1);else{const a=o.getRange();if(o.getTable(a[0],a[1],e,r,1),s)for(let o=0;o<e;o++)t[n*e*2+o]=r[o],t[n*e*2+o+e]=r[o];else for(let n=0;n<e;n++)t[n]=r[n]}}o.resetFormatAndType(),o.create2DFromRaw({width:e,height:c,numComps:1,dataType:cs.FLOAT,data:t})}else r.fill(255),o.resetFormatAndType(),o.create2DFromRaw({width:e,height:c,numComps:1,dataType:cs.UNSIGNED_CHAR,data:r});h&&t._openGLRenderWindow.setGraphicsResourceForObject(h,o,m),t.pwfTexture=o}o(t._openGLRenderWindow,t._pwfTextureCore,h),t._pwfTextureCore=h;const T=`${t.resliceGeom.getMTime()}A${t.renderable.getSlabThickness()}`;if(!t.tris.getCABO().getElementCount()||t.VBOBuildString!==T){const e=xs.newInstance({numberOfComponents:3,values:t.resliceGeom.getPoints().getData()});e.setName(&quot;points&quot;);const n=xs.newInstance({numberOfComponents:1,values:t.resliceGeom.getPolys().getData()}),r={points:e,cellOffset:0};if(t.renderable.getSlabThickness()>0){const e=t.resliceGeom.getPointData().getNormals();e?r.normals=e:Mf(&quot;Slab mode requested without normals&quot;)}t.tris.getCABO().createVBO(n,&quot;polys&quot;,Zi.SURFACE,r)}t.VBOBuildString=T,t.VBOBuildTime.modified()},e.updateShaders=(n,r,o)=>{if(t.lastBoundBO=n,e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};e.buildShaders(a,r,o);const i=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==n.getProgram()&&(n.setProgram(i),n.getVAO().releaseGraphicsResources()),n.getShaderSourceTime().modified()}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(n.getProgram());n.getVAO().bind(),e.setMapperShaderParameters(n,r,o),e.setCameraShaderParameters(n,r,o),e.setPropertyShaderParameters(n,r,o)},e.setMapperShaderParameters=(n,r,o)=>{const a=n.getProgram(),i=t.currentValidInputs[0].imageData;if(n.getCABO().getElementCount()&&(t.VBOBuildTime.getMTime()>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())){t.scalarTextures.forEach(((e,t)=>{a.setUniformi(`volumeTexture[${t}]`,e.getTextureUnit())})),a.isAttributeUsed(&quot;vertexWC&quot;)&&(n.getVAO().addAttributeArray(a,n.getCABO(),&quot;vertexWC&quot;,n.getCABO().getVertexOffset(),n.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||Mf(&quot;Error setting vertexWC in shader VAO.&quot;)),a.isAttributeUsed(&quot;normalWC&quot;)&&(n.getVAO().addAttributeArray(a,n.getCABO(),&quot;normalWC&quot;,n.getCABO().getNormalOffset(),n.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||Mf(&quot;Error setting normalWC in shader VAO.&quot;)),a.isUniformUsed(&quot;slabThickness&quot;)&&a.setUniformf(&quot;slabThickness&quot;,t.renderable.getSlabThickness()),a.isUniformUsed(&quot;spacing&quot;)&&a.setUniform3fv(&quot;spacing&quot;,i.getSpacing()),a.isUniformUsed(&quot;slabType&quot;)&&a.setUniformi(&quot;slabType&quot;,t.renderable.getSlabType()),a.isUniformUsed(&quot;slabType&quot;)&&a.setUniformi(&quot;slabType&quot;,t.renderable.getSlabType()),a.isUniformUsed(&quot;slabTrapezoid&quot;)&&a.setUniformi(&quot;slabTrapezoid&quot;,t.renderable.getSlabTrapezoidIntegration());const e=n.getCABO().getCoordShiftAndScaleEnabled()?n.getCABO().getInverseShiftAndScaleMatrix():null;if(a.isUniformUsed(&quot;WCTCMatrix&quot;)){const n=i.getDimensions();p(t.tmpMat4,i.getIndexToWorld()),x(t.tmpMat4,t.tmpMat4,[-.5,-.5,-.5]),C(t.tmpMat4,t.tmpMat4,n),v(t.tmpMat4,t.tmpMat4),e&&b(t.tmpMat4,t.tmpMat4,e),a.setUniformMatrix(&quot;WCTCMatrix&quot;,t.tmpMat4)}a.isUniformUsed(&quot;vboScaling&quot;)&&a.setUniform3fv(&quot;vboScaling&quot;,n.getCABO().getCoordScale()??[1,1,1]),n.getAttributeUpdateTime().modified()}if(t.haveSeenDepthRequest&&n.getProgram().setUniformi(&quot;depthRequest&quot;,t.renderDepth?1:0),n.getProgram().isUniformUsed(&quot;coffset&quot;)){const t=e.getCoincidentParameters(r,o);n.getProgram().setUniformf(&quot;coffset&quot;,t.offset),n.getProgram().isUniformUsed(&quot;cfactor&quot;)&&n.getProgram().setUniformf(&quot;cfactor&quot;,t.factor)}},e.setCameraShaderParameters=(e,n,o)=>{const a=t._openGLCamera.getKeyMatrices(n),i=t._openGLImageSlice.getKeyMatrices(),s=e.getCABO().getCoordShiftAndScaleEnabled()?e.getCABO().getInverseShiftAndScaleMatrix():null,l=e.getProgram();l.isUniformUsed(&quot;MCPCMatrix&quot;)&&(m(t.tmpMat4),l.setUniformMatrix(&quot;MCPCMatrix&quot;,Ef([a.wcpc,i.mcwc,s],r,t.tmpMat4))),l.isUniformUsed(&quot;MCVCMatrix&quot;)&&(m(t.tmpMat4),l.setUniformMatrix(&quot;MCVCMatrix&quot;,Ef([a.wcvc,i.mcwc,s],r,t.tmpMat4)))},e.setPropertyShaderParameters=(e,n,r)=>{const o=e.getProgram(),a=r.getProperty(t.currentValidInputs[0].inputIndex),i=a.getOpacity();o.setUniformf(&quot;opacity&quot;,i);const s=t.numberOfComponents,l=a.getIndependentComponents();if(l)for(let e=0;e<s;++e)o.setUniformf(`mix${e}`,a.getComponentWeight(e));for(let e=0;e<s;e++){const n=t.multiTexturePerVolumeEnabled,r=n?e:0,i=n?0:e,s=t.scalarTextures[r].getVolumeInfo(),c=s.scale[i],u=s.offset[i],d=l?e:0;let p=a.getColorWindow(),f=a.getColorLevel();const g=a.getRGBTransferFunction(d);if(g&&a.getUseLookupTableScalarRange()){const e=g.getRange();p=e[1]-e[0],f=.5*(e[1]+e[0])}const m=c/p,h=(u-f)/p+.5;o.setUniformf(`cshift${e}`,h),o.setUniformf(`cscale${e}`,m);let v=1,T=0;const y=a.getPiecewiseFunction(d);if(y){const e=y.getRange(),t=e[1]-e[0];v=c/t,T=(u-.5*(e[0]+e[1]))/t+.5}o.setUniformf(`pwfshift${e}`,T),o.setUniformf(`pwfscale${e}`,v)}const c=t.colorTexture.getTextureUnit();o.setUniformi(&quot;colorTexture1&quot;,c);const u=t.pwfTexture.getTextureUnit();o.setUniformi(&quot;pwfTexture1&quot;,u),o.setUniform4fv(&quot;backgroundColor&quot;,t.renderable.getBackgroundColor())},e.getNeedToRebuildShaders=(e,n,r)=>{const o=r.getProperty(t.currentValidInputs[0].inputIndex).getIndependentComponents(),a=t.renderable.getSlabThickness(),i=t.renderable.getSlabType(),s=t.renderable.getSlabTrapezoidIntegration();let l=!1;return(!t.currentRenderPass&&t.lastRenderPassShaderReplacement||t.currentRenderPass&&t.currentRenderPass.getShaderReplacement()!==t.lastRenderPassShaderReplacement)&&(l=!0),!(!l&&t.lastHaveSeenDepthRequest===t.haveSeenDepthRequest&&t.lastNumberOfComponents===t.numberOfComponents&&t.lastMultiTexturePerVolumeEnabled===t.multiTexturePerVolumeEnabled&&0!==e.getProgram()?.getHandle()&&t.lastIndependentComponents===o&&t.lastSlabThickness===a&&t.lastSlabType===i&&t.lastSlabTrapezoidIntegration===s||(t.lastHaveSeenDepthRequest=t.haveSeenDepthRequest,t.lastNumberOfComponents=t.numberOfComponents,t.lastMultiTexturePerVolumeEnabled=t.multiTexturePerVolumeEnabled,t.lastIndependentComponents=o,t.lastSlabThickness=a,t.lastSlabType=i,t.lastSlabTrapezoidIntegration=s,0))},e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkImageResliceMapperVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\n// all variables that represent positions or directions have a suffix\\n// indicating the coordinate system they are in. The possible values are\\n// MC - Model coordinates\\n// WC - World coordinates\\n// VC - View coordinates\\n// DC - Display coordinates\\n// TC - Texture coordinates\\n\\n// frag position in VC\\n//VTK::PositionVC::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\n// camera and actor matrix values\\n//VTK::Camera::Dec\\n\\nvoid main()\\n{\\n  //VTK::PositionVC::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Picking::Impl\\n}\\n&quot;,e.Fragment=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkImageResliceMapperFS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// Template for the gpu image mapper fragment shader\\n\\n// VC position of this fragment\\n//VTK::PositionVC::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\n// handle coincident offsets\\n//VTK::Coincident::Dec\\n\\n//VTK::ZBuffer::Dec\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nvoid main()\\n{\\n  // VC position of this fragment. This should not branch/return/discard.\\n  //VTK::PositionVC::Impl\\n\\n  // Place any calls that require uniform flow (e.g. dFdx) here.\\n  //VTK::UniformFlow::Impl\\n\\n  // Set gl_FragDepth here (gl_FragCoord.z by default)\\n  //VTK::Depth::Impl\\n\\n  // Early depth peeling abort:\\n  //VTK::DepthPeeling::PreColor\\n\\n  //VTK::TCoord::Impl\\n\\n  if (gl_FragData[0].a <= 0.0)\\n    {\\n    discard;\\n    }\\n\\n  //VTK::DepthPeeling::Impl\\n\\n  //VTK::Picking::Impl\\n\\n  // handle coincident offsets\\n  //VTK::Coincident::Impl\\n\\n  //VTK::ZBuffer::Impl\\n\\n  //VTK::RenderPassFragmentShader::Impl\\n}\\n&quot;,e.Geometry=&quot;&quot;},e.replaceShaderValues=(n,r,o)=>{if(e.replaceShaderTCoord(n,r,o),e.replaceShaderPositionVC(n,r,o),t.haveSeenDepthRequest){let e=n.Fragment;e=td.substitute(e,&quot;//VTK::ZBuffer::Dec&quot;,&quot;uniform int depthRequest;&quot;).result,e=td.substitute(e,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float iz = floor(gl_FragCoord.z*65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result,n.Fragment=e}e.replaceShaderCoincidentOffset(n,r,o)},e.replaceShaderTCoord=(e,n,r)=>{let o=e.Vertex;const a=e.Geometry;let i=e.Fragment;const s=t.renderable.getSlabThickness();o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;uniform mat4 WCTCMatrix;&quot;,&quot;out vec3 fragTexCoord;&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;fragTexCoord = (WCTCMatrix * vertexWC).xyz;&quot;]).result;const l=t.numberOfComponents,c=r.getProperty(t.currentValidInputs[0].inputIndex).getIndependentComponents();let u=[&quot;in vec3 fragTexCoord;&quot;,`uniform highp sampler3D volumeTexture[${t.scalarTextures.length}];`,&quot;uniform mat4 WCTCMatrix;&quot;,&quot;uniform float cshift0;&quot;,&quot;uniform float cscale0;&quot;,&quot;uniform float pwfshift0;&quot;,&quot;uniform float pwfscale0;&quot;,&quot;uniform sampler2D colorTexture1;&quot;,&quot;uniform sampler2D pwfTexture1;&quot;,&quot;uniform float opacity;&quot;,&quot;uniform vec4 backgroundColor;&quot;];if(u.push(&quot;vec4 rawSampleTexture(vec3 pos) {&quot;),t.multiTexturePerVolumeEnabled){u.push(&quot;vec4 rawSample;&quot;);for(let e=0;e<t.scalarTextures.length;++e)u.push(`rawSample[${e}] = texture(volumeTexture[${e}], pos)[0];`);u.push(&quot;return rawSample;&quot;,&quot;}&quot;)}else u.push(&quot;return texture(volumeTexture[0], pos);&quot;,&quot;}&quot;);if(c){for(let e=1;e<l;e++)u=u.concat([`uniform float cshift${e};`,`uniform float cscale${e};`,`uniform float pwfshift${e};`,`uniform float pwfscale${e};`]);switch(l){case 1:u=u.concat([&quot;uniform float mix0;&quot;,&quot;#define height0 0.5&quot;]);break;case 2:u=u.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;#define height0 0.25&quot;,&quot;#define height1 0.75&quot;]);break;case 3:u=u.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;#define height0 0.17&quot;,&quot;#define height1 0.5&quot;,&quot;#define height2 0.83&quot;]);break;case 4:u=u.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;uniform float mix3;&quot;,&quot;#define height0 0.125&quot;,&quot;#define height1 0.375&quot;,&quot;#define height2 0.625&quot;,&quot;#define height3 0.875&quot;]);break;default:Mf(&quot;Unsupported number of independent coordinates.&quot;)}}s>0&&(u=u.concat([&quot;uniform vec3 spacing;&quot;,&quot;uniform float slabThickness;&quot;,&quot;uniform int slabType;&quot;,&quot;uniform int slabTrapezoid;&quot;,&quot;uniform vec3 vboScaling;&quot;]),u=u.concat([&quot;vec4 compositeValue(vec4 currVal, vec4 valToComp, int trapezoid)&quot;,&quot;{&quot;,&quot;  vec4 retVal = vec4(1.0);&quot;,&quot;  if (slabType == 0) // min&quot;,&quot;  {&quot;,&quot;    retVal = min(currVal, valToComp);&quot;,&quot;  }&quot;,&quot;  else if (slabType == 1) // max&quot;,&quot;  {&quot;,&quot;    retVal = max(currVal, valToComp);&quot;,&quot;  }&quot;,&quot;  else if (slabType == 3) // sum&quot;,&quot;  {&quot;,&quot;    retVal = currVal + (trapezoid > 0 ? 0.5 * valToComp : valToComp); &quot;,&quot;  }&quot;,&quot;  else // mean&quot;,&quot;  {&quot;,&quot;    retVal = currVal + (trapezoid > 0 ? 0.5 * valToComp : valToComp); &quot;,&quot;  }&quot;,&quot;  return retVal;&quot;,&quot;}&quot;])),i=td.substitute(i,&quot;//VTK::TCoord::Dec&quot;,u).result;let d=[&quot;if (any(greaterThan(fragTexCoord, vec3(1.0))) || any(lessThan(fragTexCoord, vec3(0.0))))&quot;,&quot;{&quot;,&quot;  // set the background color and exit&quot;,&quot;  gl_FragData[0] = backgroundColor;&quot;,&quot;  return;&quot;,&quot;}&quot;,&quot;vec4 tvalue = rawSampleTexture(fragTexCoord);&quot;];if(s>0&&(d=d.concat([&quot;// Get the first and last samples&quot;,&quot;int numSlices = 1;&quot;,&quot;float scaling = min(min(spacing.x, spacing.y), spacing.z) * 0.5;&quot;,&quot;vec3 normalxspacing = scaling * normalWCVSOutput;&quot;,&quot;float distTraveled = length(normalxspacing);&quot;,&quot;int trapezoid = 0;&quot;,&quot;while (distTraveled < slabThickness * 0.5)&quot;,&quot;{&quot;,&quot;  distTraveled += length(normalxspacing);&quot;,&quot;  float fnumSlices = float(numSlices);&quot;,&quot;  if (distTraveled > slabThickness * 0.5)&quot;,&quot;  {&quot;,&quot;    // Before stepping outside the slab, sample at the boundaries&quot;,&quot;    normalxspacing = normalWCVSOutput * slabThickness * 0.5 / fnumSlices;&quot;,&quot;    trapezoid = slabTrapezoid;&quot;,&quot;  }&quot;,&quot;  vec3 fragTCoordNeg = (WCTCMatrix * vec4(vertexWCVSOutput.xyz - fnumSlices * normalxspacing * vboScaling, 1.0)).xyz;&quot;,&quot;  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))&quot;,&quot;  {&quot;,&quot;    vec4 newVal = rawSampleTexture(fragTCoordNeg);&quot;,&quot;    tvalue = compositeValue(tvalue, newVal, trapezoid);&quot;,&quot;    numSlices += 1;&quot;,&quot;  }&quot;,&quot;  vec3 fragTCoordPos = (WCTCMatrix * vec4(vertexWCVSOutput.xyz + fnumSlices * normalxspacing * vboScaling, 1.0)).xyz;&quot;,&quot;  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))&quot;,&quot;  {&quot;,&quot;    vec4 newVal = rawSampleTexture(fragTCoordPos);&quot;,&quot;    tvalue = compositeValue(tvalue, newVal, trapezoid);&quot;,&quot;    numSlices += 1;&quot;,&quot;  }&quot;,&quot;}&quot;,&quot;// Finally, if slab type is *mean*, divide the sum by the numSlices&quot;,&quot;if (slabType == 2)&quot;,&quot;{&quot;,&quot;  tvalue = tvalue / float(numSlices);&quot;,&quot;}&quot;])),c){const e=[&quot;r&quot;,&quot;g&quot;,&quot;b&quot;,&quot;a&quot;];for(let t=0;t<l;++t)d=d.concat([`vec3 tcolor${t} = texture2D(colorTexture1, vec2(tvalue.${e[t]} * cscale${t} + cshift${t}, height${t})).rgb;`,`float compWeight${t} = mix${t} * texture2D(pwfTexture1, vec2(tvalue.${e[t]} * pwfscale${t} + pwfshift${t}, height${t})).r;`]);switch(l){case 1:d=d.concat([&quot;gl_FragData[0] = vec4(tcolor0.rgb, compWeight0 * opacity);&quot;]);break;case 2:d=d.concat([&quot;float weightSum = compWeight0 + compWeight1;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum))), opacity);&quot;]);break;case 3:d=d.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum))), opacity);&quot;]);break;case 4:d=d.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2 + compWeight3;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum)) + (tcolor3.rgb * (compWeight3 / weightSum))), opacity);&quot;]);break;default:Mf(&quot;Unsupported number of independent coordinates.&quot;)}}else switch(l){case 1:d=d.concat([&quot;// Dependent components&quot;,&quot;float intensity = tvalue.r;&quot;,&quot;vec3 tcolor = texture2D(colorTexture1, vec2(intensity * cscale0 + cshift0, 0.5)).rgb;&quot;,&quot;float scalarOpacity = texture2D(pwfTexture1, vec2(intensity * pwfscale0 + pwfshift0, 0.5)).r;&quot;,&quot;gl_FragData[0] = vec4(tcolor, scalarOpacity * opacity);&quot;]);break;case 2:d=d.concat([&quot;float intensity = tvalue.r*cscale0 + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(intensity, 0.5)).rgb, pwfscale0*tvalue.g + pwfshift0);&quot;]);break;case 3:d=d.concat([&quot;vec4 tcolor = cscale0*tvalue + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, opacity);&quot;]);break;default:d=d.concat([&quot;vec4 tcolor = cscale0*tvalue + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, tcolor.a);&quot;])}i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,d).result,e.Vertex=o,e.Fragment=i,e.Geometry=a},e.replaceShaderPositionVC=(n,r,o)=>{let a=n.Vertex;const i=n.Geometry;let s=n.Fragment;const l=t.renderable.getSlabThickness();let c=[&quot;attribute vec4 vertexWC;&quot;];c=c.concat([`//${e.getMTime()}${t.resliceGeomUpdateString}`]),l>0&&(c=c.concat([&quot;attribute vec3 normalWC;&quot;,&quot;varying vec3 normalWCVSOutput;&quot;,&quot;varying vec4 vertexWCVSOutput;&quot;])),a=td.substitute(a,&quot;//VTK::PositionVC::Dec&quot;,c).result;let u=[&quot;gl_Position = MCPCMatrix * vertexWC;&quot;];l>0&&(u=u.concat([&quot;normalWCVSOutput = normalWC;&quot;,&quot;vertexWCVSOutput = vertexWC;&quot;])),a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,u).result,a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result;let d=[];l>0&&(d=d.concat([&quot;varying vec3 normalWCVSOutput;&quot;,&quot;varying vec4 vertexWCVSOutput;&quot;])),s=td.substitute(s,&quot;//VTK::PositionVC::Dec&quot;,d).result,n.Vertex=a,n.Geometry=i,n.Fragment=s},e.updateResliceGeometry=()=>{let e=&quot;&quot;;const n=t.currentValidInputs[0].imageData,r=n?.getBounds();let o=!0,a=2;const i=t.renderable.getSlicePolyData(),s=t.renderable.getSlicePlane();if(i)e=e.concat(`PolyData${i.getMTime()}`);else if(s){e=e.concat(`Plane${s.getMTime()}`);const t=se();n&&(e=e.concat(`Image${n.getMTime()}`),pe(t,...n.getDirection()),me(t,t));const r=[...s.getNormal()];wn(r,r,t),[o,a]=function(e){Da.normalize(e);const t=[0,0,0];for(let r=0;r<3;++r){(n=t)[0]=0,n[1]=0,n[2]=0,t[r]=1;const o=Da.dot(e,t);if(o<-.999999||o>.999999)return[!0,r]}var n;return[!1,2]}(r)}else{const o=ei.newInstance();o.setNormal(0,0,1);let a=[0,1,0,1,0,1];n&&(a=r),o.setOrigin(a[0],a[2],.5*(a[5]+a[4])),t.renderable.setSlicePlane(o),e=e.concat(`Plane${s?.getMTime()}`),n&&(e=e.concat(`Image${n.getMTime()}`))}if(!t.resliceGeom||t.resliceGeomUpdateString!==e){if(i)t.resliceGeom||(t.resliceGeom=gu.newInstance()),t.resliceGeom.getPoints().setData(i.getPoints().getData(),3),t.resliceGeom.getPolys().setData(i.getPolys().getData(),1),t.resliceGeom.getPointData().setNormals(i.getPointData().getNormals());else if(s)if(o){const e=new Float32Array(12),r=n.worldToIndex(s.getOrigin(),[0,0,0]),o=[(a+1)%3,(a+2)%3].sort(),i=n.getSpatialExtent();let l=0;for(let t=0;t<2;++t)for(let n=0;n<2;++n)e[l+a]=r[a],e[l+o[0]]=i[2*o[0]+n],e[l+o[1]]=i[2*o[1]+t],l+=3;t.transform.setMatrix(n.getIndexToWorld()),t.transform.transformPoints(e,e);const c=new Uint16Array(8);c[0]=3,c[1]=0,c[2]=1,c[3]=3,c[4]=3,c[5]=0,c[6]=3,c[7]=2;const u=s.getNormal();Da.normalize(u);const d=new Float32Array(12);for(let e=0;e<4;++e)d[3*e]=u[0],d[3*e+1]=u[1],d[3*e+2]=u[2];t.resliceGeom||(t.resliceGeom=gu.newInstance()),t.resliceGeom.getPoints().setData(e,3),t.resliceGeom.getPolys().setData(c,1);const p=xs.newInstance({numberOfComponents:3,values:d,name:&quot;Normals&quot;});t.resliceGeom.getPointData().setNormals(p)}else{t.outlineFilter.setInputData(n),t.cutter.setInputConnection(t.outlineFilter.getOutputPort()),t.cutter.setCutFunction(s),t.lineToSurfaceFilter.setInputConnection(t.cutter.getOutputPort()),t.lineToSurfaceFilter.update(),t.resliceGeom||(t.resliceGeom=gu.newInstance());const e=t.lineToSurfaceFilter.getOutputData();t.resliceGeom.getPoints().setData(e.getPoints().getData(),3),t.resliceGeom.getPolys().setData(e.getPolys().getData(),1),t.resliceGeom.getPointData().setNormals(e.getPointData().getNormals());const r=s.getNormal(),o=t.resliceGeom.getNumberOfPoints();Da.normalize(r);const a=new Float32Array(3*o);for(let e=0;e<o;++e)a[3*e]=r[0],a[3*e+1]=r[1],a[3*e+2]=r[2];const i=xs.newInstance({numberOfComponents:3,values:a,name:&quot;Normals&quot;});t.resliceGeom.getPointData().setNormals(i)}else Mf(&quot;Something went wrong.&quot;,&quot;A default slice plane should have been created in the beginning of&quot;,&quot;updateResliceGeometry.&quot;);t.resliceGeomUpdateString=e,t.resliceGeom?.modified()}},e.setScalarTextures=e=>{t.scalarTextures=[...e],t._externalOpenGLTexture=!0},e.delete=Et((()=>{t._openGLRenderWindow&&a(t._openGLRenderWindow)}),e.delete)}(e,t)}),&quot;vtkOpenGLImageResliceMapper&quot;);Jt(&quot;vtkImageResliceMapper&quot;,Df);var Lf={SlicingMode:{NONE:-1,I:0,J:1,K:2,X:3,Y:4,Z:5}};const{vtkErrorMacro:Bf}=Ht,{SlicingMode:Nf}=Lf;function Ff(e){const t=e.split(&quot;\\n&quot;),n=[];for(let e=0;e<t.length;++e){const r=t[e].trim();r.length>0&&n.push(r)}return n}const _f={VBOBuildTime:0,VBOBuildString:null,openGLTexture:null,tris:null,imagemat:null,imagematinv:null,colorTexture:null,pwfTexture:null,labelOutlineThicknessTexture:null,labelOutlineOpacityTexture:null,lastHaveSeenDepthRequest:!1,haveSeenDepthRequest:!1,lastTextureComponents:0};const kf=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,_f,n),qt.extend(e,t,n),Ed(e,t,n),Vd(e,t,n),t.tris=ld.newInstance(),t.imagemat=m(new Float64Array(16)),t.imagematinv=m(new Float64Array(16)),t.projectionToWorld=m(new Float64Array(16)),t.idxToView=m(new Float64Array(16)),t.idxNormalMatrix=fe(new Float64Array(9)),t.modelToView=m(new Float64Array(16)),t.projectionToView=m(new Float64Array(16)),Ct(e,t,[]),t.VBOBuildTime={},ht(t.VBOBuildTime),function(e,t){function n(n){t.openGLTexture.releaseGraphicsResources(n),[t._colorTransferFunc,t._pwFunc,t._labelOutlineThicknessArray,t._labelOutlineOpacity].forEach((t=>n.unregisterGraphicsResourceUser(t,e)))}t.classHierarchy.push(&quot;vtkOpenGLImageMapper&quot;),e.buildPass=r=>{if(r){t.currentRenderPass=null,t.openGLImageSlice=e.getFirstAncestorOfType(&quot;vtkOpenGLImageSlice&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;);const r=t._openGLRenderWindow;t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),r&&!r.isDeleted()&&r!==t._openGLRenderWindow&&n(r),t.context=t._openGLRenderWindow.getContext(),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow);const o=t._openGLRenderer.getRenderable();t.openGLCamera=t._openGLRenderer.getViewNodeFor(o.getActiveCamera()),t.renderable.isA(&quot;vtkImageMapper&quot;)&&t.renderable.getSliceAtFocalPoint()&&t.renderable.setSliceFromCamera(o.getActiveCamera())}},e.translucentPass=(n,r)=>{n&&(t.currentRenderPass=r,e.render())},e.zBufferPass=n=>{n&&(t.haveSeenDepthRequest=!0,t.renderDepth=!0,e.render(),t.renderDepth=!1)},e.opaqueZBufferPass=t=>e.zBufferPass(t),e.opaquePass=t=>{t&&e.render()},e.getCoincidentParameters=(e,n)=>t.renderable.getResolveCoincidentTopology()==gl.PolygonOffset?t.renderable.getCoincidentTopologyPolygonOffsetParameters():null,e.render=()=>{const n=t.openGLImageSlice.getRenderable(),r=t._openGLRenderer.getRenderable();e.renderPiece(r,n)},e.getShaderTemplate=(e,t,n)=>{e.Vertex=Rd,e.Fragment=Md,e.Geometry=&quot;&quot;},e.replaceShaderValues=(n,r,o)=>{let a=n.Vertex,i=n.Fragment;a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;  gl_Position = MCPCMatrix * vertexMC;&quot;]).result,a=td.substitute(a,&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCVSOutput = tcoordMC;&quot;).result,a=td.substitute(a,&quot;//VTK::TCoord::Dec&quot;,&quot;attribute vec2 tcoordMC; varying vec2 tcoordVCVSOutput;&quot;).result;const s=t.openGLTexture.getComponents(),l=o.getProperty().getIndependentComponents();let c=[&quot;varying vec2 tcoordVCVSOutput;&quot;,&quot;uniform float cshift0;&quot;,&quot;uniform float cscale0;&quot;,&quot;uniform float pwfshift0;&quot;,&quot;uniform float pwfscale0;&quot;,&quot;uniform sampler2D texture1;&quot;,&quot;uniform sampler2D colorTexture1;&quot;,&quot;uniform sampler2D pwfTexture1;&quot;,&quot;uniform float opacity;&quot;];if(o.getProperty().getUseLabelOutline()&&(c=c.concat([&quot;uniform sampler2D labelOutlineTexture1;&quot;,&quot;uniform sampler2D labelOutlineOpacityTexture1;&quot;])),l){for(let e=1;e<s;e++)c=c.concat([`uniform float cshift${e};`,`uniform float cscale${e};`,`uniform float pwfshift${e};`,`uniform float pwfscale${e};`]);switch(s){case 1:c=c.concat([&quot;uniform float mix0;&quot;,&quot;#define height0 0.5&quot;]);break;case 2:c=c.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;#define height0 0.25&quot;,&quot;#define height1 0.75&quot;]);break;case 3:c=c.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;#define height0 0.17&quot;,&quot;#define height1 0.5&quot;,&quot;#define height2 0.83&quot;]);break;case 4:c=c.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;uniform float mix3;&quot;,&quot;#define height0 0.125&quot;,&quot;#define height1 0.375&quot;,&quot;#define height2 0.625&quot;,&quot;#define height3 0.875&quot;]);break;default:Bf(&quot;Unsupported number of independent coordinates.&quot;)}}if(i=td.substitute(i,&quot;//VTK::TCoord::Dec&quot;,c).result,!0===o.getProperty().getUseLabelOutline()&&(i=td.substitute(i,&quot;//VTK::LabelOutline::Dec&quot;,[&quot;uniform float vpWidth;&quot;,&quot;uniform float vpHeight;&quot;,&quot;uniform float vpOffsetX;&quot;,&quot;uniform float vpOffsetY;&quot;,&quot;uniform mat4 PCWCMatrix;&quot;,&quot;uniform mat4 vWCtoIDX;&quot;,&quot;uniform ivec3 imageDimensions;&quot;,&quot;uniform int sliceAxis;&quot;]).result,i=td.substitute(i,&quot;//VTK::ImageLabelOutlineOn&quot;,&quot;#define vtkImageLabelOutlineOn&quot;).result,i=td.substitute(i,&quot;//VTK::LabelOutlineHelperFunction&quot;,[&quot;#ifdef vtkImageLabelOutlineOn&quot;,&quot;vec3 fragCoordToIndexSpace(vec4 fragCoord) {&quot;,&quot;  vec4 pcPos = vec4(&quot;,&quot;    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,&quot;,&quot;    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,&quot;,&quot;    (fragCoord.z - 0.5) * 2.0,&quot;,&quot;    1.0);&quot;,&quot;&quot;,&quot;  vec4 worldCoord = PCWCMatrix * pcPos;&quot;,&quot;  vec4 vertex = (worldCoord/worldCoord.w);&quot;,&quot;&quot;,&quot;  vec3 index = (vWCtoIDX * vertex).xyz;&quot;,&quot;&quot;,&quot;  // half voxel fix for labelmapOutline&quot;,&quot;  return (index + vec3(0.5)) / vec3(imageDimensions);&quot;,&quot;}&quot;,&quot;vec2 getSliceCoords(vec3 coord, int axis) {&quot;,&quot;  if (axis == 0) return coord.yz;&quot;,&quot;  if (axis == 1) return coord.xz;&quot;,&quot;  if (axis == 2) return coord.xy;&quot;,&quot;}&quot;,&quot;#endif&quot;]).result),l){const e=[&quot;r&quot;,&quot;g&quot;,&quot;b&quot;,&quot;a&quot;];let t=[&quot;vec4 tvalue = texture2D(texture1, tcoordVCVSOutput);&quot;];for(let n=0;n<s;n++)t=t.concat([`vec3 tcolor${n} = mix${n} * texture2D(colorTexture1, vec2(tvalue.${e[n]} * cscale${n} + cshift${n}, height${n})).rgb;`,`float compWeight${n} = mix${n} * texture2D(pwfTexture1, vec2(tvalue.${e[n]} * pwfscale${n} + pwfshift${n}, height${n})).r;`]);switch(s){case 1:t=t.concat([&quot;gl_FragData[0] = vec4(tcolor0.rgb, opacity);&quot;]);break;case 2:t=t.concat([&quot;float weightSum = compWeight0 + compWeight1;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum))), opacity);&quot;]);break;case 3:t=t.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum))), opacity);&quot;]);break;case 4:t=t.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2 + compWeight3;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum)) + (tcolor3.rgb * (compWeight3 / weightSum))), opacity);&quot;]);break;default:Bf(&quot;Unsupported number of independent coordinates.&quot;)}i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,t).result}else switch(s){case 1:i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[...Ff(&quot;\\n                #ifdef vtkImageLabelOutlineOn\\n                  vec3 centerPosIS = fragCoordToIndexSpace(gl_FragCoord);\\n                  float centerValue = texture2D(texture1, getSliceCoords(centerPosIS, sliceAxis)).r;\\n                  bool pixelOnBorder = false;\\n                  vec3 tColor = texture2D(colorTexture1, vec2(centerValue * cscale0 + cshift0, 0.5)).rgb;\\n                  float scalarOpacity = texture2D(pwfTexture1, vec2(centerValue * pwfscale0 + pwfshift0, 0.5)).r;\\n                  float opacityToUse = scalarOpacity * opacity;\\n                  int segmentIndex = int(centerValue * 255.0);\\n                  float textureCoordinate = float(segmentIndex - 1) / 1024.0;\\n                  float textureValue = texture2D(labelOutlineTexture1, vec2(textureCoordinate, 0.5)).r;\\n                  float outlineOpacity = texture2D(labelOutlineOpacityTexture1, vec2(textureCoordinate, 0.5)).r;\\n                  int actualThickness = int(textureValue * 255.0);\\n\\n                  if (segmentIndex == 0){\\n                    gl_FragData[0] = vec4(0.0, 0.0, 0.0, 0.0);\\n                    return;\\n                  }\\n\\n                  for (int i = -actualThickness; i <= actualThickness; i++) {\\n                    for (int j = -actualThickness; j <= actualThickness; j++) {\\n                      if (i == 0 || j == 0) {\\n                        continue;\\n                      }\\n                      vec4 neighborPixelCoord = vec4(gl_FragCoord.x + float(i),\\n                        gl_FragCoord.y + float(j),\\n                        gl_FragCoord.z, gl_FragCoord.w);\\n                      vec3 neighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);\\n                      float value = texture2D(texture1, getSliceCoords(neighborPosIS, sliceAxis)).r;\\n                      if (value != centerValue) {\\n                        pixelOnBorder = true;\\n                        break;\\n                      }\\n                    }\\n                    if (pixelOnBorder == true) {\\n                      break;\\n                    }\\n                  }\\n                  if (pixelOnBorder == true) {\\n                    gl_FragData[0] = vec4(tColor, outlineOpacity);\\n                  }\\n                  else {\\n                    gl_FragData[0] = vec4(tColor, opacityToUse);\\n                  }\\n                #else\\n                  float intensity = texture2D(texture1, tcoordVCVSOutput).r;\\n                  vec3 tcolor = texture2D(colorTexture1, vec2(intensity * cscale0 + cshift0, 0.5)).rgb;\\n                  float scalarOpacity = texture2D(pwfTexture1, vec2(intensity * pwfscale0 + pwfshift0, 0.5)).r;\\n                  gl_FragData[0] = vec4(tcolor, scalarOpacity * opacity);\\n                #endif\\n                &quot;)]).result;break;case 2:i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[&quot;vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);&quot;,&quot;float intensity = tcolor.r*cscale0 + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(intensity, 0.5)).rgb, pwfscale0*tcolor.g + pwfshift0);&quot;]).result;break;case 3:i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[&quot;vec4 tcolor = cscale0*texture2D(texture1, tcoordVCVSOutput.st) + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, opacity);&quot;]).result;break;default:i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[&quot;vec4 tcolor = cscale0*texture2D(texture1, tcoordVCVSOutput.st) + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, tcolor.a);&quot;]).result}t.haveSeenDepthRequest&&(i=td.substitute(i,&quot;//VTK::ZBuffer::Dec&quot;,&quot;uniform int depthRequest;&quot;).result,i=td.substitute(i,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float iz = floor(gl_FragCoord.z*65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result),n.Vertex=a,n.Fragment=i,e.replaceShaderClip(n,r,o),e.replaceShaderCoincidentOffset(n,r,o)},e.replaceShaderClip=(e,n,r)=>{let o=e.Vertex,a=e.Fragment;if(t.renderable.getNumberOfClippingPlanes()){let e=t.renderable.getNumberOfClippingPlanes();e>6&&(et(&quot;OpenGL has a limit of 6 clipping planes&quot;),e=6),o=td.substitute(o,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,&quot;uniform vec4 clipPlanes[6];&quot;,&quot;varying float clipDistancesVSOutput[6];&quot;]).result,o=td.substitute(o,&quot;//VTK::Clip::Impl&quot;,[&quot;for (int planeNum = 0; planeNum < 6; planeNum++)&quot;,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], vertexMC);&quot;,&quot;    }&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,&quot;varying float clipDistancesVSOutput[6];&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Impl&quot;,[&quot;for (int planeNum = 0; planeNum < 6; planeNum++)&quot;,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    if (clipDistancesVSOutput[planeNum] < 0.0) discard;&quot;,&quot;    }&quot;]).result}e.Vertex=o,e.Fragment=a},e.getNeedToRebuildShaders=(e,n,r)=>{const o=t.openGLTexture.getComponents(),a=r.getProperty().getIndependentComponents();let i=!1;return(!t.currentRenderPass&&t.lastRenderPassShaderReplacement||t.currentRenderPass&&t.currentRenderPass.getShaderReplacement()!==t.lastRenderPassShaderReplacement)&&(i=!0),!!(i||t.lastHaveSeenDepthRequest!==t.haveSeenDepthRequest||0===e.getProgram()?.getHandle()||e.getShaderSourceTime().getMTime()<t.renderable.getMTime()||e.getShaderSourceTime().getMTime()<t.currentInput.getMTime()||e.getShaderSourceTime().getMTime()<r.getProperty().getMTime()||t.lastTextureComponents!==o||t.lastIndependentComponents!==a)&&(t.lastHaveSeenDepthRequest=t.haveSeenDepthRequest,t.lastTextureComponents=o,t.lastIndependentComponents=a,!0)},e.updateShaders=(n,r,o)=>{if(t.lastBoundBO=n,e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};e.buildShaders(a,r,o);const i=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==n.getProgram()&&(n.setProgram(i),n.getVAO().releaseGraphicsResources()),n.getShaderSourceTime().modified()}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(n.getProgram());n.getVAO().bind(),e.setMapperShaderParameters(n,r,o),e.setCameraShaderParameters(n,r,o),e.setPropertyShaderParameters(n,r,o)},e.setMapperShaderParameters=(n,r,o)=>{n.getCABO().getElementCount()&&(t.VBOBuildTime>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())&&(n.getProgram().isAttributeUsed(&quot;vertexMC&quot;)&&(n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;vertexMC&quot;,n.getCABO().getVertexOffset(),n.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||Bf(&quot;Error setting vertexMC in shader VAO.&quot;)),n.getProgram().isAttributeUsed(&quot;tcoordMC&quot;)&&n.getCABO().getTCoordOffset()&&(n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;tcoordMC&quot;,n.getCABO().getTCoordOffset(),n.getCABO().getStride(),t.context.FLOAT,n.getCABO().getTCoordComponents(),t.context.FALSE)||Bf(&quot;Error setting tcoordMC in shader VAO.&quot;)),n.getAttributeUpdateTime().modified());const a=t.openGLTexture.getTextureUnit();n.getProgram().setUniformi(&quot;texture1&quot;,a);const i=t.openGLTexture.getComponents(),s=o.getProperty().getIndependentComponents();if(s)for(let e=0;e<i;e++)n.getProgram().setUniformf(`mix${e}`,o.getProperty().getComponentWeight(e));const l=t.openGLTexture.getShiftAndScale();for(let e=0;e<i;e++){let t=o.getProperty().getColorWindow(),r=o.getProperty().getColorLevel();const a=s?e:0,i=o.getProperty().getRGBTransferFunction(a);if(i&&o.getProperty().getUseLookupTableScalarRange()){const e=i.getRange();t=e[1]-e[0],r=.5*(e[1]+e[0])}const c=l.scale/t,u=(l.shift-r)/t+.5;n.getProgram().setUniformf(`cshift${e}`,u),n.getProgram().setUniformf(`cscale${e}`,c)}for(let e=0;e<i;e++){let t=1,r=0;const a=s?e:0,i=o.getProperty().getPiecewiseFunction(a);if(i){const e=i.getRange(),n=e[1]-e[0],o=.5*(e[0]+e[1]);t=l.scale/n,r=(l.shift-o)/n+.5}n.getProgram().setUniformf(`pwfshift${e}`,r),n.getProgram().setUniformf(`pwfscale${e}`,t)}if(t.haveSeenDepthRequest&&n.getProgram().setUniformi(&quot;depthRequest&quot;,t.renderDepth?1:0),n.getProgram().isUniformUsed(&quot;coffset&quot;)){const t=e.getCoincidentParameters(r,o);n.getProgram().setUniformf(&quot;coffset&quot;,t.offset),n.getProgram().isUniformUsed(&quot;cfactor&quot;)&&n.getProgram().setUniformf(&quot;cfactor&quot;,t.factor)}const c=t.colorTexture.getTextureUnit();n.getProgram().setUniformi(&quot;colorTexture1&quot;,c);const u=t.pwfTexture.getTextureUnit();if(n.getProgram().setUniformi(&quot;pwfTexture1&quot;,u),o.getProperty().getUseLabelOutline()){const e=t.labelOutlineThicknessTexture.getTextureUnit();n.getProgram().setUniformi(&quot;labelOutlineTexture1&quot;,e);const r=t.labelOutlineOpacityTexture.getTextureUnit();n.getProgram().setUniformi(&quot;labelOutlineOpacityTexture1&quot;,r)}if(t.renderable.getNumberOfClippingPlanes()){let e=t.renderable.getNumberOfClippingPlanes();e>6&&(et(&quot;OpenGL has a limit of 6 clipping planes&quot;),e=6);const r=n.getCABO().getCoordShiftAndScaleEnabled()?n.getCABO().getInverseShiftAndScaleMatrix():null,a=r?p(t.imagematinv,o.getMatrix()):o.getMatrix();r&&(h(a,a),b(a,a,r),h(a,a)),h(t.imagemat,t.currentInput.getIndexToWorld()),b(t.imagematinv,a,t.imagemat);const i=[];for(let n=0;n<e;n++){const e=[];t.renderable.getClippingPlaneInDataCoords(t.imagematinv,n,e);for(let t=0;t<4;t++)i.push(e[t])}n.getProgram().setUniformi(&quot;numClipPlanes&quot;,e),n.getProgram().setUniform4fv(&quot;clipPlanes&quot;,i)}},e.setCameraShaderParameters=(n,r,o)=>{const a=n.getProgram(),i=t.openGLImageSlice.getKeyMatrices(),s=t.currentInput,l=s.getIndexToWorld();b(t.imagemat,i.mcwc,l);const c=t.openGLCamera.getKeyMatrices(r);if(b(t.imagemat,c.wcpc,t.imagemat),n.getCABO().getCoordShiftAndScaleEnabled()){const e=n.getCABO().getInverseShiftAndScaleMatrix();b(t.imagemat,t.imagemat,e)}if(a.setUniformMatrix(&quot;MCPCMatrix&quot;,t.imagemat),!0===o.getProperty().getUseLabelOutline()){const n=s.getWorldToIndex(),o=s.getDimensions();let i=t.renderable.getClosestIJKAxis().ijkMode;i===Nf.NONE&&(i=Nf.K),a.setUniform3i(&quot;imageDimensions&quot;,o[0],o[1],o[2]),a.setUniformi(&quot;sliceAxis&quot;,i),a.setUniformMatrix(&quot;vWCtoIDX&quot;,n);const l=t.openGLCamera.getKeyMatrices(r);v(t.projectionToWorld,l.wcpc),t.openGLCamera.getKeyMatrices(r),a.setUniformMatrix(&quot;PCWCMatrix&quot;,t.projectionToWorld);const c=e.getRenderTargetSize();a.setUniformf(&quot;vpWidth&quot;,c[0]),a.setUniformf(&quot;vpHeight&quot;,c[1]);const u=e.getRenderTargetOffset();a.setUniformf(&quot;vpOffsetX&quot;,u[0]/c[0]),a.setUniformf(&quot;vpOffsetY&quot;,u[1]/c[1])}},e.setPropertyShaderParameters=(e,t,n)=>{const r=e.getProgram(),o=n.getProperty().getOpacity();r.setUniformf(&quot;opacity&quot;,o)},e.renderPieceStart=(n,r)=>{e.updateBufferObjects(n,r),t.lastBoundBO=null},e.renderPieceDraw=(n,r)=>{const o=t.context;t.openGLTexture.activate(),t.colorTexture.activate(),r.getProperty().getUseLabelOutline()&&(t.labelOutlineThicknessTexture.activate(),t.labelOutlineOpacityTexture.activate()),t.pwfTexture.activate(),t.tris.getCABO().getElementCount()&&(e.updateShaders(t.tris,n,r),o.drawArrays(o.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release()),t.openGLTexture.deactivate(),t.colorTexture.deactivate(),r.getProperty().getUseLabelOutline()&&(t.labelOutlineThicknessTexture.deactivate(),t.labelOutlineOpacityTexture.deactivate()),t.pwfTexture.deactivate()},e.renderPieceFinish=(e,t)=>{},e.renderPiece=(n,r)=>{e.invokeEvent({type:&quot;StartEvent&quot;}),t.renderable.update(),t.currentInput=t.renderable.getCurrentImage(),e.invokeEvent({type:&quot;EndEvent&quot;}),t.currentInput?(e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r)):Bf(&quot;No input!&quot;)},e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n)},e.getNeedToRebuildBufferObjects=(n,r)=>t.VBOBuildTime.getMTime()<e.getMTime()||t.VBOBuildTime.getMTime()<r.getMTime()||t.VBOBuildTime.getMTime()<t.renderable.getMTime()||t.VBOBuildTime.getMTime()<r.getProperty().getMTime()||t.VBOBuildTime.getMTime()<t.currentInput.getMTime()||!t.openGLTexture?.getHandle()||!t.colorTexture?.getHandle()||r.getProperty().getUseLabelOutline()&&(!t.labelOutlineThicknessTexture?.getHandle()||!t.labelOutlineOpacityTexture?.getHandle())||!t.pwfTexture?.getHandle(),e.buildBufferObjects=(n,r)=>{const o=t.currentInput;if(!o)return;const a=o.getPointData()&&o.getPointData().getScalars();if(!a)return;const i=a.getDataType(),s=a.getNumberOfComponents(),l=r.getProperty(),c=l.getInterpolationType(),u=l.getIndependentComponents(),d=u?s:1,p=u?2*d:1,f=[];for(let e=0;e<d;++e)f.push(l.getRGBTransferFunction(e));const g=wf(f,u,d),m=l.getRGBTransferFunction(),h=t._openGLRenderWindow.getGraphicsResourceForObject(m);if(h?.oglObject?.getHandle()&&h?.hash===g)t.colorTexture=h.oglObject;else{t.colorTexture=Pd.newInstance({resizable:!0}),t.colorTexture.setOpenGLRenderWindow(t._openGLRenderWindow);let n=t.renderable.getColorTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=new Uint8ClampedArray(n*p*3);if(c===Pf.NEAREST?(t.colorTexture.setMinificationFilter(ud.NEAREST),t.colorTexture.setMagnificationFilter(ud.NEAREST)):(t.colorTexture.setMinificationFilter(ud.LINEAR),t.colorTexture.setMagnificationFilter(ud.LINEAR)),m){const e=new Float32Array(3*n);for(let t=0;t<d;t++){const o=l.getRGBTransferFunction(t),a=o.getRange();if(o.getTable(a[0],a[1],n,e,1),u)for(let o=0;o<3*n;o++)r[t*n*6+o]=255*e[o],r[t*n*6+o+3*n]=255*e[o];else for(let o=0;o<3*n;o++)r[t*n*6+o]=255*e[o]}t.colorTexture.resetFormatAndType(),t.colorTexture.create2DFromRaw({width:n,height:p,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r})}else{for(let e=0;e<3*n;++e)r[e]=255*e/(3*(n-1)),r[e+1]=255*e/(3*(n-1)),r[e+2]=255*e/(3*(n-1));t.colorTexture.create2DFromRaw({width:n,height:1,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r})}m&&(t._openGLRenderWindow.setGraphicsResourceForObject(m,t.colorTexture,g),m!==t._colorTransferFunc&&(t._openGLRenderWindow.registerGraphicsResourceUser(m,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._colorTransferFunc,e)),t._colorTransferFunc=m)}const v=[];for(let e=0;e<d;++e)v.push(l.getPiecewiseFunction(e));const T=wf(v,u,d),y=l.getPiecewiseFunction(),b=t._openGLRenderWindow.getGraphicsResourceForObject(y);if(b?.oglObject?.getHandle()&&b?.hash===T)t.pwfTexture=b.oglObject;else{let n=t.renderable.getOpacityTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=n*p,o=new Uint8ClampedArray(r);if(t.pwfTexture=Pd.newInstance({resizable:!0}),t.pwfTexture.setOpenGLRenderWindow(t._openGLRenderWindow),c===Pf.NEAREST?(t.pwfTexture.setMinificationFilter(ud.NEAREST),t.pwfTexture.setMagnificationFilter(ud.NEAREST)):(t.pwfTexture.setMinificationFilter(ud.LINEAR),t.pwfTexture.setMagnificationFilter(ud.LINEAR)),y){const e=new Float32Array(r),o=new Float32Array(n);for(let t=0;t<d;++t){const r=l.getPiecewiseFunction(t);if(null===r)e.fill(1);else{const a=r.getRange();if(r.getTable(a[0],a[1],n,o,1),u)for(let r=0;r<n;r++)e[t*n*2+r]=o[r],e[t*n*2+r+n]=o[r];else for(let r=0;r<n;r++)e[t*n*2+r]=o[r]}}t.pwfTexture.resetFormatAndType(),t.pwfTexture.create2DFromRaw({width:n,height:p,numComps:1,dataType:cs.FLOAT,data:e})}else o.fill(255),t.pwfTexture.create2DFromRaw({width:n,height:1,numComps:1,dataType:cs.UNSIGNED_CHAR,data:o});y&&(t._openGLRenderWindow.setGraphicsResourceForObject(y,t.pwfTexture,T),y!==t._pwFunc&&(t._openGLRenderWindow.registerGraphicsResourceUser(y,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._pwFunc,e)),t._pwFunc=y)}r.getProperty().getUseLabelOutline()&&(e.updatelabelOutlineThicknessTexture(r),e.updateLabelOutlineOpacityTexture(r));const{ijkMode:x}=t.renderable.getClosestIJKAxis();let C=t.renderable.getSlice();x!==t.renderable.getSlicingMode()&&(C=t.renderable.getSliceAtPosition(C));const S=t.renderable.isA(&quot;vtkImageArrayMapper&quot;)?t.renderable.getSubSlice():Math.round(C),A=o.getExtent();let I;x===Nf.I&&(I=S-A[0]),x===Nf.J&&(I=S-A[2]),x!==Nf.K&&x!==Nf.NONE||(I=S-A[4]);const w=`${C}A${o.getMTime()}A${a.getMTime()}B${e.getMTime()}C${t.renderable.getSlicingMode()}D${r.getProperty().getInterpolationType()}`;if(t.VBOBuildString!==w){const e=o.getDimensions();t.openGLTexture||(t.openGLTexture=Pd.newInstance({resizable:!0})),t.openGLTexture.setOpenGLRenderWindow(t._openGLRenderWindow),t.openGLTexture.setOglNorm16Ext(t.context.getExtension(&quot;EXT_texture_norm16&quot;)),c===Pf.NEAREST?(new Set([1,3,4]).has(s)&&i===cs.UNSIGNED_CHAR&&!u?(t.openGLTexture.setGenerateMipmap(!0),t.openGLTexture.setMinificationFilter(ud.NEAREST)):t.openGLTexture.setMinificationFilter(ud.NEAREST),t.openGLTexture.setMagnificationFilter(ud.NEAREST)):(4!==s||i!==cs.UNSIGNED_CHAR||u?t.openGLTexture.setMinificationFilter(ud.LINEAR):(t.openGLTexture.setGenerateMipmap(!0),t.openGLTexture.setMinificationFilter(ud.LINEAR_MIPMAP_LINEAR)),t.openGLTexture.setMagnificationFilter(ud.LINEAR)),t.openGLTexture.setWrapS(cd.CLAMP_TO_EDGE),t.openGLTexture.setWrapT(cd.CLAMP_TO_EDGE);const n=e[0]*e[1]*s,r=new Float32Array(12),l=new Float32Array(8);for(let e=0;e<4;e++)l[2*e]=e%2?1:0,l[2*e+1]=e>1?1:0;const d=[Nf.X,Nf.Y,Nf.Z].includes(t.renderable.getSlicingMode())?C:S,p=o.getSpatialExtent(),f=a.getData();let g=null;if(x===Nf.I){g=new f.constructor(e[2]*e[1]*s);let t=0;for(let n=0;n<e[2];n++)for(let r=0;r<e[1];r++){let o=(I+r*e[0]+n*e[0]*e[1])*s;t=(n*e[1]+r)*s;const a=o+s;for(;o<a;)g[t++]=f[o++]}e[0]=e[1],e[1]=e[2],r[0]=d,r[1]=p[2],r[2]=p[4],r[3]=d,r[4]=p[3],r[5]=p[4],r[6]=d,r[7]=p[2],r[8]=p[5],r[9]=d,r[10]=p[3],r[11]=p[5]}else if(x===Nf.J){g=new f.constructor(e[2]*e[0]*s);let t=0;for(let n=0;n<e[2];n++)for(let r=0;r<e[0];r++){let o=(r+I*e[0]+n*e[0]*e[1])*s;t=(n*e[0]+r)*s;const a=o+s;for(;o<a;)g[t++]=f[o++]}e[1]=e[2],r[0]=p[0],r[1]=d,r[2]=p[4],r[3]=p[1],r[4]=d,r[5]=p[4],r[6]=p[0],r[7]=d,r[8]=p[5],r[9]=p[1],r[10]=d,r[11]=p[5]}else x===Nf.K||x===Nf.NONE?(g=f.subarray(I*n,(I+1)*n),r[0]=p[0],r[1]=p[2],r[2]=d,r[3]=p[1],r[4]=p[2],r[5]=d,r[6]=p[0],r[7]=p[3],r[8]=d,r[9]=p[1],r[10]=p[3],r[11]=d):Bf(&quot;Reformat slicing not yet supported.&quot;);const m=a.getRanges();t.openGLTexture.resetFormatAndType(),t.openGLTexture.create2DFilterableFromRaw({width:e[0],height:e[1],numComps:s,dataType:a.getDataType(),data:g,preferSizeOverAccuracy:!!t.renderable.getPreferSizeOverAccuracy?.(),ranges:m}),t.openGLTexture.activate(),t.openGLTexture.sendParameters(),t.openGLTexture.deactivate();const h=xs.newInstance({numberOfComponents:3,values:r});h.setName(&quot;points&quot;);const v=xs.newInstance({numberOfComponents:2,values:l});v.setName(&quot;tcoords&quot;);const T=new Uint16Array(8);T[0]=3,T[1]=0,T[2]=1,T[3]=3,T[4]=3,T[5]=0,T[6]=3,T[7]=2;const y=xs.newInstance({numberOfComponents:1,values:T});t.tris.getCABO().createVBO(y,&quot;polys&quot;,Zi.SURFACE,{points:h,tcoords:v,cellOffset:0}),t.VBOBuildTime.modified(),t.VBOBuildString=w}},e.updateLabelOutlineOpacityTexture=n=>{let r=n.getProperty().getLabelOutlineOpacity();&quot;number&quot;==typeof r&&(r=t._cachedLabelOutlineOpacityObj?.[0]===r?t._cachedLabelOutlineOpacityObj:[r],t._cachedLabelOutlineOpacityObj=r);const o=t._openGLRenderWindow.getGraphicsResourceForObject(r),a=`${r.join(&quot;-&quot;)}`;if(o?.oglObject?.getHandle()&&o?.hash===a)t.labelOutlineOpacityTexture=o.oglObject;else{let n=t.renderable.getLabelOutlineTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const o=1,i=new Float32Array(n*o);for(let e=0;e<n;++e)i[e]=r[e]??r[0];t.labelOutlineOpacityTexture=Pd.newInstance({resizable:!1}),t.labelOutlineOpacityTexture.setOpenGLRenderWindow(t._openGLRenderWindow),t.labelOutlineOpacityTexture.resetFormatAndType(),t.labelOutlineOpacityTexture.setMinificationFilter(ud.NEAREST),t.labelOutlineOpacityTexture.setMagnificationFilter(ud.NEAREST),t.labelOutlineOpacityTexture.create2DFromRaw({width:n,height:o,numComps:1,dataType:cs.FLOAT,data:i}),r&&(t._openGLRenderWindow.setGraphicsResourceForObject(r,t.labelOutlineOpacityTexture,a),r!==t._labelOutlineOpacity&&(t._openGLRenderWindow.registerGraphicsResourceUser(r,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._labelOutlineOpacity,e)),t._labelOutlineOpacity=r)}},e.updatelabelOutlineThicknessTexture=n=>{const r=n.getProperty().getLabelOutlineThicknessByReference(),o=t._openGLRenderWindow.getGraphicsResourceForObject(r),a=`${r.join(&quot;-&quot;)}`;if(o?.oglObject?.getHandle()&&o?.hash===a)t.labelOutlineThicknessTexture=o.oglObject;else{let n=t.renderable.getLabelOutlineTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const o=1,i=new Uint8Array(n*o);for(let e=0;e<n;++e){const t=void 0!==r[e]?r[e]:r[0];i[e]=t}t.labelOutlineThicknessTexture=Pd.newInstance({resizable:!1}),t.labelOutlineThicknessTexture.setOpenGLRenderWindow(t._openGLRenderWindow),t.labelOutlineThicknessTexture.resetFormatAndType(),t.labelOutlineThicknessTexture.setMinificationFilter(ud.NEAREST),t.labelOutlineThicknessTexture.setMagnificationFilter(ud.NEAREST),t.labelOutlineThicknessTexture.create2DFromRaw({width:n,height:o,numComps:1,dataType:cs.UNSIGNED_CHAR,data:i}),r&&(t._openGLRenderWindow.setGraphicsResourceForObject(r,t.labelOutlineThicknessTexture,a),r!==t._labelOutlineThicknessArray&&(t._openGLRenderWindow.registerGraphicsResourceUser(r,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._labelOutlineThicknessArray,e)),t._labelOutlineThicknessArray=r)}},e.getRenderTargetSize=()=>{if(t._useSmallViewport)return[t._smallViewportWidth,t._smallViewportHeight];const{usize:e,vsize:n}=t._openGLRenderer.getTiledSizeAndOrigin();return[e,n]},e.getRenderTargetOffset=()=>{const{lowerLeftU:e,lowerLeftV:n}=t._openGLRenderer.getTiledSizeAndOrigin();return[e,n]},e.delete=Et((()=>{t._openGLRenderWindow&&n(t._openGLRenderWindow)}),e.delete)}(e,t)}),&quot;vtkOpenGLImageMapper&quot;);Jt(&quot;vtkAbstractImageMapper&quot;,kf);const Gf=0,Uf=1,zf=2,{vtkErrorMacro:Wf}=Wt,Hf={currentRenderPass:null,volumeTexture:null,colorTexture:null,pwfTexture:null,tris:null,lastHaveSeenDepthRequest:!1,haveSeenDepthRequest:!1,lastTextureComponents:0,lastIndependentComponents:0,imagemat:null,imagematinv:null};const jf=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Hf,n),qt.extend(e,t,n),Ed(e,t,n),Wt.algo(e,t,2,0),t.tris=ld.newInstance(),t.volumeTexture=null,t.colorTexture=null,t.pwfTexture=null,t.imagemat=m(new Float64Array(16)),t.imagematinv=m(new Float64Array(16)),t.VBOBuildTime={},Wt.obj(t.VBOBuildTime,{mtime:0}),function(e,t){function n(n){[t._scalars,t._colorTransferFunc,t._pwFunc].forEach((t=>n.unregisterGraphicsResourceUser(t,e)))}t.classHierarchy.push(&quot;vtkOpenGLImageCPRMapper&quot;),e.buildPass=r=>{if(r){t.currentRenderPass=null,t.openGLImageSlice=e.getFirstAncestorOfType(&quot;vtkOpenGLImageSlice&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;);const r=t._openGLRenderWindow;t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),r&&!r.isDeleted()&&r!==t._openGLRenderWindow&&n(r),t.context=t._openGLRenderWindow.getContext(),t.openGLCamera=t._openGLRenderer.getViewNodeFor(t._openGLRenderer.getRenderable().getActiveCamera()),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow)}},e.opaquePass=(n,r)=>{n&&(t.currentRenderPass=r,e.render())},e.opaqueZBufferPass=n=>{n&&(t.haveSeenDepthRequest=!0,t.renderDepth=!0,e.render(),t.renderDepth=!1)},e.getCoincidentParameters=(e,n)=>t.renderable.getResolveCoincidentTopology()===gl.PolygonOffset?t.renderable.getCoincidentTopologyPolygonOffsetParameters():null,e.render=()=>{const n=t.openGLImageSlice.getRenderable(),r=t._openGLRenderer.getRenderable();e.renderPiece(r,n)},e.renderPiece=(n,r)=>{e.invokeEvent({type:&quot;StartEvent&quot;}),t.renderable.update(),e.invokeEvent({type:&quot;EndEvent&quot;}),t.renderable.preRenderCheck()&&(t.currentImageDataInput=t.renderable.getInputData(0),t.currentCenterlineInput=t.renderable.getOrientedCenterline(),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r))},e.renderPieceStart=(t,n)=>{e.updateBufferObjects(t,n)},e.renderPieceDraw=(n,r)=>{const o=t.context;t.volumeTexture.activate(),t.colorTexture.activate(),t.pwfTexture.activate(),t.tris.getCABO().getElementCount()&&(e.updateShaders(t.tris,n,r),o.drawArrays(o.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release()),t.volumeTexture.deactivate(),t.colorTexture.deactivate(),t.pwfTexture.deactivate()},e.renderPieceFinish=(e,t)=>{},e.updateBufferObjects=(n,r)=>{e.getNeedToRebuildBufferObjects(n,r)&&e.buildBufferObjects(n,r),r.getProperty().getInterpolationType()===Pf.NEAREST?(t.volumeTexture.setMinificationFilter(ud.NEAREST),t.volumeTexture.setMagnificationFilter(ud.NEAREST),t.colorTexture.setMinificationFilter(ud.NEAREST),t.colorTexture.setMagnificationFilter(ud.NEAREST),t.pwfTexture.setMinificationFilter(ud.NEAREST),t.pwfTexture.setMagnificationFilter(ud.NEAREST)):(t.volumeTexture.setMinificationFilter(ud.LINEAR),t.volumeTexture.setMagnificationFilter(ud.LINEAR),t.colorTexture.setMinificationFilter(ud.LINEAR),t.colorTexture.setMagnificationFilter(ud.LINEAR),t.pwfTexture.setMinificationFilter(ud.LINEAR),t.pwfTexture.setMagnificationFilter(ud.LINEAR))},e.getNeedToRebuildBufferObjects=(n,r)=>{const o=t.VBOBuildTime.getMTime();return o<e.getMTime()||o<t.renderable.getMTime()||o<r.getMTime()||o<t.currentImageDataInput.getMTime()||o<t.currentCenterlineInput.getMTime()||!t.volumeTexture?.getHandle()},e.buildBufferObjects=(n,r)=>{const o=t.currentImageDataInput,a=t.currentCenterlineInput,i=r.getProperty(),s=o?.getPointData()?.getScalars();if(!s)return;const l=t._openGLRenderWindow.getGraphicsResourceForObject(s),c=Of(0,s),u=!l?.oglObject?.getHandle()||l?.hash!==c,d=i.getUpdatedExtents(),p=!!d.length;if(u){t.volumeTexture=Pd.newInstance(),t.volumeTexture.setOpenGLRenderWindow(t._openGLRenderWindow);const n=o.getDimensions();t.volumeTexture.setOglNorm16Ext(t.context.getExtension(&quot;EXT_texture_norm16&quot;)),t.volumeTexture.resetFormatAndType(),t.volumeTexture.create3DFilterableFromDataArray({width:n[0],height:n[1],depth:n[2],dataArray:s,preferSizeOverAccuracy:t.renderable.getPreferSizeOverAccuracy()}),t._openGLRenderWindow.setGraphicsResourceForObject(s,t.volumeTexture,c),s!==t._scalars&&(t._openGLRenderWindow.registerGraphicsResourceUser(s,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._scalars,e)),t._scalars=s}else t.volumeTexture=l.oglObject;if(p){i.setUpdatedExtents([]);const e=o.getDimensions();t.volumeTexture.create3DFilterableFromDataArray({width:e[0],height:e[1],depth:e[2],dataArray:s,updatedExtents:d})}const f=s.getNumberOfComponents(),g=r.getProperty(),m=g.getIndependentComponents(),h=m?f:1,v=m?2*h:1,T=[];for(let e=0;e<h;++e)T.push(g.getRGBTransferFunction(e));const y=wf(T,m,h),b=g.getRGBTransferFunction(),x=t._openGLRenderWindow.getGraphicsResourceForObject(b);if(x?.oglObject?.getHandle()&&x?.hash===y)t.colorTexture=x.oglObject;else{let n=t.renderable.getColorTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=new Uint8ClampedArray(n*v*3);if(t.colorTexture=Pd.newInstance(),t.colorTexture.setOpenGLRenderWindow(t._openGLRenderWindow),b){const e=new Float32Array(3*n);for(let t=0;t<h;t++){const o=g.getRGBTransferFunction(t),a=o.getRange();if(o.getTable(a[0],a[1],n,e,1),m)for(let o=0;o<3*n;o++)r[t*n*6+o]=255*e[o],r[t*n*6+o+3*n]=255*e[o];else for(let o=0;o<3*n;o++)r[t*n*6+o]=255*e[o]}t.colorTexture.resetFormatAndType(),t.colorTexture.create2DFromRaw({width:n,height:v,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r})}else{for(let e=0;e<3*n;++e)r[e]=255*e/(3*(n-1)),r[e+1]=255*e/(3*(n-1)),r[e+2]=255*e/(3*(n-1));t.colorTexture.resetFormatAndType(),t.colorTexture.create2DFromRaw({width:n,height:1,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r})}b&&(t._openGLRenderWindow.setGraphicsResourceForObject(b,t.colorTexture,y),b!==t._colorTransferFunc&&(t._openGLRenderWindow.registerGraphicsResourceUser(b,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._colorTransferFunc,e)),t._colorTransferFunc=b)}const C=[];for(let e=0;e<h;++e)C.push(g.getPiecewiseFunction(e));const S=wf(C,m,h),A=g.getPiecewiseFunction(),I=t._openGLRenderWindow.getGraphicsResourceForObject(A);if(I?.oglObject?.getHandle()&&I?.hash===S)t.pwfTexture=I.oglObject;else{let n=t.renderable.getOpacityTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=n*v,o=new Uint8ClampedArray(r);if(t.pwfTexture=Pd.newInstance(),t.pwfTexture.setOpenGLRenderWindow(t._openGLRenderWindow),A){const e=new Float32Array(r),o=new Float32Array(n);for(let t=0;t<h;++t){const r=g.getPiecewiseFunction(t);if(null===r)e.fill(1);else{const a=r.getRange();if(r.getTable(a[0],a[1],n,o,1),m)for(let r=0;r<n;r++)e[t*n*2+r]=o[r],e[t*n*2+r+n]=o[r];else for(let r=0;r<n;r++)e[t*n*2+r]=o[r]}}t.pwfTexture.resetFormatAndType(),t.pwfTexture.create2DFromRaw({width:n,height:v,numComps:1,dataType:cs.FLOAT,data:e})}else o.fill(255),t.pwfTexture.resetFormatAndType(),t.pwfTexture.create2DFromRaw({width:n,height:1,numComps:1,dataType:cs.UNSIGNED_CHAR,data:o});A&&(t._openGLRenderWindow.setGraphicsResourceForObject(A,t.pwfTexture,S),A!==t._pwFunc&&(t._openGLRenderWindow.registerGraphicsResourceUser(A,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._pwFunc,e)),t._pwFunc=A)}if(t.VBOBuildTime.getMTime()<t.renderable.getMTime()||t.VBOBuildTime.getMTime()<a.getMTime()){const e=a.getNumberOfPoints(),n=e<=1?0:e-1,r=a.getDistancesToFirstPoint(),o=t.renderable.getHeight(),i=4*n,s=new Float32Array(3*i),l=t.renderable.getWidth();for(let e=0,t=0;e<n;++e)s.set([0,o-r[e],0],t),t+=3,s.set([l,o-r[e],0],t),t+=3,s.set([l,o-r[e+1],0],t),t+=3,s.set([0,o-r[e+1],0],t),t+=3;const c=xs.newInstance({numberOfComponents:3,values:s});c.setName(&quot;points&quot;);const u=new Uint16Array(5*n);for(let e=0,t=0,r=0;e<n;++e)u.set([4,r+3,r+2,r+1,r],t),t+=5,r+=4;const d=xs.newInstance({numberOfComponents:1,values:u}),p=a.getPoints(),f=new Float32Array(3*i),g=new Array(3),m=new Array(3);for(let e=0,t=0;e<n;++e)p.getPoint(e,g),p.getPoint(e+1,m),f.set(g,t),t+=3,f.set(g,t),t+=3,f.set(m,t),t+=3,f.set(m,t),t+=3;const h=xs.newInstance({numberOfComponents:3,values:f,name:&quot;centerlinePosition&quot;}),v=new Float32Array(i);for(let e=0,t=0;e<n;++e)v.set([0,1,3,2],t),t+=4;const T=[h,xs.newInstance({numberOfComponents:1,values:v,name:&quot;quadIndex&quot;})];if(!t.renderable.getUseUniformOrientation()){const e=t.renderable.getOrientedCenterline().getOrientations()??[],r=new Float32Array(4*i),o=new Float32Array(4*i);for(let t=0;t<n;++t){const n=e[t],a=e[t+1];for(let e=0;e<4;++e){const i=4*(e+4*t);r.set(n,i),o.set(a,i)}}const a=xs.newInstance({numberOfComponents:4,values:r,name:&quot;centerlineTopOrientation&quot;}),s=xs.newInstance({numberOfComponents:4,values:o,name:&quot;centerlineBotOrientation&quot;});T.push(a,s)}t.tris.getCABO().createVBO(d,&quot;polys&quot;,Zi.SURFACE,{points:c,customAttributes:T}),t.VBOBuildTime.modified()}},e.getNeedToRebuildShaders=(e,n,r)=>{const o=t.volumeTexture.getComponents(),a=r.getProperty().getIndependentComponents(),i=!!t.renderable.getCenterPoint(),s=t.renderable.getUseUniformOrientation(),l=t.renderable.isProjectionEnabled()&&t.renderable.getProjectionMode();return(0===e.getProgram()||t.lastUseCenterPoint!==i||t.lastUseUniformOrientation!==s||t.lastProjectionMode!==l||t.lastHaveSeenDepthRequest!==t.haveSeenDepthRequest||t.lastTextureComponents!==o||t.lastIndependentComponents!==a)&&(t.lastUseCenterPoint=i,t.lastUseUniformOrientation=s,t.lastProjectionMode=l,t.lastHaveSeenDepthRequest=t.haveSeenDepthRequest,t.lastTextureComponents=o,t.lastIndependentComponents=a,!0)},e.buildShaders=(t,n,r)=>{e.getShaderTemplate(t,n,r),e.replaceShaderValues(t,n,r)},e.replaceShaderValues=(n,r,o)=>{let a=n.Vertex,i=n.Fragment;const s=[&quot;vec3 applyQuaternionToVec(vec4 q, vec3 v) {&quot;,&quot;  float uvx = q.y * v.z - q.z * v.y;&quot;,&quot;  float uvy = q.z * v.x - q.x * v.z;&quot;,&quot;  float uvz = q.x * v.y - q.y * v.x;&quot;,&quot;  float uuvx = q.y * uvz - q.z * uvy;&quot;,&quot;  float uuvy = q.z * uvx - q.x * uvz;&quot;,&quot;  float uuvz = q.x * uvy - q.y * uvx;&quot;,&quot;  float w2 = q.w * 2.0;&quot;,&quot;  uvx *= w2;&quot;,&quot;  uvy *= w2;&quot;,&quot;  uvz *= w2;&quot;,&quot;  uuvx *= 2.0;&quot;,&quot;  uuvy *= 2.0;&quot;,&quot;  uuvz *= 2.0;&quot;,&quot;  return vec3(v.x + uvx + uuvx, v.y + uvy + uuvy, v.z + uvz + uuvz);&quot;,&quot;}&quot;];a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;  gl_Position = MCPCMatrix * vertexMC;&quot;]).result;const l=[&quot;attribute vec3 centerlinePosition;&quot;,&quot;attribute float quadIndex;&quot;,&quot;uniform float width;&quot;,&quot;out vec2 quadOffsetVSOutput;&quot;,&quot;out vec3 centerlinePosVSOutput;&quot;],c=t.renderable.isProjectionEnabled(),u=t.renderable.getUseUniformOrientation();u?(l.push(&quot;out vec3 samplingDirVSOutput;&quot;,&quot;uniform vec4 centerlineOrientation;&quot;,&quot;uniform vec3 tangentDirection;&quot;,...s),c&&l.push(&quot;out vec3 projectionDirVSOutput;&quot;,&quot;uniform vec3 bitangentDirection;&quot;)):l.push(&quot;out vec4 centerlineTopOrientationVSOutput;&quot;,&quot;out vec4 centerlineBotOrientationVSOutput;&quot;,&quot;attribute vec4 centerlineTopOrientation;&quot;,&quot;attribute vec4 centerlineBotOrientation;&quot;),a=td.substitute(a,&quot;//VTK::Color::Dec&quot;,l).result;const d=[&quot;quadOffsetVSOutput = vec2(width * (mod(quadIndex, 2.0) == 0.0 ? -0.5 : 0.5), quadIndex > 1.0 ? 0.0 : 1.0);&quot;,&quot;centerlinePosVSOutput = centerlinePosition;&quot;];u?(d.push(&quot;samplingDirVSOutput = applyQuaternionToVec(centerlineOrientation, tangentDirection);&quot;),c&&d.push(&quot;projectionDirVSOutput = applyQuaternionToVec(centerlineOrientation, bitangentDirection);&quot;)):d.push(&quot;centerlineTopOrientationVSOutput = centerlineTopOrientation;&quot;,&quot;centerlineBotOrientationVSOutput = centerlineBotOrientation;&quot;),a=td.substitute(a,&quot;//VTK::Color::Impl&quot;,d).result;const p=t.volumeTexture.getComponents(),f=o.getProperty().getIndependentComponents();let g=[&quot;uniform mat4 MCTCMatrix; // Model coordinates to texture coordinates&quot;,&quot;in vec2 quadOffsetVSOutput;&quot;,&quot;in vec3 centerlinePosVSOutput;&quot;,&quot;uniform highp sampler3D volumeTexture;&quot;,&quot;uniform sampler2D colorTexture1;&quot;,&quot;uniform sampler2D pwfTexture1;&quot;,&quot;uniform float opacity;&quot;,&quot;uniform vec4 backgroundColor;&quot;,&quot;uniform float cshift0;&quot;,&quot;uniform float cscale0;&quot;,&quot;uniform float pwfshift0;&quot;,&quot;uniform float pwfscale0;&quot;];c&&g.push(&quot;uniform vec3 volumeSizeMC;&quot;,&quot;uniform int projectionSlabNumberOfSamples;&quot;,&quot;uniform float projectionConstantOffset;&quot;,&quot;uniform float projectionStepLength;&quot;),u?(g.push(&quot;in vec3 samplingDirVSOutput;&quot;),c&&g.push(&quot;in vec3 projectionDirVSOutput;&quot;)):(g.push(&quot;uniform vec3 tangentDirection;&quot;,&quot;in vec4 centerlineTopOrientationVSOutput;&quot;,&quot;in vec4 centerlineBotOrientationVSOutput;&quot;,...s),c&&g.push(&quot;uniform vec3 bitangentDirection;&quot;));const m=t.renderable.getCenterPoint();if(m&&g.push(&quot;uniform vec3 globalCenterPoint;&quot;),f){for(let e=1;e<p;e++)g=g.concat([`uniform float cshift${e};`,`uniform float cscale${e};`,`uniform float pwfshift${e};`,`uniform float pwfscale${e};`]);switch(p){case 1:g=g.concat([&quot;uniform float mix0;&quot;,&quot;#define height0 0.5&quot;]);break;case 2:g=g.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;#define height0 0.25&quot;,&quot;#define height1 0.75&quot;]);break;case 3:g=g.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;#define height0 0.17&quot;,&quot;#define height1 0.5&quot;,&quot;#define height2 0.83&quot;]);break;case 4:g=g.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;uniform float mix3;&quot;,&quot;#define height0 0.125&quot;,&quot;#define height1 0.375&quot;,&quot;#define height2 0.625&quot;,&quot;#define height3 0.875&quot;]);break;default:Wf(&quot;Unsupported number of independent coordinates.&quot;)}}i=td.substitute(i,&quot;//VTK::TCoord::Dec&quot;,g).result;let h=[];if(u?(h.push(&quot;vec3 samplingDirection = samplingDirVSOutput;&quot;),c&&h.push(&quot;vec3 projectionDirection = projectionDirVSOutput;&quot;)):(h.push(&quot;vec4 q0 = centerlineBotOrientationVSOutput;&quot;,&quot;vec4 q1 = centerlineTopOrientationVSOutput;&quot;,&quot;float qCosAngle = dot(q0, q1);&quot;,&quot;vec4 interpolatedOrientation;&quot;,&quot;if (qCosAngle > 0.999 || qCosAngle < -0.999) {&quot;,&quot;  // Use LERP instead of SLERP when the two quaternions are close or opposite&quot;,&quot;  interpolatedOrientation = normalize(mix(q0, q1, quadOffsetVSOutput.y));&quot;,&quot;} else {&quot;,&quot;  float omega = acos(qCosAngle);&quot;,&quot;  interpolatedOrientation = normalize(sin((1.0 - quadOffsetVSOutput.y) * omega) * q0 + sin(quadOffsetVSOutput.y * omega) * q1);&quot;,&quot;}&quot;,&quot;vec3 samplingDirection = applyQuaternionToVec(interpolatedOrientation, tangentDirection);&quot;),c&&h.push(&quot;vec3 projectionDirection = applyQuaternionToVec(interpolatedOrientation, bitangentDirection);&quot;)),m?h.push(&quot;float baseOffset = dot(samplingDirection, globalCenterPoint - centerlinePosVSOutput);&quot;,&quot;float horizontalOffset = quadOffsetVSOutput.x + baseOffset;&quot;):h.push(&quot;float horizontalOffset = quadOffsetVSOutput.x;&quot;),h.push(&quot;vec3 volumePosMC = centerlinePosVSOutput + horizontalOffset * samplingDirection;&quot;,&quot;vec3 volumePosTC = (MCTCMatrix * vec4(volumePosMC, 1.0)).xyz;&quot;,&quot;if (any(lessThan(volumePosTC, vec3(0.0))) || any(greaterThan(volumePosTC, vec3(1.0))))&quot;,&quot;{&quot;,&quot;  // set the background color and exit&quot;,&quot;  gl_FragData[0] = backgroundColor;&quot;,&quot;  return;&quot;,&quot;}&quot;),c){const e=t.renderable.getProjectionMode();switch(e===Uf?h.push(&quot;const vec4 initialProjectionTextureValue = vec4(1.0);&quot;):h.push(&quot;const vec4 initialProjectionTextureValue = vec4(0.0);&quot;),h.push(&quot;vec3 projectionScaledDirection = projectionDirection / volumeSizeMC;&quot;,&quot;vec3 projectionStep = projectionStepLength * projectionScaledDirection;&quot;,&quot;vec3 projectionStartPosition = volumePosTC + projectionConstantOffset * projectionScaledDirection;&quot;,&quot;vec4 tvalue = initialProjectionTextureValue;&quot;,&quot;for (int projectionSampleIdx = 0; projectionSampleIdx < projectionSlabNumberOfSamples; ++projectionSampleIdx) {&quot;,&quot;  vec3 projectionSamplePosition = projectionStartPosition + float(projectionSampleIdx) * projectionStep;&quot;,&quot;  vec4 sampledTextureValue = texture(volumeTexture, projectionSamplePosition);&quot;),e){case Gf:h.push(&quot;  tvalue = max(tvalue, sampledTextureValue);&quot;);break;case Uf:h.push(&quot;  tvalue = min(tvalue, sampledTextureValue);&quot;);break;default:h.push(&quot;  tvalue = tvalue + sampledTextureValue;&quot;)}h.push(&quot;}&quot;),e===zf&&h.push(&quot;tvalue = tvalue / float(projectionSlabNumberOfSamples);&quot;)}else h.push(&quot;vec4 tvalue = texture(volumeTexture, volumePosTC);&quot;);if(f){const e=[&quot;r&quot;,&quot;g&quot;,&quot;b&quot;,&quot;a&quot;];for(let t=0;t<p;++t)h=h.concat([`vec3 tcolor${t} = mix${t} * texture2D(colorTexture1, vec2(tvalue.${e[t]} * cscale${t} + cshift${t}, height${t})).rgb;`,`float compWeight${t} = mix${t} * texture2D(pwfTexture1, vec2(tvalue.${e[t]} * pwfscale${t} + pwfshift${t}, height${t})).r;`]);switch(p){case 1:h=h.concat([&quot;gl_FragData[0] = vec4(tcolor0.rgb, compWeight0 * opacity);&quot;]);break;case 2:h=h.concat([&quot;float weightSum = compWeight0 + compWeight1;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum))), opacity);&quot;]);break;case 3:h=h.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum))), opacity);&quot;]);break;case 4:h=h.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2 + compWeight3;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum)) + (tcolor3.rgb * (compWeight3 / weightSum))), opacity);&quot;]);break;default:Wf(&quot;Unsupported number of independent coordinates.&quot;)}}else switch(p){case 1:h=h.concat([&quot;// Dependent components&quot;,&quot;float intensity = tvalue.r;&quot;,&quot;vec3 tcolor = texture2D(colorTexture1, vec2(intensity * cscale0 + cshift0, 0.5)).rgb;&quot;,&quot;float scalarOpacity = texture2D(pwfTexture1, vec2(intensity * pwfscale0 + pwfshift0, 0.5)).r;&quot;,&quot;gl_FragData[0] = vec4(tcolor, scalarOpacity * opacity);&quot;]);break;case 2:h=h.concat([&quot;float intensity = tvalue.r*cscale0 + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(intensity, 0.5)).rgb, pwfscale0*tvalue.g + pwfshift0);&quot;]);break;case 3:h=h.concat([&quot;vec4 tcolor = cscale0*tvalue + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, opacity);&quot;]);break;default:h=h.concat([&quot;vec4 tcolor = cscale0*tvalue + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, tcolor.a);&quot;])}i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,h).result,t.haveSeenDepthRequest&&(i=td.substitute(i,&quot;//VTK::ZBuffer::Dec&quot;,&quot;uniform int depthRequest;&quot;).result,i=td.substitute(i,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float iz = floor(gl_FragCoord.z*65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result),n.Vertex=a,n.Fragment=i,e.replaceShaderClip(n,r,o),e.replaceShaderCoincidentOffset(n,r,o)},e.replaceShaderClip=(e,n,r)=>{let o=e.Vertex,a=e.Fragment;if(t.renderable.getNumberOfClippingPlanes()){let e=t.renderable.getNumberOfClippingPlanes();e>6&&(Wt.vtkErrorMacro(&quot;OpenGL has a limit of 6 clipping planes&quot;),e=6),o=td.substitute(o,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,&quot;uniform vec4 clipPlanes[6];&quot;,&quot;varying float clipDistancesVSOutput[6];&quot;]).result,o=td.substitute(o,&quot;//VTK::Clip::Impl&quot;,[&quot;for (int planeNum = 0; planeNum < 6; planeNum++)&quot;,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], vertexMC);&quot;,&quot;    }&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,&quot;varying float clipDistancesVSOutput[6];&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Impl&quot;,[&quot;for (int planeNum = 0; planeNum < 6; planeNum++)&quot;,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    if (clipDistancesVSOutput[planeNum] < 0.0) discard;&quot;,&quot;    }&quot;]).result}e.Vertex=o,e.Fragment=a},e.getShaderTemplate=(e,t,n)=>{e.Vertex=Rd,e.Fragment=Md,e.Geometry=&quot;&quot;},e.setMapperShaderParameters=(n,r,o)=>{const a=n.getProgram(),i=n.getCABO();i.getElementCount()&&(t.VBOBuildTime.getMTime()>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())&&(a.isAttributeUsed(&quot;vertexMC&quot;)&&(n.getVAO().addAttributeArray(a,i,&quot;vertexMC&quot;,i.getVertexOffset(),i.getStride(),t.context.FLOAT,3,t.context.FALSE)||Wf(&quot;Error setting vertexMC in shader VAO.&quot;)),n.getCABO().getCustomData().forEach((e=>{e&&a.isAttributeUsed(e.name)&&!n.getVAO().addAttributeArray(a,i,e.name,e.offset,i.getStride(),t.context.FLOAT,e.components,t.context.FALSE)&&Wf(`Error setting ${e.name} in shader VAO.`)})),n.getAttributeUpdateTime().modified());const s=t.volumeTexture.getTextureUnit();if(a.setUniformi(&quot;volumeTexture&quot;,s),a.setUniformf(&quot;width&quot;,t.renderable.getWidth()),n.getProgram().setUniform4fv(&quot;backgroundColor&quot;,t.renderable.getBackgroundColor()),a.isUniformUsed(&quot;tangentDirection&quot;)){const e=t.renderable.getTangentDirection();n.getProgram().setUniform3fArray(&quot;tangentDirection&quot;,e)}if(a.isUniformUsed(&quot;bitangentDirection&quot;)){const e=t.renderable.getBitangentDirection();n.getProgram().setUniform3fArray(&quot;bitangentDirection&quot;,e)}if(a.isUniformUsed(&quot;centerlineOrientation&quot;)){const e=t.renderable.getUniformOrientation();n.getProgram().setUniform4fv(&quot;centerlineOrientation&quot;,e)}if(a.isUniformUsed(&quot;globalCenterPoint&quot;)){const e=t.renderable.getCenterPoint();a.setUniform3fArray(&quot;globalCenterPoint&quot;,e)}if(t.renderable.isProjectionEnabled()){const e=t.currentImageDataInput,n=e.getSpacing(),r=e.getDimensions(),o=t.renderable.getProjectionSlabThickness(),i=t.renderable.getProjectionSlabNumberOfSamples(),s=Mn([],n,r);a.setUniform3fArray(&quot;volumeSizeMC&quot;,s),a.setUniformi(&quot;projectionSlabNumberOfSamples&quot;,i);const l=-.5*o;a.setUniformf(&quot;projectionConstantOffset&quot;,l);const c=o/(i-1);a.setUniformf(&quot;projectionStepLength&quot;,c)}const l=t.currentImageDataInput,c=l.getWorldToIndex(),u=P(new Float32Array(16),xn([],l.getDimensions())),d=ae(u,u,c);if(a.setUniformMatrix(&quot;MCTCMatrix&quot;,d),t.haveSeenDepthRequest&&n.getProgram().setUniformi(&quot;depthRequest&quot;,t.renderDepth?1:0),t.renderable.getNumberOfClippingPlanes()){let e=t.renderable.getNumberOfClippingPlanes();e>6&&(Wt.vtkErrorMacro(&quot;OpenGL has a limit of 6 clipping planes&quot;),e=6);const n=i.getCoordShiftAndScaleEnabled()?i.getInverseShiftAndScaleMatrix():null,r=n?p(t.imagematinv,o.getMatrix()):o.getMatrix();n&&(h(r,r),b(r,r,n),h(r,r)),h(t.imagemat,t.currentImageDataInput.getIndexToWorld()),b(t.imagematinv,r,t.imagemat);const s=[];for(let n=0;n<e;n++){const e=[];t.renderable.getClippingPlaneInDataCoords(t.imagematinv,n,e);for(let t=0;t<4;t++)s.push(e[t])}a.setUniformi(&quot;numClipPlanes&quot;,e),a.setUniform4fv(&quot;clipPlanes&quot;,s)}if(a.isUniformUsed(&quot;coffset&quot;)){const t=e.getCoincidentParameters(r,o);a.setUniformf(&quot;coffset&quot;,t.offset),a.isUniformUsed(&quot;cfactor&quot;)&&a.setUniformf(&quot;cfactor&quot;,t.factor)}},e.setCameraShaderParameters=(e,n,r)=>{const o=t.openGLImageSlice.getKeyMatrices().mcwc,a=t.openGLCamera.getKeyMatrices(n).wcpc;if(b(t.imagemat,a,o),e.getCABO().getCoordShiftAndScaleEnabled()){const n=e.getCABO().getInverseShiftAndScaleMatrix();b(t.imagemat,t.imagemat,n)}e.getProgram().setUniformMatrix(&quot;MCPCMatrix&quot;,t.imagemat)},e.setPropertyShaderParameters=(e,n,r)=>{const o=e.getProgram(),a=r.getProperty(),i=a.getOpacity();o.setUniformf(&quot;opacity&quot;,i);const s=t.volumeTexture.getComponents(),l=a.getIndependentComponents();if(l)for(let e=0;e<s;++e)o.setUniformf(`mix${e}`,a.getComponentWeight(e));const c=t.volumeTexture.getVolumeInfo();for(let e=0;e<s;e++){let t=a.getColorWindow(),n=a.getColorLevel();const r=l?e:0,i=a.getRGBTransferFunction(r);if(i&&a.getUseLookupTableScalarRange()){const e=i.getRange();t=e[1]-e[0],n=.5*(e[1]+e[0])}const s=c.scale[e]/t,u=(c.offset[e]-n)/t+.5;o.setUniformf(`cshift${e}`,u),o.setUniformf(`cscale${e}`,s)}const u=t.colorTexture.getTextureUnit();o.setUniformi(&quot;colorTexture1&quot;,u);for(let e=0;e<s;e++){let t=1,n=0;const r=l?e:0,i=a.getPiecewiseFunction(r);if(i){const r=i.getRange(),o=r[1]-r[0],a=.5*(r[0]+r[1]);t=c.scale[e]/o,n=(c.offset[e]-a)/o+.5}o.setUniformf(`pwfshift${e}`,n),o.setUniformf(`pwfscale${e}`,t)}const d=t.pwfTexture.getTextureUnit();o.setUniformi(&quot;pwfTexture1&quot;,d)},e.updateShaders=(n,r,o)=>{if(e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};e.buildShaders(a,r,o);const i=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==n.getProgram()&&(n.setProgram(i),n.getVAO().releaseGraphicsResources()),n.getShaderSourceTime().modified()}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(n.getProgram());n.getVAO().bind(),e.setMapperShaderParameters(n,r,o),e.setCameraShaderParameters(n,r,o),e.setPropertyShaderParameters(n,r,o)},e.delete=Wt.chain((()=>{t._openGLRenderWindow&&n(t._openGLRenderWindow)}),e.delete)}(e,t)}),&quot;vtkOpenGLImageCPRMapper&quot;);Jt(&quot;vtkImageCPRMapper&quot;,jf);const Kf={context:null,keyMatrixTime:null,keyMatrices:null};const $f=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Kf,n),qt.extend(e,t,n),t.keyMatrixTime={},ht(t.keyMatrixTime,{mtime:0}),t.keyMatrices={mcwc:m(new Float64Array(16))},Ct(e,t,[&quot;context&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLImageSlice&quot;),e.buildPass=n=>{if(t.renderable&&t.renderable.getVisibility()&&n){if(!t.renderable)return;t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t.context=t._openGLRenderWindow.getContext(),e.prepareNodes(),e.addMissingNode(t.renderable.getMapper()),e.removeUnusedNodes()}},e.traverseZBufferPass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.children.forEach((e=>{e.traverse(n)})),e.apply(n,!1))},e.traverseOpaqueZBufferPass=t=>e.traverseOpaquePass(t),e.traverseOpaquePass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&t.renderable.getIsOpaque()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.children.forEach((e=>{e.traverse(n)})),e.apply(n,!1))},e.traverseTranslucentPass=n=>{!t.renderable||!t.renderable.getNestedVisibility()||t.renderable.getIsOpaque()||t._openGLRenderer.getSelector()&&!t.renderable.getNestedPickable()||(e.apply(n,!0),t.children.forEach((e=>{e.traverse(n)})),e.apply(n,!1))},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;t.renderable.getIsOpaque()?n.incrementOpaqueActorCount():n.incrementTranslucentActorCount()}},e.zBufferPass=(t,n)=>e.opaquePass(t,n),e.opaqueZBufferPass=(t,n)=>e.opaquePass(t,n),e.opaquePass=(e,n)=>{e&&t.context.depthMask(!0)},e.translucentPass=(e,n)=>{t.context.depthMask(!e)},e.getKeyMatrices=()=>(t.renderable.getMTime()>t.keyMatrixTime.getMTime()&&(p(t.keyMatrices.mcwc,t.renderable.getMatrix()),h(t.keyMatrices.mcwc,t.keyMatrices.mcwc),t.keyMatrixTime.modified()),t.keyMatrices)}(e,t)}),&quot;vtkOpenGLImageSlice&quot;);Jt(&quot;vtkImageSlice&quot;,$f);const qf={};const Xf=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,qf,n),qt.extend(e,t,n),t.keyMatrixTime={},ht(t.keyMatrixTime,{mtime:0}),t.normalMatrix=new Float64Array(9),t.MCWCMatrix=new Float64Array(16),Ct(e,t,[&quot;context&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLVolume&quot;),e.buildPass=n=>{t.renderable&&t.renderable.getVisibility()&&n&&(t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t.context=t._openGLRenderWindow.getContext(),e.prepareNodes(),e.addMissingNode(t.renderable.getMapper()),e.removeUnusedNodes())},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;n.incrementVolumeCount()}},e.traverseVolumePass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.children[0].traverse(n),e.apply(n,!1))},e.volumePass=e=>{t.renderable&&t.renderable.getVisibility()&&t.context.depthMask(!e)},e.getKeyMatrices=()=>(t.renderable.getMTime()>t.keyMatrixTime.getMTime()&&(t.renderable.computeMatrix(),p(t.MCWCMatrix,t.renderable.getMatrix()),h(t.MCWCMatrix,t.MCWCMatrix),t.renderable.getIsIdentity()?fe(t.normalMatrix):(le(t.normalMatrix,t.MCWCMatrix),me(t.normalMatrix,t.normalMatrix),ge(t.normalMatrix,t.normalMatrix)),t.keyMatrixTime.modified()),{mcwc:t.MCWCMatrix,normalMatrix:t.normalMatrix})}(e,t)}),&quot;vtkOpenGLVolume&quot;);Jt(&quot;vtkVolume&quot;,Xf);const Yf={NEAREST:0,LINEAR:1,FAST_LINEAR:2},Zf={FRACTIONAL:0,PROPORTIONAL:1},Qf={DEFAULT:0,ADDITIVE:1,COLORIZE:2,CUSTOM:3};var Jf={InterpolationType:Yf,OpacityMode:Zf,ColorMixPreset:Qf,FilterMode:{OFF:0,NORMALIZED:1,RAW:2}};const eg={COMPOSITE_BLEND:0,MAXIMUM_INTENSITY_BLEND:1,MINIMUM_INTENSITY_BLEND:2,AVERAGE_INTENSITY_BLEND:3,ADDITIVE_INTENSITY_BLEND:4,RADON_TRANSFORM_BLEND:5,LABELMAP_EDGE_PROJECTION_BLEND:6};var tg={BlendMode:eg};const{vtkWarningMacro:ng,vtkErrorMacro:rg}=Ht,og={idxToView:m(new Float64Array(16)),vecISToVCMatrix:fe(new Float64Array(9)),modelToView:m(new Float64Array(16)),projectionToView:m(new Float64Array(16)),projectionToWorld:m(new Float64Array(16))};const ag={context:null,VBOBuildTime:null,scalarTextures:[],_scalarTexturesCore:[],opacityTexture:null,_opacityTextureCore:null,colorTexture:null,_colorTextureCore:null,labelOutlineThicknessTexture:null,_labelOutlineThicknessTextureCore:null,jitterTexture:null,tris:null,framebuffer:null,copyShader:null,copyVAO:null,lastXYF:1,targetXYF:1,zBufferTexture:null,lastZBufferTexture:null,fullViewportTime:1,idxToView:null,vecISToVCMatrix:null,modelToView:null,projectionToView:null,avgWindowArea:0,avgFrameTime:0};const ig=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ag,n),qt.extend(e,t,n),Vd(e,t,n),t.VBOBuildTime={},ht(t.VBOBuildTime,{mtime:0}),t.tris=ld.newInstance(),t.jitterTexture=Pd.newInstance(),t.jitterTexture.setWrapS(cd.REPEAT),t.jitterTexture.setWrapT(cd.REPEAT),t.framebuffer=Sp.newInstance(),Ct(e,t,[&quot;context&quot;]),function(e,t){function n(e){return e.getUseLabelOutline()||t.renderable.getBlendMode()===eg.LABELMAP_EDGE_PROJECTION_BLEND}t.classHierarchy.push(&quot;vtkOpenGLVolumeMapper&quot;);const r=new Map;function o(t,n,o){n!==o&&(function(t,n){if(!n)return;const o=(r.get(n)??0)-1;o<=0?(t.unregisterGraphicsResourceUser(n,e),r.delete(n)):r.set(n,o)}(t,n),function(t,n){if(!n)return;const o=r.get(n)??0,a=o+1;r.set(n,a),o<=0&&t.registerGraphicsResourceUser(n,e)}(t,o))}function a(t){[...r.keys()].forEach((n=>t.unregisterGraphicsResourceUser(n,e)))}e.buildPass=()=>{t.zBufferTexture=null},e.zBufferPass=(e,n)=>{if(e){const e=n.getZBufferTexture();e!==t.zBufferTexture&&(t.zBufferTexture=e)}},e.opaqueZBufferPass=(t,n)=>e.zBufferPass(t,n),e.volumePass=(n,r)=>{if(n){const n=t._openGLRenderWindow;t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),n&&!n.isDeleted()&&n!==t._openGLRenderWindow&&a(n),t.context=t._openGLRenderWindow.getContext(),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow),t.jitterTexture.setOpenGLRenderWindow(t._openGLRenderWindow),t.framebuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.openGLVolume=e.getFirstAncestorOfType(&quot;vtkOpenGLVolume&quot;);const r=t.openGLVolume.getRenderable();t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;);const o=t._openGLRenderer.getRenderable();t.openGLCamera=t._openGLRenderer.getViewNodeFor(o.getActiveCamera()),e.renderPiece(o,r)}},e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkVolumeVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\nattribute vec4 vertexDC;\\n\\nvarying vec3 vertexVCVSOutput;\\nuniform mat4 PCVCMatrix;\\n\\nuniform float dcxmin;\\nuniform float dcxmax;\\nuniform float dcymin;\\nuniform float dcymax;\\n\\nvoid main()\\n{\\n  // dcsmall is the device coords reduced to the\\n  // x y area covered by the volume\\n  vec4 dcsmall = vec4(\\n    dcxmin + 0.5 * (vertexDC.x + 1.0) * (dcxmax - dcxmin),\\n    dcymin + 0.5 * (vertexDC.y + 1.0) * (dcymax - dcymin),\\n    vertexDC.z,\\n    vertexDC.w);\\n  vec4 vcpos = PCVCMatrix * dcsmall;\\n  vertexVCVSOutput = vcpos.xyz/vcpos.w;\\n  gl_Position = dcsmall;\\n}\\n&quot;,e.Fragment=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkVolumeFS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// Template for the volume mappers fragment shader\\n\\nconst float infinity = 3.402823466e38;\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nin vec3 vertexVCVSOutput;\\n\\n// From Sources\\\\Rendering\\\\Core\\\\VolumeProperty\\\\Constants.js\\n#define COMPOSITE_BLEND 0\\n#define MAXIMUM_INTENSITY_BLEND 1\\n#define MINIMUM_INTENSITY_BLEND 2\\n#define AVERAGE_INTENSITY_BLEND 3\\n#define ADDITIVE_INTENSITY_BLEND 4\\n#define RADON_TRANSFORM_BLEND 5\\n#define LABELMAP_EDGE_PROJECTION_BLEND 6\\n\\n#define vtkNumberOfLights //VTK::NumberOfLights\\n#define vtkMaxLaoKernelSize //VTK::MaxLaoKernelSize\\n#define vtkNumberOfComponents //VTK::NumberOfComponents\\n#define vtkBlendMode //VTK::BlendMode\\n#define vtkMaximumNumberOfSamples //VTK::MaximumNumberOfSamples\\n\\n//VTK::EnabledColorFunctions\\n\\n//VTK::EnabledLightings\\n\\n//VTK::EnabledMultiTexturePerVolume\\n\\n//VTK::EnabledGradientOpacity\\n\\n//VTK::EnabledIndependentComponents\\n\\n//VTK::vtkProportionalComponents\\n\\n//VTK::vtkForceNearestComponents\\n\\nuniform int twoSidedLighting;\\n\\n#if vtkMaxLaoKernelSize > 0\\n  vec2 kernelSample[vtkMaxLaoKernelSize];\\n#endif\\n\\n// Textures\\n#ifdef EnabledMultiTexturePerVolume\\n  #define vtkNumberOfVolumeTextures vtkNumberOfComponents\\n#else\\n  #define vtkNumberOfVolumeTextures 1\\n#endif\\nuniform highp sampler3D volumeTexture[vtkNumberOfVolumeTextures];\\nuniform sampler2D colorTexture;\\nuniform sampler2D opacityTexture;\\nuniform sampler2D jtexture;\\nuniform sampler2D labelOutlineThicknessTexture;\\n\\nstruct Volume {\\n  // ---- Volume geometry settings ----\\n\\n  vec3 originVC;          // in VC\\n  vec3 spacing;           // in VC per IC\\n  vec3 inverseSpacing;    // 1/spacing\\n  ivec3 dimensions;       // in IC\\n  vec3 inverseDimensions; // 1/vec3(dimensions)\\n  mat3 vecISToVCMatrix;   // convert from IS to VC without translation\\n  mat3 vecVCToISMatrix;   // convert from VC to IS without translation\\n  mat4 PCWCMatrix;\\n  mat4 worldToIndex;\\n  float diagonalLength; // in VC, this is: length(size)\\n\\n  // ---- Texture settings ----\\n\\n  // Texture shift and scale\\n  vec4 colorTextureScale;\\n  vec4 colorTextureShift;\\n  vec4 opacityTextureScale;\\n  vec4 opacityTextureShift;\\n\\n  // The heights defined below are the locations for the up to four components\\n  // of the transfer functions. The transfer functions have a height of (2 *\\n  // numberOfComponents) pixels so the values are computed to hit the middle of\\n  // the two rows for that component\\n  vec4 transferFunctionsSampleHeight;\\n\\n  // ---- Mode specific settings ----\\n\\n  // Independent component default preset settings per component\\n  vec4 independentComponentMix;\\n\\n  // Additive / average blending mode settings\\n  vec4 ipScalarRangeMin;\\n  vec4 ipScalarRangeMax;\\n\\n  // ---- Rendering settings ----\\n\\n  // Lighting\\n  float ambient;\\n  float diffuse;\\n  float specular;\\n  float specularPower;\\n  int computeNormalFromOpacity;\\n\\n  // Gradient opacity\\n  vec4 gradientOpacityScale;\\n  vec4 gradientOpacityShift;\\n  vec4 gradientOpacityMin;\\n  vec4 gradientOpacityMax;\\n\\n  // Volume shadow\\n  float volumetricScatteringBlending;\\n  float globalIlluminationReach;\\n  float anisotropy;\\n  float anisotropySquared;\\n\\n  // LAO\\n  int kernelSize;\\n  int kernelRadius;\\n\\n  // Label outline\\n  float outlineOpacity;\\n};\\nuniform Volume volume;\\n\\nstruct Light {\\n  vec3 color;\\n  vec3 positionVC;\\n  vec3 directionVC; // normalized\\n  vec3 halfAngleVC;\\n  vec3 attenuation;\\n  float exponent;\\n  float coneAngle;\\n  int isPositional;\\n};\\n#if vtkNumberOfLights > 0\\n  uniform Light lights[vtkNumberOfLights];\\n#endif\\n\\nuniform float vpWidth;\\nuniform float vpHeight;\\nuniform float vpOffsetX;\\nuniform float vpOffsetY;\\n\\n// Bitmasks for label outline\\nconst int MAX_SEGMENT_INDEX = 256; // Define as per expected maximum\\n#define MAX_SEGMENTS 256\\n#define UINT_SIZE 32\\n// We add UINT_SIZE - 1, as we want the ceil of the division instead of the\\n// floor\\n#define BITMASK_SIZE ((MAX_SEGMENTS + UINT_SIZE - 1) / UINT_SIZE)\\nuint labelOutlineBitmasks[BITMASK_SIZE];\\n\\n// Set the corresponding bit in the bitmask\\nvoid setLabelOutlineBit(int segmentIndex) {\\n  int arrayIndex = segmentIndex / UINT_SIZE;\\n  int bitIndex = segmentIndex % UINT_SIZE;\\n  labelOutlineBitmasks[arrayIndex] |= 1u << bitIndex;\\n}\\n\\n// Check if a bit is set in the bitmask\\nbool isLabelOutlineBitSet(int segmentIndex) {\\n  int arrayIndex = segmentIndex / UINT_SIZE;\\n  int bitIndex = segmentIndex % UINT_SIZE;\\n  return ((labelOutlineBitmasks[arrayIndex] & (1u << bitIndex)) != 0u);\\n}\\n\\n// if you want to see the raw tiled\\n// data in webgl1 uncomment the following line\\n// #define debugtile\\n\\n// camera values\\nuniform float camThick;\\nuniform float camNear;\\nuniform float camFar;\\nuniform int cameraParallel;\\n\\n//VTK::ClipPlane::Dec\\n\\n// A random number between 0 and 1 that only depends on the fragment\\n// It uses the jtexture, so this random seed repeats by blocks of 32 fragments\\n// in screen space\\nfloat fragmentSeed;\\n\\n// sample texture is global\\nuniform float sampleDistance;\\nuniform float volumeShadowSampleDistance;\\n\\n// declaration for intermixed geometry\\n//VTK::ZBuffer::Dec\\n\\n//=======================================================================\\n// global and custom variables (a temporary section before photorealistics\\n// rendering module is complete)\\nvec3 rayDirVC;\\n\\n#define INV4PI 0.0796\\n#define EPSILON 0.001\\n#define PI 3.1415\\n#define PI2 9.8696\\n\\nvec4 rawSampleTexture(vec3 pos) {\\n  #ifdef EnabledMultiTexturePerVolume\\n    vec4 rawSample;\\n    rawSample[0] = texture(volumeTexture[0], pos)[0];\\n  #if vtkNumberOfComponents > 1\\n    rawSample[1] = texture(volumeTexture[1], pos)[0];\\n  #endif\\n  #if vtkNumberOfComponents > 2\\n    rawSample[2] = texture(volumeTexture[2], pos)[0];\\n  #endif\\n  #if vtkNumberOfComponents > 3\\n    rawSample[3] = texture(volumeTexture[3], pos)[0];\\n  #endif\\n    return rawSample;\\n  #else\\n    return texture(volumeTexture[0], pos);\\n  #endif\\n}\\n\\nvec4 rawFetchTexture(ivec3 pos) {\\n  #ifdef EnabledMultiTexturePerVolume\\n    vec4 rawSample;\\n    #if vtkNumberOfComponents > 0\\n      rawSample[0] = texelFetch(volumeTexture[0], pos, 0)[0];\\n    #endif\\n    #if vtkNumberOfComponents > 1\\n      rawSample[1] = texelFetch(volumeTexture[1], pos, 0)[0];\\n    #endif\\n    #if vtkNumberOfComponents > 2\\n      rawSample[2] = texelFetch(volumeTexture[2], pos, 0)[0];\\n    #endif\\n    #if vtkNumberOfComponents > 3\\n      rawSample[3] = texelFetch(volumeTexture[3], pos, 0)[0];\\n    #endif\\n    return rawSample;\\n  #else\\n    return texelFetch(volumeTexture[0], pos, 0);\\n  #endif\\n}\\n\\nvec4 getTextureValue(vec3 pos) {\\n  vec4 tmp = rawSampleTexture(pos);\\n\\n  // Force nearest\\n  #if defined(vtkComponent0ForceNearest) || \\\\\\n      defined(vtkComponent1ForceNearest) || \\\\\\n      defined(vtkComponent2ForceNearest) || \\\\\\n      defined(vtkComponent3ForceNearest)\\n    vec3 nearestPos = (floor(pos * vec3(volume.dimensions)) + 0.5) *\\n                      volume.inverseDimensions;\\n    vec4 nearestValue = rawSampleTexture(nearestPos);\\n    #ifdef vtkComponent0ForceNearest\\n      tmp[0] = nearestValue[0];\\n    #endif\\n    #ifdef vtkComponent1ForceNearest\\n      tmp[1] = nearestValue[1];\\n    #endif\\n    #ifdef vtkComponent2ForceNearest\\n      tmp[2] = nearestValue[2];\\n    #endif\\n    #ifdef vtkComponent3ForceNearest\\n      tmp[3] = nearestValue[3];\\n    #endif\\n  #endif\\n\\n  // Set alpha when using dependent components\\n  #ifndef EnabledIndependentComponents\\n    #if vtkNumberOfComponents == 1\\n      tmp.a = tmp.r;\\n    #endif\\n    #if vtkNumberOfComponents == 2\\n      tmp.a = tmp.g;\\n    #endif\\n    #if vtkNumberOfComponents == 3\\n      tmp.a = length(tmp.rgb);\\n    #endif\\n  #endif\\n\\n  return tmp;\\n}\\n\\n// `height` is usually `volume.transferFunctionsSampleHeight[component]`\\n// when using independent component and `0.5` otherwise. Don't move the if\\n// statement in these function, as the callers usually already knows if it is\\n// using independent component or not\\nfloat getOpacityFromTexture(float scalar, int component, float height) {\\n  float scaledScalar = scalar * volume.opacityTextureScale[component] +\\n                       volume.opacityTextureShift[component];\\n  return texture2D(opacityTexture, vec2(scaledScalar, height)).r;\\n}\\nvec3 getColorFromTexture(float scalar, int component, float height) {\\n  float scaledScalar = scalar * volume.colorTextureScale[component] +\\n                       volume.colorTextureShift[component];\\n  return texture2D(colorTexture, vec2(scaledScalar, height)).rgb;\\n}\\n\\n//=======================================================================\\n// transformation between VC and IS space\\n\\n// convert vector position from idx to vc\\nvec3 posIStoVC(vec3 posIS) {\\n  return volume.vecISToVCMatrix * posIS + volume.originVC;\\n}\\n\\n// convert vector position from vc to idx\\nvec3 posVCtoIS(vec3 posVC) {\\n  return volume.vecVCToISMatrix * (posVC - volume.originVC);\\n}\\n\\n// Rotate vector to view coordinate\\nvec3 vecISToVC(vec3 dirIS) {\\n  return volume.vecISToVCMatrix * dirIS;\\n}\\n\\n// Rotate vector to idx coordinate\\nvec3 vecVCToIS(vec3 dirVC) {\\n  return volume.vecVCToISMatrix * dirVC;\\n}\\n\\n//=======================================================================\\n// Given a normal compute the gradient opacity factors\\nfloat computeGradientOpacityFactor(float normalMag, int component) {\\n  float goscale = volume.gradientOpacityScale[component];\\n  float goshift = volume.gradientOpacityShift[component];\\n  float gomin = volume.gradientOpacityMin[component];\\n  float gomax = volume.gradientOpacityMax[component];\\n  return clamp(normalMag * goscale + goshift, gomin, gomax);\\n}\\n\\n#ifdef vtkClippingPlanesOn\\n  bool isPointClipped(vec3 posVC) {\\n    for (int i = 0; i < clip_numPlanes; ++i) {\\n      if (dot(vec3(vClipPlaneOrigins[i] - posVC), vClipPlaneNormals[i]) > 0.0) {\\n        return true;\\n      }\\n    }\\n    return false;\\n  }\\n#endif\\n\\n//=======================================================================\\n// compute the normal and gradient magnitude for a position, uses forward\\n// difference\\n\\n// The output normal is in VC\\nvec4 computeDensityNormal(vec3 opacityUCoords[2], float opacityTextureHeight,\\n                          float gradientOpacity, int component) {\\n  // Pass the scalars through the opacity functions\\n  vec4 opacityG;\\n  opacityG.x += getOpacityFromTexture(opacityUCoords[0].x, component,\\n                                      opacityTextureHeight);\\n  opacityG.y += getOpacityFromTexture(opacityUCoords[0].y, component,\\n                                      opacityTextureHeight);\\n  opacityG.z += getOpacityFromTexture(opacityUCoords[0].z, component,\\n                                      opacityTextureHeight);\\n  opacityG.x -= getOpacityFromTexture(opacityUCoords[1].x, component,\\n                                      opacityTextureHeight);\\n  opacityG.y -= getOpacityFromTexture(opacityUCoords[1].y, component,\\n                                      opacityTextureHeight);\\n  opacityG.z -= getOpacityFromTexture(opacityUCoords[1].z, component,\\n                                      opacityTextureHeight);\\n\\n  // Divide by spacing and convert to VC\\n  opacityG.xyz *= gradientOpacity * volume.inverseSpacing;\\n  opacityG.w = length(opacityG.xyz);\\n  if (opacityG.w == 0.0) {\\n    return vec4(0.0);\\n  }\\n\\n  // Normalize\\n  opacityG.xyz = normalize(vecISToVC(opacityG.xyz));\\n\\n  return opacityG;\\n}\\n\\n// The output normal is in VC\\nvec4 computeNormalForDensity(vec3 posIS, out vec3 scalarInterp[2],\\n                             const int opacityComponent) {\\n  vec3 offsetedPosIS;\\n  for (int axis = 0; axis < 3; ++axis) {\\n    // Positive direction\\n    offsetedPosIS = posIS;\\n    offsetedPosIS[axis] += volume.inverseDimensions[axis];\\n    scalarInterp[0][axis] =\\n        getTextureValue(offsetedPosIS)[opacityComponent];\\n    #ifdef vtkClippingPlanesOn\\n      if (isPointClipped(posIStoVC(offsetedPosIS))) {\\n        scalarInterp[0][axis] = 0.0;\\n      }\\n    #endif\\n\\n    // Negative direction\\n    offsetedPosIS = posIS;\\n    offsetedPosIS[axis] -= volume.inverseDimensions[axis];\\n    scalarInterp[1][axis] =\\n        getTextureValue(offsetedPosIS)[opacityComponent];\\n    #ifdef vtkClippingPlanesOn\\n      if (isPointClipped(posIStoVC(offsetedPosIS))) {\\n        scalarInterp[1][axis] = 0.0;\\n      }\\n    #endif\\n  }\\n\\n  vec4 result;\\n  result.xyz = (scalarInterp[0] - scalarInterp[1]) * volume.inverseSpacing;\\n  result.w = length(result.xyz);\\n  if (result.w == 0.0) {\\n    return vec4(0.0);\\n  }\\n  result.xyz = normalize(vecISToVC(result.xyz));\\n  return result;\\n}\\n\\nvec4 fragCoordToPCPos(vec4 fragCoord) {\\n  return vec4((fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,\\n              (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,\\n              (fragCoord.z - 0.5) * 2.0, 1.0);\\n}\\n\\nvec4 pcPosToWorldCoord(vec4 pcPos) {\\n  return volume.PCWCMatrix * pcPos;\\n}\\n\\nvec3 fragCoordToIndexSpace(vec4 fragCoord) {\\n  vec4 pcPos = fragCoordToPCPos(fragCoord);\\n  vec4 worldCoord = pcPosToWorldCoord(pcPos);\\n  vec4 vertex = (worldCoord / worldCoord.w);\\n\\n  vec3 index = (volume.worldToIndex * vertex).xyz;\\n\\n  // half voxel fix for labelmapOutline\\n  return (index + vec3(0.5)) * volume.inverseDimensions;\\n}\\n\\nvec3 fragCoordToWorld(vec4 fragCoord) {\\n  vec4 pcPos = fragCoordToPCPos(fragCoord);\\n  vec4 worldCoord = pcPosToWorldCoord(pcPos);\\n  return worldCoord.xyz;\\n}\\n\\n//=======================================================================\\n// Compute the normals and gradient magnitudes for a position for independent\\n// components The output normals are in VC\\nmat4 computeMat4Normal(vec3 posIS, vec4 tValue) {\\n  vec3 xvec = vec3(volume.inverseDimensions.x, 0.0, 0.0);\\n  vec3 yvec = vec3(0.0, volume.inverseDimensions.y, 0.0);\\n  vec3 zvec = vec3(0.0, 0.0, volume.inverseDimensions.z);\\n\\n  vec4 distX = getTextureValue(posIS + xvec) - getTextureValue(posIS - xvec);\\n  vec4 distY = getTextureValue(posIS + yvec) - getTextureValue(posIS - yvec);\\n  vec4 distZ = getTextureValue(posIS + zvec) - getTextureValue(posIS - zvec);\\n\\n  // divide by spacing\\n  distX *= 0.5 * volume.inverseSpacing.x;\\n  distY *= 0.5 * volume.inverseSpacing.y;\\n  distZ *= 0.5 * volume.inverseSpacing.z;\\n\\n  mat4 result;\\n\\n  // optionally compute the 1st component\\n  #if vtkNumberOfComponents > 0 && !defined(vtkComponent0Proportional)\\n    {\\n      const int component = 0;\\n      vec3 normal = vec3(distX[component], distY[component], distZ[component]);\\n      float normalLength = length(normal);\\n      if (normalLength > 0.0) {\\n        normal = normalize(vecISToVC(normal));\\n      }\\n      result[component] = vec4(normal, normalLength);\\n    }\\n  #endif\\n\\n  // optionally compute the 2nd component\\n  #if vtkNumberOfComponents > 1 && !defined(vtkComponent1Proportional)\\n    {\\n      const int component = 1;\\n      vec3 normal = vec3(distX[component], distY[component], distZ[component]);\\n      float normalLength = length(normal);\\n      if (normalLength > 0.0) {\\n        normal = normalize(vecISToVC(normal));\\n      }\\n      result[component] = vec4(normal, normalLength);\\n    }\\n  #endif\\n\\n  // optionally compute the 3rd component\\n  #if vtkNumberOfComponents > 2 && !defined(vtkComponent2Proportional)\\n    {\\n      const int component = 2;\\n      vec3 normal = vec3(distX[component], distY[component], distZ[component]);\\n      float normalLength = length(normal);\\n      if (normalLength > 0.0) {\\n        normal = normalize(vecISToVC(normal));\\n      }\\n      result[component] = vec4(normal, normalLength);\\n    }\\n  #endif\\n\\n  // optionally compute the 4th component\\n  #if vtkNumberOfComponents > 3 && !defined(vtkComponent3Proportional)\\n    {\\n      const int component = 3;\\n      vec3 normal = vec3(distX[component], distY[component], distZ[component]);\\n      float normalLength = length(normal);\\n      if (normalLength > 0.0) {\\n        normal = normalize(vecISToVC(normal));\\n      }\\n      result[component] = vec4(normal, normalLength);\\n    }\\n  #endif\\n\\n  return result;\\n}\\n\\n//=======================================================================\\n// global shadow - secondary ray\\n\\n// henyey greenstein phase function\\nfloat phaseFunction(float cos_angle) {\\n  // divide by 2.0 instead of 4pi to increase intensity\\n  float anisotropy = volume.anisotropy;\\n  if (abs(anisotropy) <= EPSILON) {\\n    // isotropic scatter returns 0.5 instead of 1/4pi to increase intensity\\n    return 0.5;\\n  }\\n  float anisotropy2 = volume.anisotropySquared;\\n  return ((1.0 - anisotropy2) /\\n          pow(1.0 + anisotropy2 - 2.0 * anisotropy * cos_angle, 1.5)) /\\n         2.0;\\n}\\n\\n// Compute the two intersection distances of the ray with the volume in VC\\n// The entry point is `rayOriginVC + distanceMin * rayDirVC` and the exit point\\n// is `rayOriginVC + distanceMax * rayDirVC` If distanceMin < distanceMax, the\\n// volume is not intersected The ray origin is inside the box when distanceMin <\\n// 0.0 < distanceMax\\nvec2 rayIntersectVolumeDistances(vec3 rayOriginVC, vec3 rayDirVC) {\\n  // Compute origin and direction in IS\\n  vec3 rayOriginIS = posVCtoIS(rayOriginVC);\\n  vec3 rayDirIS = vecVCToIS(rayDirVC);\\n  // Don't check for infinity as the min/max combination afterward will always\\n  // find an intersection before infinity\\n  vec3 invDir = 1.0 / rayDirIS;\\n\\n  // We have: bound = origin + t * dir\\n  // So: t = (1/dir) * (bound - origin)\\n  vec3 distancesTo0 = invDir * (vec3(0.0) - rayOriginIS);\\n  vec3 distancesTo1 = invDir * (vec3(1.0) - rayOriginIS);\\n  // Min and max distances to plane intersection per plane\\n  vec3 dMinPerAxis = min(distancesTo0, distancesTo1);\\n  vec3 dMaxPerAxis = max(distancesTo0, distancesTo1);\\n  // Overall first and last intersection\\n  float distanceMin = max(dMinPerAxis.x, max(dMinPerAxis.y, dMinPerAxis.z));\\n  float distanceMax = min(dMaxPerAxis.x, min(dMaxPerAxis.y, dMaxPerAxis.z));\\n  return vec2(distanceMin, distanceMax);\\n}\\n\\n//=======================================================================\\n// local ambient occlusion\\n#if vtkMaxLaoKernelSize > 0\\n\\n  // Return a random point on the unit sphere\\n  vec3 sampleDirectionUniform(int rayIndex) {\\n    // Each ray of each fragment should be different, two sources of randomness\\n    // are used. Only depends on ray index\\n    vec2 rayRandomness = kernelSample[rayIndex];\\n    // Only depends on fragment\\n    float fragmentRandomness = fragmentSeed;\\n    // Merge both source of randomness in a single uniform random variable using\\n    // the formula (x+y < 1 ? x+y : x+y-1). The simpler formula (x+y)/2 doesn't\\n    // result in a uniform distribution\\n    vec2 mergedRandom = rayRandomness + vec2(fragmentRandomness);\\n    mergedRandom -= vec2(greaterThanEqual(mergedRandom, vec2(1.0)));\\n\\n    // Insipred by:\\n    // https://karthikkaranth.me/blog/generating-random-points-in-a-sphere/#better-choice-of-spherical-coordinates\\n    float u = mergedRandom[0];\\n    float v = mergedRandom[1];\\n    float theta = u * 2.0 * PI;\\n    float phi = acos(2.0 * v - 1.0);\\n    float sinTheta = sin(theta);\\n    float cosTheta = cos(theta);\\n    float sinPhi = sin(phi);\\n    float cosPhi = cos(phi);\\n    return vec3(sinPhi * cosTheta, sinPhi * sinTheta, cosPhi);\\n  }\\n\\n  float computeLAO(vec3 posVC, vec4 normalVC, float originalOpacity) {\\n    // apply LAO only at selected locations, otherwise return full brightness\\n    if (normalVC.w <= 0.0 || originalOpacity <= 0.05) {\\n      return 1.0;\\n    }\\n\\n    #ifdef EnabledGradientOpacity\\n      float gradientOpacityFactor = computeGradientOpacityFactor(normalVC.w, 0);\\n    #endif\\n\\n    float visibilitySum = 0.0;\\n    float weightSum = 0.0;\\n    for (int i = 0; i < volume.kernelSize; i++) {\\n      // Only sample on an hemisphere around the normalVC.xyz axis, so\\n      // normalDotRay should be negative\\n      vec3 rayDirectionVC = sampleDirectionUniform(i);\\n      float normalDotRay = dot(normalVC.xyz, rayDirectionVC);\\n      if (normalDotRay > 0.0) {\\n        // Flip rayDirectionVC when it is in the wrong hemisphere\\n        rayDirectionVC = -rayDirectionVC;\\n        normalDotRay = -normalDotRay;\\n      }\\n\\n      vec3 currPosIS = posVCtoIS(posVC);\\n      float visibility = 1.0;\\n      vec3 randomDirStepIS = vecVCToIS(rayDirectionVC * sampleDistance);\\n      for (int j = 0; j < volume.kernelRadius; j++) {\\n        currPosIS += randomDirStepIS;\\n        // If out of the volume, we are done\\n        if (any(lessThan(currPosIS, vec3(0.0))) ||\\n            any(greaterThan(currPosIS, vec3(1.0)))) {\\n          break;\\n        }\\n        float opacity = getOpacityFromTexture(getTextureValue(currPosIS).r, 0, 0.5);\\n        #ifdef EnabledGradientOpacity\\n          opacity *= gradientOpacityFactor;\\n        #endif\\n        visibility *= 1.0 - opacity;\\n        // If visibility is less than EPSILON, consider it to be 0\\n        if (visibility < EPSILON) {\\n          visibility = 0.0;\\n          break;\\n        }\\n      }\\n      float rayWeight = -normalDotRay;\\n      visibilitySum += visibility * rayWeight;\\n      weightSum += rayWeight;\\n    }\\n\\n    // If no sample, LAO factor is one\\n    if (weightSum == 0.0) {\\n      return 1.0;\\n    }\\n\\n    // LAO factor is the average visibility:\\n    // - visibility low => ambient low\\n    // - visibility high => ambient high\\n    float lao = visibilitySum / weightSum;\\n\\n    // Reduce variance by clamping\\n    return clamp(lao, 0.3, 1.0);\\n  }\\n#endif\\n\\n//=======================================================================\\n// Volume shadows\\n#if vtkNumberOfLights > 0\\n\\n  // Non-memoised version\\n  float computeVolumeShadowWithoutCache(vec3 posVC, vec3 lightDirNormVC) {\\n    // modify sample distance with a random number between 1.5 and 3.0\\n    float rayStepLength =\\n        volumeShadowSampleDistance * mix(1.5, 3.0, fragmentSeed);\\n\\n    // in case the first sample near surface has a very tiled light ray, we need\\n    // to offset start position\\n    vec3 initialPosVC = posVC + rayStepLength * lightDirNormVC;\\n\\n    #ifdef vtkClippingPlanesOn\\n      float clippingPlanesMaxDistance = infinity;\\n      for (int i = 0; i < clip_numPlanes; ++i) {\\n        // Find distance of intersection with the plane\\n        // Points are clipped when:\\n        // dot(planeOrigin - (rayOrigin + distance * rayDirection), planeNormal) > 0\\n        // This is equivalent to:\\n        // dot(planeOrigin - rayOrigin, planeNormal) - distance * dot(rayDirection,\\n        // planeNormal) > 0.0\\n        // We precompute the dot products, so we clip ray points when:\\n        // dotOrigin - distance * dotDirection > 0.0\\n        float dotOrigin =\\n            dot(vClipPlaneOrigins[i] - initialPosVC, vClipPlaneNormals[i]);\\n        if (dotOrigin > 0.0) {\\n          // The initialPosVC is clipped by this plane\\n          return 1.0;\\n        }\\n        float dotDirection = dot(lightDirNormVC, vClipPlaneNormals[i]);\\n        if (dotDirection < 0.0) {\\n          // We only hit the plane if dotDirection is negative, as (distance is\\n          // positive)\\n          float intersectionDistance =\\n              dotOrigin / dotDirection; // negative divided by negative => positive\\n          clippingPlanesMaxDistance =\\n              min(clippingPlanesMaxDistance, intersectionDistance);\\n        }\\n      }\\n    #endif\\n\\n    vec2 intersectionDistances =\\n        rayIntersectVolumeDistances(initialPosVC, lightDirNormVC);\\n\\n    if (intersectionDistances[1] <= intersectionDistances[0] ||\\n        intersectionDistances[1] <= 0.0) {\\n      // Volume not hit or behind the ray\\n      return 1.0;\\n    }\\n\\n    // When globalIlluminationReach is 0, no sample at all\\n    // When globalIlluminationReach is 1, the ray will go through the whole\\n    // volume\\n    float maxTravelDistance = mix(0.0, volume.diagonalLength,\\n                                  volume.globalIlluminationReach);\\n    float startDistance = max(intersectionDistances[0], 0.0);\\n    float endDistance = min(intersectionDistances[1], startDistance + maxTravelDistance);\\n    #ifdef vtkClippingPlanesOn\\n      endDistance = min(endDistance, clippingPlanesMaxDistance);\\n    #endif\\n    if (endDistance - startDistance < 0.0) {\\n      return 1.0;\\n    }\\n\\n    // These two variables are used to compute posIS, without having to call\\n    // VCtoIS at each step\\n    vec3 initialPosIS = posVCtoIS(initialPosVC);\\n    // The light dir is scaled and rotated, but not translated, as it is a\\n    // vector (w = 0)\\n    vec3 scaledLightDirIS = vecVCToIS(lightDirNormVC);\\n\\n    float shadow = 1.0;\\n    for (float currentDistance = startDistance; currentDistance <= endDistance;\\n          currentDistance += rayStepLength) {\\n      vec3 posIS = initialPosIS + currentDistance * scaledLightDirIS;\\n      vec4 scalar = getTextureValue(posIS);\\n      float opacity = getOpacityFromTexture(scalar.r, 0, 0.5);\\n      #if defined(EnabledGradientOpacity) && !defined(EnabledIndependentComponents)\\n        vec3 scalarInterp[2];\\n        vec4 normal = computeNormalForDensity(posIS, scalarInterp, 3);\\n        float opacityFactor = computeGradientOpacityFactor(normal.w, 0);\\n        opacity *= opacityFactor;\\n      #endif\\n      shadow *= 1.0 - opacity;\\n\\n      // Early termination if shadow coeff is near 0.0\\n      if (shadow < EPSILON) {\\n        return 0.0;\\n      }\\n    }\\n    return shadow;\\n  }\\n\\n  // Some cache for volume shadows\\n  struct {\\n    vec3 posVC;\\n    float shadow;\\n  } cachedShadows[vtkNumberOfLights];\\n\\n  // Memoised version\\n  float computeVolumeShadow(vec3 posVC, vec3 lightDirNormVC, int lightIdx) {\\n    if (posVC == cachedShadows[lightIdx].posVC) {\\n      return cachedShadows[lightIdx].shadow;\\n    }\\n    float shadow = computeVolumeShadowWithoutCache(posVC, lightDirNormVC);\\n    cachedShadows[lightIdx].posVC = posVC;\\n    cachedShadows[lightIdx].shadow = shadow;\\n    return shadow;\\n  }\\n\\n#endif\\n\\n//=======================================================================\\n// surface light contribution\\n#if vtkNumberOfLights > 0\\n  vec3 applyLighting(vec3 tColor, vec4 normalVC) {\\n    vec3 diffuse = vec3(0.0, 0.0, 0.0);\\n    vec3 specular = vec3(0.0, 0.0, 0.0);\\n    for (int lightIdx = 0; lightIdx < vtkNumberOfLights; lightIdx++) {\\n      float df = dot(normalVC.xyz, lights[lightIdx].directionVC);\\n      if (df > 0.0) {\\n        diffuse += df * lights[lightIdx].color;\\n        float sf = dot(normalVC.xyz, -lights[lightIdx].halfAngleVC);\\n        if (sf > 0.0) {\\n          specular += pow(sf, volume.specularPower) * lights[lightIdx].color;\\n        }\\n      }\\n    }\\n    return tColor * (diffuse * volume.diffuse + volume.ambient) +\\n          specular * volume.specular;\\n  }\\n\\n  vec3 applySurfaceShadowLighting(vec3 tColor, float alpha, vec3 posVC,\\n                                  vec4 normalVC) {\\n    // everything in VC\\n    vec3 diffuse = vec3(0.0);\\n    vec3 specular = vec3(0.0);\\n    for (int ligthIdx = 0; ligthIdx < vtkNumberOfLights; ligthIdx++) {\\n      vec3 vertLightDirection;\\n      float attenuation;\\n      if (lights[ligthIdx].isPositional == 1) {\\n        vertLightDirection = posVC - lights[ligthIdx].positionVC;\\n        float lightDistance = length(vertLightDirection);\\n        // Normalize with precomputed length\\n        vertLightDirection = vertLightDirection / lightDistance;\\n        // Base attenuation\\n        vec3 attenuationPolynom = lights[ligthIdx].attenuation;\\n        attenuation =\\n            1.0 / (attenuationPolynom[0] +\\n                  lightDistance * (attenuationPolynom[1] +\\n                                    lightDistance * attenuationPolynom[2]));\\n        // Cone attenuation\\n        float coneDot = dot(vertLightDirection, lights[ligthIdx].directionVC);\\n        // Per OpenGL standard cone angle is 90 or less for a spot light\\n        if (lights[ligthIdx].coneAngle <= 90.0) {\\n          if (coneDot >= cos(radians(lights[ligthIdx].coneAngle))) {\\n            // Inside the cone\\n            attenuation *= pow(coneDot, lights[ligthIdx].exponent);\\n          } else {\\n            // Outside the cone\\n            attenuation = 0.0;\\n          }\\n        }\\n      } else {\\n        vertLightDirection = lights[ligthIdx].directionVC;\\n        attenuation = 1.0;\\n      }\\n\\n      float ndotL = dot(normalVC.xyz, vertLightDirection);\\n      if (ndotL < 0.0 && twoSidedLighting == 1) {\\n        ndotL = -ndotL;\\n      }\\n      if (ndotL > 0.0) {\\n        // Diffuse\\n        diffuse += ndotL * attenuation * lights[ligthIdx].color;\\n        // Specular\\n        float vdotR =\\n            dot(-rayDirVC, normalize(vertLightDirection - 2.0 * ndotL * normalVC.xyz));\\n        if (vdotR > 0.0) {\\n          specular += pow(vdotR, volume.specularPower) * attenuation *\\n                      lights[ligthIdx].color;\\n        }\\n      }\\n    }\\n    #if vtkMaxLaoKernelSize > 0\\n      float laoFactor = computeLAO(posVC, normalVC, alpha);\\n    #else\\n      const float laoFactor = 1.0;\\n    #endif\\n    return tColor * (diffuse * volume.diffuse +\\n                    volume.ambient * laoFactor) +\\n          specular * volume.specular;\\n  }\\n\\n  vec3 applyVolumeShadowLighting(vec3 tColor, vec3 posVC) {\\n    // Here we have no effect of cones and no attenuation\\n    vec3 diffuse = vec3(0.0);\\n    for (int lightIdx = 0; lightIdx < vtkNumberOfLights; lightIdx++) {\\n      vec3 lightDirVC = lights[lightIdx].isPositional == 1\\n                            ? normalize(lights[lightIdx].positionVC - posVC)\\n                            : -lights[lightIdx].directionVC;\\n      float shadowCoeff = computeVolumeShadow(posVC, lightDirVC, lightIdx);\\n      float phaseAttenuation = phaseFunction(dot(rayDirVC, lightDirVC));\\n      diffuse += phaseAttenuation * shadowCoeff * lights[lightIdx].color;\\n    }\\n    return tColor * (diffuse * volume.diffuse + volume.ambient);\\n  }\\n#endif\\n\\n// LAO of surface shadows and volume shadows only work with dependent components\\nvec3 applyAllLightning(vec3 tColor, float alpha, vec3 posVC,\\n                       vec4 surfaceNormalVC) {\\n  #if vtkNumberOfLights > 0\\n    // 0 <= volCoeff < EPSILON => only surface shadows\\n    // EPSILON <= volCoeff < 1 - EPSILON => mix of surface and volume shadows\\n    // 1 - EPSILON <= volCoeff => only volume shadows\\n    float volCoeff = volume.volumetricScatteringBlending *\\n                    (1.0 - alpha / 2.0) *\\n                    (1.0 - atan(surfaceNormalVC.w) * INV4PI);\\n\\n    // Compute surface lighting if needed\\n    vec3 surfaceShadedColor = tColor;\\n    #ifdef EnableSurfaceLighting\\n      if (volCoeff < 1.0 - EPSILON) {\\n        surfaceShadedColor =\\n            applySurfaceShadowLighting(tColor, alpha, posVC, surfaceNormalVC);\\n      }\\n    #endif\\n\\n    // Compute volume lighting if needed\\n    vec3 volumeShadedColor = tColor;\\n    #ifdef EnableVolumeLighting\\n      if (volCoeff >= EPSILON) {\\n        volumeShadedColor = applyVolumeShadowLighting(tColor, posVC);\\n      }\\n    #endif\\n\\n    // Return the right mix\\n    if (volCoeff < EPSILON) {\\n      // Surface shadows\\n      return surfaceShadedColor;\\n    }\\n    if (volCoeff >= 1.0 - EPSILON) {\\n      // Volume shadows\\n      return volumeShadedColor;\\n    }\\n    // Mix of surface and volume shadows\\n    return mix(surfaceShadedColor, volumeShadedColor, volCoeff);\\n  #endif\\n  return tColor;\\n}\\n\\nvec4 getColorForLabelOutline() {\\n  vec3 centerPosIS =\\n      fragCoordToIndexSpace(gl_FragCoord); // pos in texture space\\n  vec4 centerValue = getTextureValue(centerPosIS);\\n  bool pixelOnBorder = false;\\n  vec4 tColor = vec4(getColorFromTexture(centerValue.r, 0, 0.5),\\n                     getOpacityFromTexture(centerValue.r, 0, 0.5));\\n\\n  int segmentIndex = int(centerValue.r * 255.0);\\n\\n  // Use texture sampling for outlineThickness\\n  float textureCoordinate = float(segmentIndex - 1) / 1024.0;\\n  float textureValue =\\n      texture2D(labelOutlineThicknessTexture, vec2(textureCoordinate, 0.5)).r;\\n  int actualThickness = int(textureValue * 255.0);\\n\\n  // If it is the background (segment index 0), we should quickly bail out.\\n  // Previously, this was determined by tColor.a, which was incorrect as it\\n  // prevented the outline from appearing when the fill is 0.\\n  if (segmentIndex == 0) {\\n    return vec4(0, 0, 0, 0);\\n  }\\n\\n  // Only perform outline check on fragments rendering voxels that aren't\\n  // invisible. Saves a bunch of needless checks on the background.\\n  // TODO define epsilon when building shader?\\n  for (int i = -actualThickness; i <= actualThickness; i++) {\\n    for (int j = -actualThickness; j <= actualThickness; j++) {\\n      if (i == 0 || j == 0) {\\n        continue;\\n      }\\n\\n      vec4 neighborPixelCoord =\\n          vec4(gl_FragCoord.x + float(i), gl_FragCoord.y + float(j),\\n               gl_FragCoord.z, gl_FragCoord.w);\\n\\n      vec3 neighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);\\n      vec4 value = getTextureValue(neighborPosIS);\\n\\n      // If any of my neighbours are not the same value as I\\n      // am, this means I am on the border of the segment.\\n      // We can break the loops\\n      if (any(notEqual(value, centerValue))) {\\n        pixelOnBorder = true;\\n        break;\\n      }\\n    }\\n\\n    if (pixelOnBorder == true) {\\n      break;\\n    }\\n  }\\n\\n  // If I am on the border, I am displayed at full opacity\\n  if (pixelOnBorder == true) {\\n    tColor.a = volume.outlineOpacity;\\n  }\\n\\n  return tColor;\\n}\\n\\nvec4 getColorForAdditivePreset(vec4 tValue, vec3 posVC, vec3 posIS) {\\n  // compute normals\\n  mat4 normalMat = computeMat4Normal(posIS, tValue);\\n  vec4 normalLights[2];\\n  normalLights[0] = normalMat[0];\\n  normalLights[1] = normalMat[1];\\n  #if vtkNumberOfLights > 0\\n    if (volume.computeNormalFromOpacity == 1) {\\n      for (int component = 0; component < 2; ++component) {\\n        vec3 scalarInterp[2];\\n        float height = volume.transferFunctionsSampleHeight[component];\\n        computeNormalForDensity(posIS, scalarInterp, component);\\n        normalLights[component] =\\n            computeDensityNormal(scalarInterp, height, 1.0, component);\\n      }\\n    }\\n  #endif\\n\\n  // compute opacities\\n  float opacities[2];\\n  opacities[0] = getOpacityFromTexture(\\n      tValue[0], 0, volume.transferFunctionsSampleHeight[0]);\\n  opacities[1] = getOpacityFromTexture(\\n      tValue[1], 1, volume.transferFunctionsSampleHeight[1]);\\n  #ifdef EnabledGradientOpacity\\n    for (int component = 0; component < 2; ++component) {\\n      opacities[component] *=\\n          computeGradientOpacityFactor(normalMat[component].a, component);\\n    }\\n  #endif\\n  float opacitySum = opacities[0] + opacities[1];\\n  if (opacitySum <= 0.0) {\\n    return vec4(0.0);\\n  }\\n\\n  // mix the colors and opacities\\n  vec3 colors[2];\\n  for (int component = 0; component < 2; ++component) {\\n    float sampleHeight = volume.transferFunctionsSampleHeight[component];\\n    vec3 color = getColorFromTexture(tValue[component], component, sampleHeight);\\n    color = applyAllLightning(color, opacities[component], posVC,\\n                              normalLights[component]);\\n    colors[component] = color;\\n  }\\n  vec3 mixedColor =\\n      (opacities[0] * colors[0] + opacities[1] * colors[1]) / opacitySum;\\n  return vec4(mixedColor, min(1.0, opacitySum));\\n}\\n\\nvec4 getColorForColorizePreset(vec4 tValue, vec3 posVC, vec3 posIS) {\\n  // compute normals\\n  mat4 normalMat = computeMat4Normal(posIS, tValue);\\n  vec4 normalLight = normalMat[0];\\n  #if vtkNumberOfLights > 0\\n    if (volume.computeNormalFromOpacity == 1) {\\n      vec3 scalarInterp[2];\\n      float height = volume.transferFunctionsSampleHeight[0];\\n      computeNormalForDensity(posIS, scalarInterp, 0);\\n      normalLight = computeDensityNormal(scalarInterp, height, 1.0, 0);\\n    }\\n  #endif\\n\\n  // compute opacities\\n  float opacity = getOpacityFromTexture(\\n      tValue[0], 0, volume.transferFunctionsSampleHeight[0]);\\n  #ifdef EnabledGradientOpacity\\n    opacity *= computeGradientOpacityFactor(normalMat[0].a, 0);\\n  #endif\\n\\n  // colorizing component\\n  vec3 colorizingColor = getColorFromTexture(\\n      tValue[0], 1, volume.transferFunctionsSampleHeight[1]);\\n  float colorizingOpacity = getOpacityFromTexture(\\n      tValue[1], 1, volume.transferFunctionsSampleHeight[1]);\\n\\n  // mix the colors and opacities\\n  vec3 color =\\n      getColorFromTexture(tValue[0], 0,\\n                          volume.transferFunctionsSampleHeight[0]) *\\n      mix(vec3(1.0), colorizingColor, colorizingOpacity);\\n  color = applyAllLightning(color, opacity, posVC, normalLight);\\n  return vec4(color, opacity);\\n}\\n\\nvec4 getColorForDefaultIndependentPreset(vec4 tValue, vec3 posIS) {\\n\\n  // compute the normal vectors as needed\\n  #if defined(EnabledGradientOpacity) || vtkNumberOfLights > 0\\n    mat4 normalMat = computeMat4Normal(posIS, tValue);\\n  #endif\\n\\n  // process color and opacity for each component\\n  // initial value of alpha is determined by wether the first component is\\n  // proportional or not\\n  #if defined(vtkComponent0Proportional)\\n    // when it is proportional, it starts at 1 (neutral for multiplications)\\n    float alpha = 1.0;\\n  #else\\n    // when it is not proportional, it starts at 0 (neutral for additions)\\n    float alpha = 0.0;\\n  #endif\\n\\n  vec3 mixedColor = vec3(0.0);\\n  #if vtkNumberOfComponents > 0\\n    {\\n      const int component = 0;\\n      vec3 color = getColorFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      float opacity = getOpacityFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      #if !defined(vtkComponent0Proportional)\\n        float alphaContribution = volume.independentComponentMix[component] * opacity;\\n        #ifdef EnabledGradientOpacity\\n          alphaContribution *= computeGradientOpacityFactor(normalMat[component].a, component);\\n        #endif\\n        alpha += alphaContribution;\\n        #if vtkNumberOfLights > 0\\n          color = applyLighting(color, normalMat[component]);\\n        #endif\\n      #else\\n        color *= opacity;\\n        alpha *= mix(opacity, 1.0,\\n                    (1.0 - volume.independentComponentMix[component]));\\n      #endif\\n      mixedColor += volume.independentComponentMix[component] * color;\\n    }\\n  #endif\\n  #if vtkNumberOfComponents > 1\\n    {\\n      const int component = 1;\\n      vec3 color = getColorFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      float opacity = getOpacityFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      #if !defined(vtkComponent1Proportional)\\n        float alphaContribution = volume.independentComponentMix[component] * opacity;\\n        #ifdef EnabledGradientOpacity\\n          alphaContribution *= computeGradientOpacityFactor(normalMat[component].a, component);\\n        #endif\\n        alpha += alphaContribution;\\n        #if vtkNumberOfLights > 0\\n          color = applyLighting(color, normalMat[component]);\\n        #endif\\n      #else\\n        color *= opacity;\\n        alpha *= mix(opacity, 1.0,\\n                    (1.0 - volume.independentComponentMix[component]));\\n      #endif\\n      mixedColor += volume.independentComponentMix[component] * color;\\n    }\\n  #endif\\n  #if vtkNumberOfComponents > 2\\n    {\\n      const int component = 2;\\n      vec3 color = getColorFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      float opacity = getOpacityFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      #if !defined(vtkComponent2Proportional)\\n        float alphaContribution = volume.independentComponentMix[component] * opacity;\\n        #ifdef EnabledGradientOpacity\\n          alphaContribution *= computeGradientOpacityFactor(normalMat[component].a, component);\\n        #endif\\n        alpha += alphaContribution;\\n        #if vtkNumberOfLights > 0\\n          color = applyLighting(color, normalMat[component]);\\n        #endif\\n      #else\\n        color *= opacity;\\n        alpha *= mix(opacity, 1.0,\\n                    (1.0 - volume.independentComponentMix[component]));\\n      #endif\\n      mixedColor += volume.independentComponentMix[component] * color;\\n    }\\n  #endif\\n  #if vtkNumberOfComponents > 3\\n    {\\n      const int component = 3;\\n      vec3 color = getColorFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      float opacity = getOpacityFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      #if !defined(vtkComponent3Proportional)\\n        float alphaContribution = volume.independentComponentMix[component] * opacity;\\n        #ifdef EnabledGradientOpacity\\n          alphaContribution *= computeGradientOpacityFactor(normalMat[component].a, component);\\n        #endif\\n        alpha += alphaContribution;\\n        #if vtkNumberOfLights > 0\\n          color = applyLighting(color, normalMat[component]);\\n        #endif\\n      #else\\n        color *= opacity;\\n        alpha *= mix(opacity, 1.0,\\n                    (1.0 - volume.independentComponentMix[component]));\\n      #endif\\n      mixedColor += volume.independentComponentMix[component] * color;\\n    }\\n  #endif\\n\\n  return vec4(mixedColor, alpha);\\n}\\n\\nvec4 getColorForDependentComponents(vec4 tValue, vec3 posVC, vec3 posIS) {\\n  #if defined(EnabledGradientOpacity) || vtkNumberOfLights > 0\\n    // use component 3 of the opacity texture as getTextureValue() sets alpha to\\n    // the opacity value\\n    vec3 scalarInterp[2];\\n    vec4 normal0 = computeNormalForDensity(posIS, scalarInterp, 3);\\n    float gradientOpacity = computeGradientOpacityFactor(normal0.a, 0);\\n  #endif\\n\\n  // get color and opacity\\n  #if vtkNumberOfComponents == 1\\n    vec3 tColor = getColorFromTexture(tValue.r, 0, 0.5);\\n    float alpha = getOpacityFromTexture(tValue.r, 0, 0.5);\\n  #endif\\n  #if vtkNumberOfComponents == 2\\n    vec3 tColor = vec3(tValue.r * volume.colorTextureScale[0] +\\n                  volume.colorTextureShift[0]);\\n    float alpha = getOpacityFromTexture(tValue.a, 1, 0.5);\\n  #endif\\n  #if vtkNumberOfComponents == 3\\n      vec3 tColor = tValue.rgb * volume.colorTextureScale.rgb +\\n              volume.colorTextureShift.rgb;\\n      float alpha = getOpacityFromTexture(tValue.a, 0, 0.5);\\n  #endif\\n  #if vtkNumberOfComponents == 4\\n      vec3 tColor = tValue.rgb * volume.colorTextureScale.rgb +\\n              volume.colorTextureShift.rgb;\\n      float alpha = getOpacityFromTexture(tValue.a, 3, 0.5);\\n  #endif\\n\\n  // Apply gradient opacity\\n  #if defined(EnabledGradientOpacity)\\n    alpha *= gradientOpacity;\\n  #endif\\n\\n  #if vtkNumberOfComponents == 1\\n    if (alpha < EPSILON) {\\n      return vec4(0.0);\\n    }\\n  #endif\\n\\n  // lighting\\n  #if vtkNumberOfLights > 0\\n    vec4 normalLight;\\n    if (volume.computeNormalFromOpacity == 1) {\\n      if (normal0[3] != 0.0) {\\n        normalLight =\\n            computeDensityNormal(scalarInterp, 0.5, gradientOpacity, 0);\\n        if (normalLight[3] == 0.0) {\\n          normalLight = normal0;\\n        }\\n      }\\n    } else {\\n      normalLight = normal0;\\n    }\\n    tColor = applyAllLightning(tColor, alpha, posVC, normalLight);\\n  #endif\\n\\n  return vec4(tColor, alpha);\\n}\\n\\nvec4 getColorForValue(vec4 tValue, vec3 posVC, vec3 posIS) {\\n  #ifdef EnableColorForValueFunctionId0\\n    return getColorForDependentComponents(tValue, posVC, posIS);\\n  #endif\\n\\n  #ifdef EnableColorForValueFunctionId1\\n    return getColorForAdditivePreset(tValue, posVC, posIS);\\n  #endif\\n\\n  #ifdef EnableColorForValueFunctionId2\\n    return getColorForColorizePreset(tValue, posVC, posIS);\\n  #endif\\n\\n  #ifdef EnableColorForValueFunctionId3\\n    /*\\n      * Mix the color information from all the independent components to get a\\n      * single rgba output. See other shader functions like\\n      * `getColorForAdditivePreset` to learn how to create a custom color mix.\\n      * The custom color mix should return a value, but if it doesn't, it will\\n      * fallback on the default shading\\n      */\\n    //VTK::CustomColorMix\\n  #endif\\n\\n  #if defined(EnableColorForValueFunctionId4) || defined(EnableColorForValueFunctionId3)\\n    return getColorForDefaultIndependentPreset(tValue, posIS);\\n  #endif\\n\\n  #ifdef EnableColorForValueFunctionId5\\n    return getColorForLabelOutline();\\n  #endif\\n}\\n\\nbool valueWithinScalarRange(vec4 val) {\\n  #if vtkNumberOfComponents > 1 && !defined(EnabledIndependentComponents)\\n    return false;\\n  #endif\\n  vec4 rangeMin = volume.ipScalarRangeMin;\\n  vec4 rangeMax = volume.ipScalarRangeMax;\\n  for (int component = 0; component < vtkNumberOfComponents; ++component) {\\n    if (val[component] < rangeMin[component] ||\\n        rangeMax[component] < val[component]) {\\n      return false;\\n    }\\n  }\\n  return true;\\n}\\n\\n#if vtkBlendMode == LABELMAP_EDGE_PROJECTION_BLEND\\n  bool checkOnEdgeForNeighbor(int xFragmentOffset, int yFragmentOffset,\\n                              int segmentIndex, vec3 stepIS) {\\n    vec3 volumeDimensions = vec3(volume.dimensions);\\n    vec4 neighborPixelCoord = vec4(gl_FragCoord.x + float(xFragmentOffset),\\n                                  gl_FragCoord.y + float(yFragmentOffset),\\n                                  gl_FragCoord.z, gl_FragCoord.w);\\n    vec3 originalNeighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);\\n\\n    vec3 neighborPosIS = originalNeighborPosIS;\\n    for (int k = 0; k < vtkMaximumNumberOfSamples / 2; ++k) {\\n      ivec3 texCoord = ivec3(neighborPosIS * volumeDimensions);\\n      vec4 texValue = rawFetchTexture(texCoord);\\n      if (int(texValue.g) == segmentIndex) {\\n        // not on edge\\n        return false;\\n      }\\n      neighborPosIS += stepIS;\\n    }\\n\\n    neighborPosIS = originalNeighborPosIS;\\n    for (int k = 0; k < vtkMaximumNumberOfSamples / 2; ++k) {\\n      ivec3 texCoord = ivec3(neighborPosIS * volumeDimensions);\\n      vec4 texValue = rawFetchTexture(texCoord);\\n      if (int(texValue.g) == segmentIndex) {\\n        // not on edge\\n        return false;\\n      }\\n      neighborPosIS -= stepIS;\\n    }\\n\\n    // onedge\\n    float sampleHeight = volume.transferFunctionsSampleHeight[1];\\n    vec3 tColorSegment =\\n        getColorFromTexture(float(segmentIndex), 1, sampleHeight);\\n    float pwfValueSegment =\\n        getOpacityFromTexture(float(segmentIndex), 1, sampleHeight);\\n    gl_FragData[0] = vec4(tColorSegment, pwfValueSegment);\\n    return true;\\n  }\\n#endif\\n\\nvec4 getColorAtPos(vec3 posVC) {\\n  vec3 posIS = posVCtoIS(posVC);\\n  vec4 texValue = getTextureValue(posIS);\\n  return getColorForValue(texValue, posVC, posIS);\\n}\\n\\n//=======================================================================\\n// Apply the specified blend mode operation along the ray's path.\\n//\\nvoid applyBlend(vec3 rayOriginVC, vec3 rayDirVC, float minDistance,\\n                float maxDistance) {\\n  // start slightly inside and apply some jitter\\n  vec3 stepVC = rayDirVC * sampleDistance;\\n  float raySteps = (maxDistance - minDistance) / sampleDistance;\\n\\n  // Avoid 0.0 jitter\\n  float jitter = 0.01 + 0.99 * fragmentSeed;\\n\\n  #if vtkBlendMode == COMPOSITE_BLEND\\n    // now map through opacity and color\\n    vec3 firstPosVC = rayOriginVC + minDistance * rayDirVC;\\n    vec4 firstColor = getColorAtPos(firstPosVC);\\n\\n    // handle very thin volumes\\n    if (raySteps <= 1.0) {\\n      firstColor.a = 1.0 - pow(1.0 - firstColor.a, raySteps);\\n      gl_FragData[0] = firstColor;\\n      return;\\n    }\\n\\n    // first color only counts for `jitter` factor of the step\\n    firstColor.a = 1.0 - pow(1.0 - firstColor.a, jitter);\\n    vec4 color = vec4(firstColor.rgb * firstColor.a, firstColor.a);\\n    vec3 posVC = firstPosVC + jitter * stepVC;\\n    float stepsTraveled = jitter;\\n\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      // If we have reached the last step, break\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n      vec4 tColor = getColorAtPos(posVC);\\n\\n      color = color + vec4(tColor.rgb * tColor.a, tColor.a) * (1.0 - color.a);\\n      stepsTraveled++;\\n      posVC += stepVC;\\n      if (color.a > 0.99) {\\n        color.a = 1.0;\\n        break;\\n      }\\n    }\\n\\n    if (color.a < 0.99 && (raySteps - stepsTraveled) > 0.0) {\\n      vec3 endPosVC = rayOriginVC + maxDistance * rayDirVC;\\n      vec4 tColor = getColorAtPos(endPosVC);\\n      tColor.a = 1.0 - pow(1.0 - tColor.a, raySteps - stepsTraveled);\\n\\n      float mix = (1.0 - color.a);\\n      color = color + vec4(tColor.rgb * tColor.a, tColor.a) * mix;\\n    }\\n\\n    gl_FragData[0] = vec4(color.rgb / color.a, color.a);\\n  #endif\\n\\n  #if vtkBlendMode == MAXIMUM_INTENSITY_BLEND ||                                 \\\\\\n      vtkBlendMode == MINIMUM_INTENSITY_BLEND\\n    // Find maximum/minimum intensity along the ray.\\n\\n    // Define the operation we will use (min or max)\\n    #if vtkBlendMode == MAXIMUM_INTENSITY_BLEND\\n      #define OP max\\n    #else\\n      #define OP min\\n    #endif\\n\\n    vec3 posVC = rayOriginVC + minDistance * rayDirVC;\\n    float stepsTraveled = 0.0;\\n\\n    // Find a value to initialize the selected variables\\n    vec4 selectedValue;\\n    vec3 selectedPosVC;\\n    vec3 selectedPosIS;\\n    {\\n      vec3 posIS = posVCtoIS(posVC);\\n      selectedValue = getTextureValue(posIS);\\n      selectedPosVC = posVC;\\n      selectedPosIS = posIS;\\n    }\\n\\n    // If the clipping range is shorter than the sample distance\\n    // we can skip the sampling loop along the ray.\\n    if (raySteps <= 1.0) {\\n      gl_FragData[0] = getColorForValue(selectedValue, selectedPosVC, selectedPosIS);\\n      return;\\n    }\\n\\n    posVC += jitter * stepVC;\\n    stepsTraveled += jitter;\\n\\n    // Sample along the ray until vtkMaximumNumberOfSamples,\\n    // ending slightly inside the total distance\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      // If we have reached the last step, break\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n\\n      // Get selected values\\n      vec3 posIS = posVCtoIS(posVC);\\n      vec4 previousSelectedValue = selectedValue;\\n      vec4 currentValue = getTextureValue(posIS);\\n      selectedValue = OP(selectedValue, currentValue);\\n      if (previousSelectedValue != selectedValue) {\\n        selectedPosVC = posVC;\\n        selectedPosIS = posIS;\\n      }\\n\\n      // Otherwise, continue along the ray\\n      stepsTraveled++;\\n      posVC += stepVC;\\n    }\\n\\n    // Perform the last step along the ray using the\\n    // residual distance\\n    posVC = rayOriginVC + maxDistance * rayDirVC;\\n    {\\n      vec3 posIS = posVCtoIS(posVC);\\n      vec4 previousSelectedValue = selectedValue;\\n      vec4 currentValue = getTextureValue(posIS);\\n      selectedValue = OP(selectedValue, currentValue);\\n      if (previousSelectedValue != selectedValue) {\\n        selectedPosVC = posVC;\\n        selectedPosIS = posIS;\\n      }\\n    }\\n\\n    gl_FragData[0] = getColorForValue(selectedValue, selectedPosVC, selectedPosIS);\\n  #endif\\n\\n  #if vtkBlendMode == ADDITIVE_INTENSITY_BLEND ||                                \\\\\\n      vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n    vec4 sum = vec4(0.);\\n    #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n      float totalWeight = 0.0;\\n    #endif\\n    vec3 posVC = rayOriginVC + minDistance * rayDirVC;\\n    float stepsTraveled = 0.0;\\n\\n    vec3 posIS = posVCtoIS(posVC);\\n    vec4 value = getTextureValue(posIS);\\n\\n    if (raySteps <= 1.0) {\\n      gl_FragData[0] = getColorForValue(value * raySteps, posVC, posIS);\\n      return;\\n    }\\n\\n    if (valueWithinScalarRange(value)) {\\n      sum += value * jitter;\\n      #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n        totalWeight += jitter;\\n      #endif\\n    }\\n    posVC += jitter * stepVC;\\n    stepsTraveled += jitter;\\n\\n    // Sample along the ray until vtkMaximumNumberOfSamples,\\n    // ending slightly inside the total distance\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      // If we have reached the last step, break\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n\\n      posIS = posVCtoIS(posVC);\\n      value = getTextureValue(posIS);\\n      // One can control the scalar range by setting the AverageIPScalarRange to\\n      // disregard scalar values, not in the range of interest, from the average\\n      // computation. Notes:\\n      // - We are comparing all values in the texture to see if any of them\\n      //   are outside of the scalar range. In the future we might want to allow\\n      //   scalar ranges for each component.\\n      if (valueWithinScalarRange(value)) {\\n        sum += value;\\n        #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n          totalWeight++;\\n        #endif\\n      }\\n\\n      stepsTraveled++;\\n      posVC += stepVC;\\n    }\\n\\n    // Perform the last step along the ray using the\\n    // residual distance\\n    posVC = rayOriginVC + maxDistance * rayDirVC;\\n    posIS = posVCtoIS(posVC);\\n    value = getTextureValue(posIS);\\n    if (valueWithinScalarRange(value)) {\\n      sum += value;\\n      #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n        totalWeight += raySteps - stepsTraveled;\\n      #endif\\n    }\\n\\n    #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n      sum /= vec4(totalWeight, totalWeight, totalWeight, 1.0);\\n    #endif\\n\\n    gl_FragData[0] = getColorForValue(sum, posVC, posIS);\\n  #endif\\n\\n  #if vtkBlendMode == RADON_TRANSFORM_BLEND\\n    float normalizedRayIntensity = 1.0;\\n    vec3 posVC = rayOriginVC + minDistance * rayDirVC;\\n    float stepsTraveled = 0.0;\\n\\n    // handle very thin volumes\\n    if (raySteps <= 1.0) {\\n      vec3 posIS = posVCtoIS(posVC);\\n      vec4 tValue = getTextureValue(posIS);\\n      normalizedRayIntensity -= raySteps * sampleDistance *\\n                                getOpacityFromTexture(tValue.r, 0, 0.5);\\n      gl_FragData[0] =\\n          vec4(getColorFromTexture(normalizedRayIntensity, 0, 0.5), 1.0);\\n      return;\\n    }\\n\\n    posVC += jitter * stepVC;\\n    stepsTraveled += jitter;\\n\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n\\n      vec3 posIS = posVCtoIS(posVC);\\n      vec4 value = getTextureValue(posIS);\\n      // Convert scalar value to normalizedRayIntensity coefficient and\\n      // accumulate normalizedRayIntensity\\n      normalizedRayIntensity -=\\n          sampleDistance * getOpacityFromTexture(value.r, 0, 0.5);\\n\\n      posVC += stepVC;\\n      stepsTraveled++;\\n    }\\n\\n    // map normalizedRayIntensity to color\\n    gl_FragData[0] =\\n        vec4(getColorFromTexture(normalizedRayIntensity, 0, 0.5), 1.0);\\n  #endif\\n\\n  #if vtkBlendMode == LABELMAP_EDGE_PROJECTION_BLEND\\n    // Only works with a single volume\\n    vec3 posVC = rayOriginVC + minDistance * rayDirVC;\\n    float stepsTraveled = 0.0;\\n    vec3 posIS = posVCtoIS(posVC);\\n    vec4 tValue = getTextureValue(posIS);\\n    if (raySteps <= 1.0) {\\n      gl_FragData[0] = getColorForValue(tValue, posVC, posIS);\\n      return;\\n    }\\n\\n    vec3 stepIS = vecVCToIS(stepVC);\\n    vec4 value = tValue;\\n    posIS += jitter * stepIS;\\n    stepsTraveled += jitter;\\n    vec3 maxPosIS = posIS; // Store the position of the max value\\n    int segmentIndex = int(value.g);\\n    bool originalPosHasSeenNonZero = false;\\n\\n    if (segmentIndex != 0) {\\n      // Tried using the segment index in an boolean array but reading\\n      // from the array by dynamic indexing was horrondously slow\\n      // so use bit masking instead and assign 1 to the bit corresponding to the\\n      // segment index and later check if the bit is set via bit operations\\n      setLabelOutlineBit(segmentIndex);\\n    }\\n\\n    // Sample along the ray until vtkMaximumNumberOfSamples,\\n    // ending slightly inside the total distance\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      // If we have reached the last step, break\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n\\n      // compute the scalar\\n      tValue = getTextureValue(posIS);\\n      segmentIndex = int(tValue.g);\\n\\n      if (segmentIndex != 0) {\\n        originalPosHasSeenNonZero = true;\\n        setLabelOutlineBit(segmentIndex);\\n      }\\n\\n      if (tValue.r > value.r) {\\n        value = tValue;   // Update the max value\\n        maxPosIS = posIS; // Update the position where max occurred\\n      }\\n\\n      // Otherwise, continue along the ray\\n      stepsTraveled++;\\n      posIS += stepIS;\\n    }\\n\\n    // Perform the last step along the ray using the\\n    // residual distance\\n    posIS = posVCtoIS(rayOriginVC + maxDistance * rayDirVC);\\n    tValue = getTextureValue(posIS);\\n\\n    if (tValue.r > value.r) {\\n      value = tValue;   // Update the max value\\n      maxPosIS = posIS; // Update the position where max occurred\\n    }\\n\\n    // If we have not seen any non-zero segments, we can return early\\n    // and grab color from the actual center value first component (image)\\n    if (!originalPosHasSeenNonZero) {\\n      vec3 maxPosVC = posIStoVC(maxPosIS);\\n      gl_FragData[0] = getColorForValue(value, maxPosVC, maxPosIS);\\n      return;\\n    }\\n\\n    vec3 neighborRayStepsIS = stepIS;\\n    float neighborRaySteps = raySteps;\\n    bool shouldLookInAllNeighbors = false;\\n\\n    vec3 volumeSpacings = volume.spacing;\\n    float minVoxelSpacing =\\n        min(volumeSpacings[0], min(volumeSpacings[1], volumeSpacings[2]));\\n    vec4 base =\\n        vec4(gl_FragCoord.x, gl_FragCoord.y, gl_FragCoord.z, gl_FragCoord.w);\\n\\n    vec4 baseXPlus = vec4(gl_FragCoord.x + 1.0, gl_FragCoord.y, gl_FragCoord.z,\\n                          gl_FragCoord.w);\\n    vec4 baseYPlus = vec4(gl_FragCoord.x, gl_FragCoord.y + 1.0, gl_FragCoord.z,\\n                          gl_FragCoord.w);\\n\\n    vec3 baseWorld = fragCoordToWorld(base);\\n    vec3 baseXPlusWorld = fragCoordToWorld(baseXPlus);\\n    vec3 baseYPlusWorld = fragCoordToWorld(baseYPlus);\\n\\n    float XPlusDiff = length(baseXPlusWorld - baseWorld);\\n    float YPlusDiff = length(baseYPlusWorld - baseWorld);\\n\\n    float minFragSpacingWorld = min(XPlusDiff, YPlusDiff);\\n\\n    for (int s = 1; s < MAX_SEGMENT_INDEX; s++) {\\n      // bail out quickly if the segment index has not\\n      // been seen by the center segment\\n      if (!isLabelOutlineBitSet(s)) {\\n        continue;\\n      }\\n\\n      // Use texture sampling for outlineThickness so that we can have\\n      // per segment thickness\\n      float textureCoordinate = float(s - 1) / 1024.0;\\n      float textureValue =\\n          texture2D(labelOutlineThicknessTexture, vec2(textureCoordinate, 0.5)).r;\\n\\n      int actualThickness = int(textureValue * 255.0);\\n\\n      // check the extreme points in the neighborhood since there is a better\\n      // chance of finding the edge there, so that we can bail out\\n      // faster if we find the edge\\n      bool onEdge = checkOnEdgeForNeighbor(-actualThickness, -actualThickness, s,\\n                                          stepIS) ||\\n                    checkOnEdgeForNeighbor(actualThickness, actualThickness, s,\\n                                          stepIS) ||\\n                    checkOnEdgeForNeighbor(actualThickness, -actualThickness, s,\\n                                          stepIS) ||\\n                    checkOnEdgeForNeighbor(-actualThickness, +actualThickness, s,\\n                                          stepIS);\\n\\n      if (onEdge) {\\n        return;\\n      }\\n\\n      // since the next step is computationally expensive, we need to perform\\n      // some optimizations to avoid it if possible. One of the optimizations\\n      // is to check the whether the minimum of the voxel spacing is greater than\\n      // the 2 * the thickness of the outline segment. If that is the case\\n      // then we can safely skip the next step since we can be sure that the\\n      // the previous 4 checks on the extreme points would caught the entirety\\n      // of the all the fragments inside. i.e., this happens when we zoom out,\\n      if (minVoxelSpacing >\\n          (2.0 * float(actualThickness) - 1.0) * minFragSpacingWorld) {\\n        continue;\\n      }\\n\\n      // Loop through the rest, skipping the processed extremes and the center\\n      for (int i = -actualThickness; i <= actualThickness; i++) {\\n        for (int j = -actualThickness; j <= actualThickness; j++) {\\n          if (i == 0 && j == 0)\\n            continue; // Skip the center\\n          if (abs(i) == actualThickness && abs(j) == actualThickness)\\n            continue; // Skip corners\\n          if (checkOnEdgeForNeighbor(i, j, s, stepIS)) {\\n            return;\\n          }\\n        }\\n      }\\n    }\\n\\n    float sampleHeight = volume.transferFunctionsSampleHeight[0];\\n    vec3 tColor0 = getColorFromTexture(value.r, 0, sampleHeight);\\n    float pwfValue0 = getOpacityFromTexture(value.r, 0, sampleHeight);\\n    gl_FragData[0] = vec4(tColor0, pwfValue0);\\n  #endif\\n}\\n\\n//=======================================================================\\n// given a\\n// - ray direction (rayDir)\\n// - starting point (vertexVCVSOutput)\\n// - bounding planes of the volume\\n// - optionally depth buffer values\\n// - far clipping plane\\n// compute the start/end distances of the ray we need to cast\\nvec2 computeRayDistances(vec3 rayOriginVC, vec3 rayDirVC) {\\n  vec2 dists = rayIntersectVolumeDistances(rayOriginVC, rayDirVC);\\n\\n  //VTK::ClipPlane::Impl\\n\\n  // do not go behind front clipping plane\\n  dists.x = max(0.0, dists.x);\\n\\n  // do not go PAST far clipping plane\\n  float farDist = -camThick / rayDirVC.z;\\n  dists.y = min(farDist, dists.y);\\n\\n  // Do not go past the zbuffer value if set\\n  // This is used for intermixing opaque geometry\\n  //VTK::ZBuffer::Impl\\n\\n  return dists;\\n}\\n\\nfloat getFragmentSeed() {\\n  // This first noise has a diagonal pattern\\n  float firstNoise =\\n      fract(sin(dot(gl_FragCoord.xy, vec2(12.9898, 78.233))) * 43758.5453);\\n  // This second noise is made out of blocks of CPU generated noise\\n  float secondNoise = texture2D(jtexture, gl_FragCoord.xy / 32.0).r;\\n  // Combine the two sources of noise in a way that the distribution is uniform\\n  // in [0,1[\\n  float noiseSum = firstNoise + secondNoise;\\n  return noiseSum < 1.0 ? noiseSum : noiseSum - 1.0;\\n}\\n\\nvoid main() {\\n  fragmentSeed = getFragmentSeed();\\n\\n  if (cameraParallel == 1) {\\n    // Camera is parallel, so the rayDir is just the direction of the camera.\\n    rayDirVC = vec3(0.0, 0.0, -1.0);\\n  } else {\\n    // camera is at 0,0,0 so rayDir for perspective is just the vc coord\\n    rayDirVC = normalize(vertexVCVSOutput);\\n  }\\n\\n  vec3 rayOriginVC = vertexVCVSOutput;\\n  vec2 rayStartEndDistancesVC = computeRayDistances(rayOriginVC, rayDirVC);\\n  if (rayStartEndDistancesVC[1] <= rayStartEndDistancesVC[0] ||\\n      rayStartEndDistancesVC[1] <= 0.0) {\\n    // Volume not hit or behind the ray\\n    discard;\\n  }\\n\\n  // Perform the blending operation along the ray\\n  applyBlend(rayOriginVC, rayDirVC, rayStartEndDistancesVC[0], rayStartEndDistancesVC[1]);\\n}\\n&quot;,e.Geometry=&quot;&quot;},e.replaceShaderValues=(e,n,r)=>{let o=e.Fragment;o=td.substitute(o,&quot;//VTK::EnabledColorFunctions&quot;,`#define EnableColorForValueFunctionId${t.previousState.colorForValueFunctionId}`).result;const a=[];t.previousState.surfaceLightingEnabled&&a.push(&quot;Surface&quot;),t.previousState.volumeLightingEnabled&&a.push(&quot;Volume&quot;),o=td.substitute(o,&quot;//VTK::EnabledLightings&quot;,a.map((e=>`#define Enable${e}Lighting`))).result,t.previousState.multiTexturePerVolumeEnabled&&(o=td.substitute(o,&quot;//VTK::EnabledMultiTexturePerVolume&quot;,&quot;#define EnabledMultiTexturePerVolume&quot;).result),t.previousState.useIndependentComponents&&(o=td.substitute(o,&quot;//VTK::EnabledIndependentComponents&quot;,&quot;#define EnabledIndependentComponents&quot;).result),t.previousState.gradientOpacityEnabled&&(o=td.substitute(o,&quot;//VTK::EnabledGradientOpacity&quot;,&quot;#define EnabledGradientOpacity&quot;).result),o=td.substitute(o,&quot;//VTK::vtkProportionalComponents&quot;,t.previousState.proportionalComponents.map((e=>`#define vtkComponent${e}Proportional`)).join(&quot;\\n&quot;)).result,o=td.substitute(o,&quot;//VTK::vtkForceNearestComponents&quot;,t.previousState.forceNearestComponents.map((e=>`#define vtkComponent${e}ForceNearest`)).join(&quot;\\n&quot;)).result,t.previousState.hasZBufferTexture&&(o=td.substitute(o,&quot;//VTK::ZBuffer::Dec&quot;,[&quot;uniform sampler2D zBufferTexture;&quot;,&quot;uniform float vpZWidth;&quot;,&quot;uniform float vpZHeight;&quot;]).result,o=td.substitute(o,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;vec4 depthVec = texture2D(zBufferTexture, vec2(gl_FragCoord.x / vpZWidth, gl_FragCoord.y/vpZHeight));&quot;,&quot;float zdepth = (depthVec.r*256.0 + depthVec.g)/257.0;&quot;,&quot;zdepth = zdepth * 2.0 - 1.0;&quot;,&quot;if (cameraParallel == 0) {&quot;,&quot;zdepth = -2.0 * camFar * camNear / (zdepth*(camFar-camNear)-(camFar+camNear)) - camNear;}&quot;,&quot;else {&quot;,&quot;zdepth = (zdepth + 1.0) * 0.5 * (camFar - camNear);}\\n&quot;,&quot;zdepth = -zdepth/rayDirVC.z;&quot;,&quot;dists.y = min(zdepth,dists.y);&quot;]).result),o=td.substitute(o,&quot;//VTK::BlendMode&quot;,`${t.previousState.blendMode}`).result,o=td.substitute(o,&quot;//VTK::NumberOfLights&quot;,`${t.previousState.numberOfLights}`).result,o=td.substitute(o,&quot;//VTK::MaxLaoKernelSize&quot;,`${t.previousState.maxLaoKernelSize}`).result,o=td.substitute(o,&quot;//VTK::NumberOfComponents&quot;,`${t.previousState.numberOfComponents}`).result,o=td.substitute(o,&quot;//VTK::MaximumNumberOfSamples&quot;,`${t.previousState.maximumNumberOfSamples}`).result,e.Fragment=o;const i=t.previousState.numberOfClippingPlanes;i>0&&(o=td.substitute(o,&quot;//VTK::ClipPlane::Dec&quot;,[&quot;uniform vec3 vClipPlaneNormals[6];&quot;,&quot;uniform float vClipPlaneDistances[6];&quot;,&quot;uniform vec3 vClipPlaneOrigins[6];&quot;,&quot;uniform int clip_numPlanes;&quot;,&quot;//VTK::ClipPlane::Dec&quot;,&quot;#define vtkClippingPlanesOn&quot;],!1).result,o=td.substitute(o,&quot;//VTK::ClipPlane::Impl&quot;,[`for(int i = 0; i < ${i}; i++) {`,&quot;  float rayDirRatio = dot(rayDirVC, vClipPlaneNormals[i]);&quot;,&quot;  float equationResult = dot(vertexVCVSOutput, vClipPlaneNormals[i]) + vClipPlaneDistances[i];&quot;,&quot;  if (rayDirRatio == 0.0)&quot;,&quot;  {&quot;,&quot;    if (equationResult < 0.0) dists.x = dists.y;&quot;,&quot;    continue;&quot;,&quot;  }&quot;,&quot;  float result = -1.0 * equationResult / rayDirRatio;&quot;,&quot;  if (rayDirRatio < 0.0) dists.y = min(dists.y, result);&quot;,&quot;  else dists.x = max(dists.x, result);&quot;,&quot;}&quot;,&quot;//VTK::ClipPlane::Impl&quot;],!1).result),e.Fragment=o},e.getNeedToRebuildShaders=(r,o,a)=>{const i=!!t.zBufferTexture,s=t.currentValidInputs.length,l=t.numberOfLights,c=t.numberOfComponents,u=t.useIndependentComponents,d=a.getProperties(),p=t.currentValidInputs[0],f=d[p.inputIndex],g=s>1,m=p.imageData.getBounds(),h=Gi.getDiagonalLength(m),v=Math.ceil(h/e.getCurrentSampleDistance(o));v>t.renderable.getMaximumSamplesPerRay()&&ng(`The number of steps required ${v} is larger than the specified maximum number of steps ${t.renderable.getMaximumSamplesPerRay()}.\\nPlease either change the volumeMapper sampleDistance or its maximum number of samples.`);const T=u?c:1;let y=!1;for(let e=0;e<T;++e)if(f.getUseGradientOpacity(e)){y=!0;break}let b=0;const x=f.getLAOKernelSize();x>b&&f.getLocalAmbientOcclusion()&&f.getAmbient()>0&&(b=x);const C=t.renderable.getClippingPlanes().length,S=t.renderable.getViewSpecificProperties().OpenGL?.ShaderReplacements,A=t.currentRenderPass?.getShaderReplacement(),I=t.renderable.getBlendMode(),w=(()=>{if(I!==eg.LABELMAP_EDGE_PROJECTION_BLEND&&n(f))return 5;if(u)switch(f.getColorMixPreset()){case Qf.ADDITIVE:return 1;case Qf.COLORIZE:return 2;case Qf.CUSTOM:return 3;default:return 4}return 0})(),O=f.getVolumetricScatteringBlending()<1,P=f.getVolumetricScatteringBlending()>0;let R=!1;for(let e=0;e<c;++e)if(f.getForceNearestInterpolation(e)){R=!0;break}const M=[],E=[];for(let e=0;e<c;e++)f.getOpacityMode(e)===Zf.PROPORTIONAL&&M.push(e),f.getForceNearestInterpolation(e)&&E.push(e);const V={numberOfComponents:c,useIndependentComponents:u,proportionalComponents:M,forceNearestComponents:E,blendMode:I,numberOfLights:l,numberOfValidInputs:s,maximumNumberOfSamples:v,hasZBufferTexture:i,maxLaoKernelSize:b,numberOfClippingPlanes:C,mapperShaderReplacements:S,renderPassShaderReplacements:A,colorForValueFunctionId:w,surfaceLightingEnabled:O,volumeLightingEnabled:P,forceNearestInterpolationEnabled:R,multiTexturePerVolumeEnabled:g,gradientOpacityEnabled:y};return!(0!==r.getProgram()?.getHandle()&&t.previousState&&ke(t.previousState,V)||(t.previousState=V,0))},e.updateShaders=(n,r,o)=>{if(e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};e.buildShaders(a,r,o);const i=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==n.getProgram()&&(n.setProgram(i),n.getVAO().releaseGraphicsResources()),n.getShaderSourceTime().modified()}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(n.getProgram());n.getVAO().bind(),e.setMapperShaderParameters(n,r,o),e.setCameraShaderParameters(n,r,o),e.setPropertyShaderParameters(n,r,o),e.getClippingPlaneShaderParameters(n,r,o)},e.setMapperShaderParameters=(n,r,o)=>{const a=n.getProgram();n.getCABO().getElementCount()&&(t.VBOBuildTime.getMTime()>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())&&(a.isAttributeUsed(&quot;vertexDC&quot;)&&(n.getVAO().addAttributeArray(a,n.getCABO(),&quot;vertexDC&quot;,n.getCABO().getVertexOffset(),n.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||rg(&quot;Error setting vertexDC in shader VAO.&quot;)),n.getAttributeUpdateTime().modified());const i=e.getCurrentSampleDistance(r);a.setUniformf(&quot;sampleDistance&quot;,i);const s=i*t.renderable.getVolumeShadowSamplingDistFactor();a.setUniformf(&quot;volumeShadowSampleDistance&quot;,s),t.scalarTextures.forEach(((e,t)=>{a.setUniformi(`volumeTexture[${t}]`,e.getTextureUnit())}));const l=o.getProperties()[t.currentValidInputs[0].inputIndex].getIpScalarRange(),c=new Float32Array(4),u=new Float32Array(4),d=(e,t,n)=>{t?.dataComputedScale?.length&&(c[e]=l[0]*t.dataComputedScale[n]+t.dataComputedOffset[n],u[e]=l[1]*t.dataComputedScale[n]+t.dataComputedOffset[n],c[e]=(c[e]-t.offset[n])/t.scale[n],u[e]=(u[e]-t.offset[n])/t.scale[n])};if(t.previousState.multiTexturePerVolumeEnabled)t.scalarTextures.forEach(((e,t)=>{const n=e.getVolumeInfo();d(t,n,0)}));else{const e=t.scalarTextures[0].getVolumeInfo();for(let t=0;t<4;++t)d(t,e,t)}const p=&quot;volume&quot;;if(a.setUniform4f(`${p}.ipScalarRangeMin`,c[0],c[1],c[2],c[3]),a.setUniform4f(`${p}.ipScalarRangeMax`,u[0],u[1],u[2],u[3]),null!==t.zBufferTexture){a.setUniformi(&quot;zBufferTexture&quot;,t.zBufferTexture.getTextureUnit());const e=t._useSmallViewport?[t._smallViewportWidth,t._smallViewportHeight]:t._openGLRenderWindow.getFramebufferSize();a.setUniformf(&quot;vpZWidth&quot;,e[0]),a.setUniformf(&quot;vpZHeight&quot;,e[1])}},e.setCameraShaderParameters=(r,o,a)=>{const{idxToView:i,vecISToVCMatrix:s,modelToView:l,projectionToView:c,projectionToWorld:u}=og,d=t.openGLCamera.getKeyMatrices(o),p=t.openGLVolume.getKeyMatrices();b(l,d.wcvc,p.mcwc);const f=r.getProgram(),g=t.openGLCamera.getRenderable(),m=g.getParallelProjection(),h=g.getClippingRange();f.setUniformf(&quot;camThick&quot;,h[1]-h[0]),f.setUniformf(&quot;camNear&quot;,h[0]),f.setUniformf(&quot;camFar&quot;,h[1]),f.setUniformi(&quot;cameraParallel&quot;,m);const T=t.currentValidInputs[0],y=T.imageData.getBounds(),x=Gi.getCorners(y,[]).map((e=>(In(e,e,l),m||bn(e,e,-h[0]/(e[2]*gn(e))),In(e,e,d.vcpc),e))),C=Gi.addPoints([...Gi.INIT_BOUNDS],x);f.setUniformf(&quot;dcxmin&quot;,C[0]),f.setUniformf(&quot;dcxmax&quot;,C[1]),f.setUniformf(&quot;dcymin&quot;,C[2]),f.setUniformf(&quot;dcymax&quot;,C[3]);const S=e.getRenderTargetSize();f.setUniformf(&quot;vpWidth&quot;,S[0]),f.setUniformf(&quot;vpHeight&quot;,S[1]);const A=e.getRenderTargetOffset();f.setUniformf(&quot;vpOffsetX&quot;,A[0]/S[0]),f.setUniformf(&quot;vpOffsetY&quot;,A[1]/S[1]),v(c,d.vcpc),f.setUniformMatrix(&quot;PCVCMatrix&quot;,c),f.setUniformi(&quot;twoSidedLighting&quot;,o.getTwoSidedLighting());const I=new Array(2*t.previousState.maxLaoKernelSize);for(let e=0;e<t.previousState.maxLaoKernelSize;e++)I[2*e]=Math.random(),I[2*e+1]=Math.random();if(f.setUniform2fv(&quot;kernelSample&quot;,I),t.numberOfLights>0){let e=0;o.getLights().forEach((t=>{if(t.getSwitch()>0){const n=`lights[${e}]`,r=bn([],t.getColor(),t.getIntensity());f.setUniform3fv(`${n}.color`,r);const o=t.getTransformedPosition();In(o,o,l),f.setUniform3fv(`${n}.positionVC`,o);const a=[...t.getDirection()];wn(a,a,d.normalMatrix),Cn(a,a),f.setUniform3fv(`${n}.directionVC`,a);const i=[-.5*a[0],-.5*a[1],-.5*(a[2]-1)];f.setUniform3fv(`${n}.halfAngleVC`,i);const s=t.getAttenuationValues();f.setUniform3fv(`${n}.attenuation`,s);const c=t.getExponent();f.setUniformf(`${n}.exponent`,c);const u=t.getConeAngle();f.setUniformf(`${n}.coneAngle`,u);const p=t.getPositional();f.setUniformi(`${n}.isPositional`,p),e++}}))}const w=&quot;volume&quot;,O=a.getProperties()[T.inputIndex],P=T.imageData,R=P.getSpatialExtent(),M=P.getSpacing(),E=P.getDimensions(),V=P.getIndexToWorld(),D=P.getWorldToIndex(),L=P.getDirectionByReference();b(i,l,V),f.setUniform3fv(`${w}.spacing`,M);const B=xn([],M);f.setUniform3fv(`${w}.inverseSpacing`,B),f.setUniform3iv(`${w}.dimensions`,E),f.setUniform3fv(`${w}.inverseDimensions`,xn([],E)),f.setUniformMatrix(`${w}.worldToIndex`,D),s.fill(0);const N=yn(new Float64Array(3),E,M);s[0]=N[0],s[4]=N[1],s[8]=N[2],Te(s,L,s),Te(s,p.normalMatrix,s),Te(s,d.normalMatrix,s),f.setUniformMatrix3x3(`${w}.vecISToVCMatrix`,s),f.setUniformMatrix3x3(`${w}.vecVCToISMatrix`,me(new Float32Array(9),s));const F=mn(R[0],R[2],R[4]),_=In(new Float64Array(3),F,i);f.setUniform3fv(`${w}.originVC`,_);const k=gn(N);if(f.setUniformf(`${w}.diagonalLength`,k),n(O)){const e=g.getDistance();g.setClippingRange(e,e+.1),v(u,t.openGLCamera.getKeyMatrices(o).wcpc),g.setClippingRange(h[0],h[1]),t.openGLCamera.getKeyMatrices(o),f.setUniformMatrix(`${w}.PCWCMatrix`,u)}if(O.getVolumetricScatteringBlending()>0&&(f.setUniformf(`${w}.globalIlluminationReach`,O.getGlobalIlluminationReach()),f.setUniformf(`${w}.volumetricScatteringBlending`,O.getVolumetricScatteringBlending()),f.setUniformf(`${w}.anisotropy`,O.getAnisotropy()),f.setUniformf(`${w}.anisotropySquared`,O.getAnisotropy()**2)),O.getLocalAmbientOcclusion()&&O.getAmbient()>0){const e=O.getLAOKernelSize();f.setUniformi(`${w}.kernelSize`,e);const t=O.getLAOKernelRadius();f.setUniformi(`${w}.kernelRadius`,t)}else f.setUniformi(`${w}.kernelSize`,0)},e.setPropertyShaderParameters=(e,n,r)=>{const o=e.getProgram();o.setUniformi(&quot;jtexture&quot;,t.jitterTexture.getTextureUnit());const a=r.getProperties();o.setUniformi(&quot;labelOutlineThicknessTexture&quot;,t.labelOutlineThicknessTexture.getTextureUnit()),o.setUniformi(&quot;opacityTexture&quot;,t.opacityTexture.getTextureUnit()),o.setUniformi(&quot;colorTexture&quot;,t.colorTexture.getTextureUnit());const i=&quot;volume&quot;,s=a[t.currentValidInputs[0].inputIndex],l=t.previousState.numberOfComponents,c=t.previousState.useIndependentComponents;if(c){const e=new Float32Array(4);for(let t=0;t<l;t++)e[t]=s.getComponentWeight(t);o.setUniform4fv(`${i}.independentComponentMix`,e);const t=new Float32Array(4),n=1/l;for(let e=0;e<l;++e)t[e]=(e+.5)*n;o.setUniform4fv(`${i}.transferFunctionsSampleHeight`,t)}const u=t.colorForValueFunctionId;o.setUniformi(`${i}.colorForValueFunctionId`,u);const d=s.getComputeNormalFromOpacity();o.setUniformi(`${i}.computeNormalFromOpacity`,d);const p=new Float32Array(4),f=new Float32Array(4),g=new Float32Array(4),m=new Float32Array(4);for(let e=0;e<l;e++){const n=t.previousState.multiTexturePerVolumeEnabled,r=n?e:0,o=n?0:e,a=t.scalarTextures[r].getVolumeInfo(),i=c?e:0,l=a.scale[o],u=s.getRGBTransferFunction(i).getRange();p[e]=l/(u[1]-u[0]),f[e]=(a.offset[o]-u[0])/(u[1]-u[0]);const d=s.getScalarOpacity(i).getRange();g[e]=l/(d[1]-d[0]),m[e]=(a.offset[o]-d[0])/(d[1]-d[0])}if(o.setUniform4fv(`${i}.colorTextureScale`,p),o.setUniform4fv(`${i}.colorTextureShift`,f),o.setUniform4fv(`${i}.opacityTextureScale`,g),o.setUniform4fv(`${i}.opacityTextureShift`,m),t.previousState.gradientOpacityEnabled){const e=new Array(4),n=new Array(4),r=new Array(4),a=new Array(4);if(c)for(let o=0;o<l;++o){const i=t.previousState.multiTexturePerVolumeEnabled,l=i?o:0,c=i?0:o,u=t.scalarTextures[l].getVolumeInfo().scale[c];if(s.getUseGradientOpacity(o)){const t=[s.getGradientOpacityMinimumOpacity(o),s.getGradientOpacityMaximumOpacity(o)],i=[s.getGradientOpacityMinimumValue(o),s.getGradientOpacityMaximumValue(o)];r[o]=t[0],a[o]=t[1],e[o]=u*(t[1]-t[0])/(i[1]-i[0]),n[o]=-i[0]*(t[1]-t[0])/(i[1]-i[0])+t[0]}else r[o]=1,a[o]=1,e[o]=0,n[o]=1}else{const o=l-1,i=t.previousState.multiTexturePerVolumeEnabled,c=i?o:0,u=i?0:o,d=t.scalarTextures[c].getVolumeInfo().scale[u],p=[s.getGradientOpacityMinimumOpacity(0),s.getGradientOpacityMaximumOpacity(0)],f=[s.getGradientOpacityMinimumValue(0),s.getGradientOpacityMaximumValue(0)];r[0]=p[0],a[0]=p[1],e[0]=d*(p[1]-p[0])/(f[1]-f[0]),n[0]=-f[0]*(p[1]-p[0])/(f[1]-f[0])+p[0]}o.setUniform4f(`${i}.gradientOpacityScale`,e),o.setUniform4f(`${i}.gradientOpacityShift`,n),o.setUniform4f(`${i}.gradientOpacityMin`,r),o.setUniform4f(`${i}.gradientOpacityMax`,a)}const h=s.getLabelOutlineOpacity();if(o.setUniformf(`${i}.outlineOpacity`,h),t.numberOfLights>0){o.setUniformf(`${i}.ambient`,s.getAmbient()),o.setUniformf(`${i}.diffuse`,s.getDiffuse()),o.setUniformf(`${i}.specular`,s.getSpecular());const e=s.getSpecularPower();o.setUniformf(`${i}.specularPower`,0===e?1:e)}},e.getClippingPlaneShaderParameters=(e,n,r)=>{if(t.renderable.getClippingPlanes().length>0){const r=t.openGLCamera.getKeyMatrices(n),o=[],a=[],i=[],s=t.renderable.getClippingPlanes(),l=s.length;for(let e=0;e<l;++e){const t=s[e].getNormal(),n=s[e].getOrigin();wn(t,t,r.normalMatrix),In(n,n,r.wcvc);const l=-1*Sn(n,t);o.push(t[0]),o.push(t[1]),o.push(t[2]),a.push(l),i.push(n[0]),i.push(n[1]),i.push(n[2])}const c=e.getProgram();c.setUniform3fv(&quot;vClipPlaneNormals&quot;,o),c.setUniformfv(&quot;vClipPlaneDistances&quot;,a),c.setUniform3fv(&quot;vClipPlaneOrigins&quot;,i),c.setUniformi(&quot;clip_numPlanes&quot;,l)}},e.delete=Et((()=>{t._animationRateSubscription&&(t._animationRateSubscription.unsubscribe(),t._animationRateSubscription=null)}),(()=>{t._openGLRenderWindow&&a(t._openGLRenderWindow)}),e.delete),e.getRenderTargetSize=()=>{if(t._useSmallViewport)return[t._smallViewportWidth,t._smallViewportHeight];const{usize:e,vsize:n}=t._openGLRenderer.getTiledSizeAndOrigin();return[e,n]},e.getRenderTargetOffset=()=>{const{lowerLeftU:e,lowerLeftV:n}=t._openGLRenderer.getTiledSizeAndOrigin();return[e,n]},e.getCurrentSampleDistance=e=>{const n=e.getVTKWindow().getInteractor(),r=t.renderable.getSampleDistance();return n.isAnimating()?r*t.renderable.getInteractionSampleDistanceFactor():r},e.renderPieceStart=(n,r)=>{const o=n.getVTKWindow().getInteractor();if(t._lastScale||(t._lastScale=t.renderable.getInitialInteractionScale()),t._useSmallViewport=!1,o.isAnimating()&&t._lastScale>1.5&&(t._useSmallViewport=!0),t._animationRateSubscription||(t._animationRateSubscription=o.onAnimationFrameRateUpdate((()=>{if(t.renderable.getAutoAdjustSampleDistances()){const e=o.getRecentAnimationFrameRate(),n=o.getDesiredUpdateRate()/e;(n>1.15||n<.85)&&(t._lastScale*=n),t._lastScale>400&&(t._lastScale=400),t._lastScale<1.5&&(t._lastScale=1.5)}else t._lastScale=t.renderable.getImageSampleDistance()*t.renderable.getImageSampleDistance()}))),t._useSmallViewport){const e=t._openGLRenderWindow.getFramebufferSize(),n=1/Math.sqrt(t._lastScale);if(t._smallViewportWidth=Math.ceil(n*e[0]),t._smallViewportHeight=Math.ceil(n*e[1]),t._smallViewportHeight>e[1]&&(t._smallViewportHeight=e[1]),t._smallViewportWidth>e[0]&&(t._smallViewportWidth=e[0]),t.framebuffer.saveCurrentBindingsAndBuffers(),null===t.framebuffer.getGLFramebuffer())t.framebuffer.create(e[0],e[1]),t.framebuffer.populateFramebuffer();else{const n=t.framebuffer.getSize();n&&n[0]===e[0]&&n[1]===e[1]||(t.framebuffer.create(e[0],e[1]),t.framebuffer.populateFramebuffer())}t.framebuffer.bind();const r=t.context;r.clearColor(0,0,0,0),r.colorMask(!0,!0,!0,!0),r.clear(r.COLOR_BUFFER_BIT),r.viewport(0,0,t._smallViewportWidth,t._smallViewportHeight),t.fvp=[t._smallViewportWidth/e[0],t._smallViewportHeight/e[1]]}t.context.disable(t.context.DEPTH_TEST),e.updateBufferObjects(n,r);const a=r.getProperties();t.currentValidInputs.forEach((e=>{let{inputIndex:n}=e;const r=a[n].getInterpolationType(),o=t.scalarTextures[n];r===Yf.NEAREST?(o.setMinificationFilter(ud.NEAREST),o.setMagnificationFilter(ud.NEAREST)):(o.setMinificationFilter(ud.LINEAR),o.setMagnificationFilter(ud.LINEAR))})),null!==t.zBufferTexture&&t.zBufferTexture.activate()},e.renderPieceDraw=(n,r)=>{const o=t.context,a=[...t.scalarTextures,t.colorTexture,t.opacityTexture,t.labelOutlineThicknessTexture,t.jitterTexture];a.forEach((e=>e.activate())),e.updateShaders(t.tris,n,r),o.drawArrays(o.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release(),a.forEach((e=>e.deactivate()))},e.renderPieceFinish=(e,n)=>{if(null!==t.zBufferTexture&&t.zBufferTexture.deactivate(),t._useSmallViewport){if(t.framebuffer.restorePreviousBindingsAndBuffers(),null===t.copyShader){t.copyShader=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray([&quot;//VTK::System::Dec&quot;,&quot;attribute vec4 vertexDC;&quot;,&quot;uniform vec2 tfactor;&quot;,&quot;varying vec2 tcoord;&quot;,&quot;void main() { tcoord = vec2(vertexDC.x*0.5 + 0.5, vertexDC.y*0.5 + 0.5) * tfactor; gl_Position = vertexDC; }&quot;].join(&quot;\\n&quot;),[&quot;//VTK::System::Dec&quot;,&quot;//VTK::Output::Dec&quot;,&quot;uniform sampler2D texture1;&quot;,&quot;varying vec2 tcoord;&quot;,&quot;void main() { gl_FragData[0] = texture2D(texture1,tcoord); }&quot;].join(&quot;\\n&quot;),&quot;&quot;);const e=t.copyShader;t.copyVAO=od.newInstance(),t.copyVAO.setOpenGLRenderWindow(t._openGLRenderWindow),t.tris.getCABO().bind(),t.copyVAO.addAttributeArray(e,t.tris.getCABO(),&quot;vertexDC&quot;,t.tris.getCABO().getVertexOffset(),t.tris.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||rg(&quot;Error setting vertexDC in copy shader VAO.&quot;)}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(t.copyShader);const e=t._openGLRenderWindow.getFramebufferSize();t.context.viewport(0,0,e[0],e[1]);const n=t.framebuffer.getColorTexture();n.activate(),t.copyShader.setUniformi(&quot;texture&quot;,n.getTextureUnit()),t.copyShader.setUniform2f(&quot;tfactor&quot;,t.fvp[0],t.fvp[1]);const r=t.context;r.blendFuncSeparate(r.ONE,r.ONE_MINUS_SRC_ALPHA,r.ONE,r.ONE_MINUS_SRC_ALPHA),t.context.drawArrays(t.context.TRIANGLES,0,t.tris.getCABO().getElementCount()),n.deactivate(),r.blendFuncSeparate(r.SRC_ALPHA,r.ONE_MINUS_SRC_ALPHA,r.ONE,r.ONE_MINUS_SRC_ALPHA)}},e.renderPiece=(n,r)=>{e.invokeEvent({type:&quot;StartEvent&quot;}),t.renderable.update();const o=t.renderable.getNumberOfInputPorts();t.currentValidInputs=[];for(let e=0;e<o;++e){const n=t.renderable.getInputData(e);n&&!n.isDeleted()&&t.currentValidInputs.push({imageData:n,inputIndex:e})}let a=0;if(t.currentValidInputs.length>0){const e=r.getProperties(),o=t.currentValidInputs[0],i=o.imageData.getPointData().getScalars(),s=e[o.inputIndex];s.getShade()&&t.renderable.getBlendMode()===eg.COMPOSITE_BLEND&&n.getLights().forEach((e=>{e.getSwitch()>0&&a++}));const l=t.currentValidInputs.length,c=l>1;t.numberOfComponents=c?l:i.getNumberOfComponents(),t.useIndependentComponents=function(e,t){const n=e.getIndependentComponents(),r=e.getColorMixPreset();return n&&t>=2||!!r}(s,t.numberOfComponents)}a!==t.numberOfLights&&(t.numberOfLights=a,e.modified()),e.invokeEvent({type:&quot;EndEvent&quot;}),0!==t.currentValidInputs.length&&(e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r))},e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n)},e.getNeedToRebuildBufferObjects=(n,r)=>t.VBOBuildTime.getMTime()<e.getMTime()||t.VBOBuildTime.getMTime()<r.getMTime()||t.VBOBuildTime.getMTime()<r.getProperty(t.currentValidInputs[0].inputIndex)?.getMTime()||t.VBOBuildTime.getMTime()<t.renderable.getMTime()||t.currentValidInputs.some((e=>{let{imageData:n}=e;return t.VBOBuildTime.getMTime()<n.getMTime()}))||t.scalarTextures.length!==t.currentValidInputs.length||!t.scalarTextures.every((e=>!!e?.getHandle()))||!t.colorTexture?.getHandle()||!t.opacityTexture?.getHandle()||!t.labelOutlineThicknessTexture?.getHandle()||!t.jitterTexture?.getHandle(),e.buildBufferObjects=(n,r)=>{if(!t.jitterTexture.getHandle()){const e=new Float32Array(1024);for(let t=0;t<1024;++t)e[t]=Math.random();t.jitterTexture.setMinificationFilter(ud.NEAREST),t.jitterTexture.setMagnificationFilter(ud.NEAREST),t.jitterTexture.create2DFromRaw({width:32,height:32,numComps:1,dataType:cs.FLOAT,data:e})}const a=r.getProperties(),i=t.currentValidInputs[0],s=a[i.inputIndex],l=t.numberOfComponents,c=t.useIndependentComponents,u=c?l:1,d=[];for(let e=0;e<u;++e)d.push(s.getScalarOpacity(e));const p=wf(d,c,u),f=s.getScalarOpacity(),g=t._openGLRenderWindow.getGraphicsResourceForObject(f);if(g?.oglObject?.getHandle()&&g.hash===p)t.opacityTexture=g.oglObject;else{const r=Pd.newInstance();r.setOpenGLRenderWindow(t._openGLRenderWindow);let o=t.renderable.getOpacityTextureWidth();o<=0&&(o=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const a=2*o*u,i=new Float32Array(a),l=new Float32Array(o);for(let t=0;t<u;++t){const r=s.getScalarOpacity(t),a=e.getCurrentSampleDistance(n)/s.getScalarOpacityUnitDistance(t),c=r.getRange();r.getTable(c[0],c[1],o,l,1);for(let e=0;e<o;++e)i[t*o*2+e]=1-(1-l[e])**a,i[t*o*2+e+o]=i[t*o*2+e]}if(r.resetFormatAndType(),r.setMinificationFilter(ud.LINEAR),r.setMagnificationFilter(ud.LINEAR),t._openGLRenderWindow.getWebgl2()||t.context.getExtension(&quot;OES_texture_float&quot;)&&t.context.getExtension(&quot;OES_texture_float_linear&quot;))r.create2DFromRaw({width:o,height:2*u,numComps:1,dataType:cs.FLOAT,data:i});else{const e=new Uint8ClampedArray(a);for(let t=0;t<a;++t)e[t]=255*i[t];r.create2DFromRaw({width:o,height:2*u,numComps:1,dataType:cs.UNSIGNED_CHAR,data:e})}f&&t._openGLRenderWindow.setGraphicsResourceForObject(f,r,p),t.opacityTexture=r}o(t._openGLRenderWindow,t._opacityTextureCore,f),t._opacityTextureCore=f;const m=[];for(let e=0;e<u;++e)m.push(s.getRGBTransferFunction(e));const h=wf(m,c,u),v=s.getRGBTransferFunction(),T=t._openGLRenderWindow.getGraphicsResourceForObject(v);if(T?.oglObject?.getHandle()&&T?.hash===h)t.colorTexture=T.oglObject;else{const e=Pd.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow);let n=t.renderable.getColorTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=new Uint8ClampedArray(2*n*u*3),o=new Float32Array(3*n);for(let e=0;e<u;++e){const t=s.getRGBTransferFunction(e),a=t.getRange();t.getTable(a[0],a[1],n,o,1);for(let t=0;t<3*n;++t)r[e*n*6+t]=255*o[t],r[e*n*6+t+3*n]=255*o[t]}e.resetFormatAndType(),e.setMinificationFilter(ud.LINEAR),e.setMagnificationFilter(ud.LINEAR),e.create2DFromRaw({width:n,height:2*u,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r}),t._openGLRenderWindow.setGraphicsResourceForObject(v,e,h),t.colorTexture=e}o(t._openGLRenderWindow,t._colorTextureCore,v),t._colorTextureCore=v,t.currentValidInputs.forEach(((e,n)=>{let{imageData:r,inputIndex:i}=e;const s=a[i],l=r.getPointData().getScalars(),c=t._openGLRenderWindow.getGraphicsResourceForObject(l),u=Of(0,l),d=!c?.oglObject?.getHandle()||c?.hash!==u,p=s.getUpdatedExtents(),f=!!p.length;if(d&&!f){const e=Pd.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow);const o=r.getDimensions();e.setOglNorm16Ext(t.context.getExtension(&quot;EXT_texture_norm16&quot;)),e.resetFormatAndType(),e.create3DFilterableFromDataArray({width:o[0],height:o[1],depth:o[2],dataArray:l,preferSizeOverAccuracy:s.getPreferSizeOverAccuracy()}),t._openGLRenderWindow.setGraphicsResourceForObject(l,e,u),t.scalarTextures[n]=e}else t.scalarTextures[n]=c.oglObject;if(f){s.setUpdatedExtents([]);const e=r.getDimensions();t.scalarTextures[n].create3DFilterableFromDataArray({width:e[0],height:e[1],depth:e[2],dataArray:l,updatedExtents:p})}o(t._openGLRenderWindow,t._scalarTexturesCore[n],l),t._scalarTexturesCore[n]=l}));const y=s.getLabelOutlineThickness(),b=t._openGLRenderWindow.getGraphicsResourceForObject(y),x=y.join(&quot;-&quot;);if(b?.oglObject?.getHandle()&&b?.hash===x)t.labelOutlineThicknessTexture=b.oglObject;else{const e=Pd.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow);let n=t.renderable.getLabelOutlineTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=1,o=new Uint8Array(n*r);for(let e=0;e<n;++e){const t=void 0!==y[e]?y[e]:y[0];o[e]=t}e.resetFormatAndType(),e.setMinificationFilter(ud.NEAREST),e.setMagnificationFilter(ud.NEAREST),e.create2DFromRaw({width:n,height:r,numComps:1,dataType:cs.UNSIGNED_CHAR,data:o}),y&&t._openGLRenderWindow.setGraphicsResourceForObject(y,e,x),t.labelOutlineThicknessTexture=e}if(o(t._openGLRenderWindow,t._labelOutlineThicknessTextureCore,y),t._labelOutlineThicknessTextureCore=y,!t.tris.getCABO().getElementCount()){const e=new Float32Array(12);for(let t=0;t<4;t++)e[3*t]=t%2*2-1,e[3*t+1]=t>1?1:-1,e[3*t+2]=-1;const n=new Uint16Array(8);n[0]=3,n[1]=0,n[2]=1,n[3]=3,n[4]=3,n[5]=0,n[6]=3,n[7]=2;const r=xs.newInstance({numberOfComponents:3,values:e});r.setName(&quot;points&quot;);const o=xs.newInstance({numberOfComponents:1,values:n});t.tris.getCABO().createVBO(o,&quot;polys&quot;,Zi.SURFACE,{points:r,cellOffset:0})}t.VBOBuildTime.modified()}}(e,t)}),&quot;vtkOpenGLVolumeMapper&quot;);Jt(&quot;vtkVolumeMapper&quot;,ig);const{vtkDebugMacro:sg}=Ht,lg={};const cg=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,lg,n),qt.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLPixelSpaceCallbackMapper&quot;),e.opaquePass=(n,r)=>{t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;);const o=t._openGLRenderer.getAspectRatio(),a=t._openGLRenderer?t._openGLRenderer.getRenderable().getActiveCamera():null,i=t._openGLRenderer.getTiledSizeAndOrigin();let s=null;if(t.renderable.getUseZValues()){const e=r.getZBufferTexture(),n=Math.floor(e.getWidth()),o=Math.floor(e.getHeight()),a=t._openGLRenderWindow.getContext();e.bind();const i=r.getFramebuffer();i?i.saveCurrentBindingsAndBuffers():sg(&quot;No framebuffer to save/restore&quot;);const l=a.createFramebuffer();a.bindFramebuffer(a.FRAMEBUFFER,l),a.framebufferTexture2D(a.FRAMEBUFFER,a.COLOR_ATTACHMENT0,a.TEXTURE_2D,e.getHandle(),0),a.checkFramebufferStatus(a.FRAMEBUFFER)===a.FRAMEBUFFER_COMPLETE&&(s=new Uint8Array(n*o*4),a.viewport(0,0,n,o),a.readPixels(0,0,n,o,a.RGBA,a.UNSIGNED_BYTE,s)),i&&i.restorePreviousBindingsAndBuffers(),a.deleteFramebuffer(l)}t.renderable.invokeCallback(t.renderable.getInputData(),a,o,i,s)},e.queryPass=(e,n)=>{e&&t.renderable.getUseZValues()&&n.requestDepth()}}(e,t)}),&quot;vtkOpenGLPixelSpaceCallbackMapper&quot;);Jt(&quot;vtkPixelSpaceCallbackMapper&quot;,cg);var ug=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtktextureObjectVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\nattribute vec4 vertexDC;\\nattribute vec2 tcoordDC;\\nvarying vec2 tcoordVC;\\n\\nvoid main()\\n{\\n  tcoordVC = tcoordDC;\\n  gl_Position = vertexDC;\\n}\\n&quot;;const{Representation:dg}=os;function pg(e,t,n,r){let[o,a]=t;const i=e.getContext(),s=Pd.newInstance({autoParameters:!1,wrapS:r,wrapT:r,minificationFilter:n,magnificationFilter:n,generateMipmap:!1,openGLDataType:i.FLOAT,baseLevel:0,maxLevel:0});return s.setOpenGLRenderWindow(e),s.setInternalFormat(i.RGBA32F),s.create2DFromRaw({width:o,height:a,numComps:4,dataType:&quot;Float32Array&quot;,data:null}),s.activate(),s.sendParameters(),s.deactivate(),s}function fg(e,t){return pg(e,t,Pd.Filter.NEAREST,Pd.Wrap.CLAMP_TO_EDGE)}const gg={vectorTexture:null,maskVectorTexture:null,noiseTexture:null,doEEPass:!1,doVTPass:!1,readIndex:0,quad:null,lastProgramHash:null,framebuffer:null,size:null,pingTextures:[],pongTextures:[],textures:[]};function mg(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,gg,n),Wt.obj(e,t),Wt.get(e,t,[&quot;readIndex&quot;]),Wt.setGet(e,t,[&quot;doEEPass&quot;,&quot;doVTPass&quot;,&quot;_openGLRenderWindow&quot;,&quot;vectorTexture&quot;,&quot;maskVectorTexture&quot;,&quot;noiseTexture&quot;,&quot;framebuffer&quot;,&quot;size&quot;]),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkLICPingPongBufferManager&quot;),t._openGLRenderWindow?(t.quad=function(e){const t=ld.newInstance();t.setOpenGLRenderWindow(e);const n=new Float32Array(12);for(let e=0;e<4;e++)n[3*e]=e%2*2-1,n[3*e+1]=e>1?1:-1,n[3*e+2]=0;const r=new Float32Array([0,0,1,0,0,1,1,1]),o=new Uint16Array(8);o[0]=3,o[1]=0,o[2]=1,o[3]=3,o[4]=3,o[5]=0,o[6]=3,o[7]=2;const a=xs.newInstance({numberOfComponents:3,values:n});a.setName(&quot;points&quot;);const i=xs.newInstance({numberOfComponents:1,values:o}),s=xs.newInstance({numberOfComponents:2,values:r});return t.getCABO().createVBO(i,&quot;polys&quot;,dg.SURFACE,{points:a,cellOffset:0,tcoords:s}),t}(t._openGLRenderWindow),t.context=t._openGLRenderWindow.getContext(),t.licTexture0=fg(t._openGLRenderWindow,t.size),t.seedTexture0=fg(t._openGLRenderWindow,t.size),t.licTexture1=fg(t._openGLRenderWindow,t.size),t.seedTexture1=fg(t._openGLRenderWindow,t.size),t.eeTexture=t.doEEPass?pg(t._openGLRenderWindow,t.size,Pd.Filter.NEAREST,Pd.Wrap.CLAMP_TO_EDGE):null,t.imageVectorTexture=t.doVTPass?(n=t._openGLRenderWindow,r=t.size,pg(n,r,Pd.Filter.LINEAR,Pd.Wrap.CLAMP_TO_EDGE)):null,t.pingTextures[0]=t.licTexture0,t.pingTextures[1]=t.seedTexture0,t.pongTextures[0]=t.licTexture1,t.pongTextures[1]=t.seedTexture1,t.textures[0]=t.pingTextures,t.textures[1]=t.pongTextures,e.swap=()=>{t.readIndex=1-t.readIndex},e.renderQuad=(e,n)=>{const r=t.quad,o=t.context;let a=t.quadVAO;a||(a=od.newInstance(),a.setOpenGLRenderWindow(t._openGLRenderWindow),t.quadVAO=a),t.previousProgramHash!==n.getMd5Hash()&&(a.shaderProgramChanged(),r.getCABO().bind(),a.addAttributeArray(n,r.getCABO(),&quot;vertexDC&quot;,r.getCABO().getVertexOffset(),r.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE),a.addAttributeArray(n,r.getCABO(),&quot;tcoordDC&quot;,r.getCABO().getTCoordOffset(),r.getCABO().getStride(),t.context.FLOAT,2,t.context.FALSE),t.previousProgramHash=n.getMd5Hash()),o.drawArrays(o.TRIANGLES,0,r.getCABO().getElementCount()),a.release()},e.getLastLICBuffer=()=>0===t.readIndex?t.licTexture0:t.licTexture1,e.getLastSeedBuffer=()=>0===t.readIndex?t.seedTexture0:t.seedTexture1,e.getLICBuffer=()=>1-t.readIndex==0?t.licTexture0:t.licTexture1,e.getSeedBuffer=()=>1-t.readIndex==0?t.seedTexture0:t.seedTexture1,e.getLICTextureUnit=()=>{const e=t.textures[t.readIndex][0];return e.activate(),e.getTextureUnit()},e.getSeedTextureUnit=()=>{const e=t.textures[t.readIndex][1];return e.activate(),e.getTextureUnit()},e.getNoiseTextureUnit=function(){return 0===(arguments.length>0&&void 0!==arguments[0]?arguments[0]:0)?(t.noiseTexture.activate(),t.noiseTexture.getTextureUnit()):(t.eeTexture.activate(),t.eeTexture.getTextureUnit())},e.getVectorTextureUnit=()=>(t.vectorTexture.activate(),t.vectorTexture.getTextureUnit()),e.getImageVectorTextureUnit=()=>t.imageVectorTexture?(t.imageVectorTexture.activate(),t.imageVectorTexture.getTextureUnit()):e.getVectorTextureUnit(),e.getMaskVectorTextureUnit=()=>t.maskVectorTexture?(t.maskVectorTexture.activate(),t.maskVectorTexture.getTextureUnit()):e.getImageVectorTextureUnit(),e.clearBuffers=function(){let e=arguments.length>0&&void 0!==arguments[0]&&arguments[0];const n=t.framebuffer,r=t.context;n.removeColorBuffer(0),n.removeColorBuffer(1),n.removeColorBuffer(2),n.removeColorBuffer(3),n.setColorBuffer(t.licTexture0,0),n.setColorBuffer(t.seedTexture0,1),n.setColorBuffer(t.licTexture1,2),n.setColorBuffer(t.seedTexture1,3);const o=[r.COLOR_ATTACHMENT0,r.COLOR_ATTACHMENT1,r.COLOR_ATTACHMENT2,r.COLOR_ATTACHMENT3];e&&(n.removeColorBuffer(4),n.setColorBuffer(t.eeTexture,4),o.push(r.COLOR_ATTACHMENT4)),r.drawBuffers(o),r.clearColor(0,1,0,0),r.disable(r.SCISSOR_TEST),r.disable(r.BLEND),r.clear(r.COLOR_BUFFER_BIT),n.removeColorBuffer(0),n.removeColorBuffer(1),n.removeColorBuffer(2),n.removeColorBuffer(3),e&&n.removeColorBuffer(4),r.drawBuffers([r.NONE])},e.clearBuffer=e=>{const n=t.framebuffer,r=t.context;n.removeColorBuffer(0),n.setColorBuffer(e,0),r.drawBuffers([r.COLOR_ATTACHMENT0]),r.clearColor(0,1,0,0),r.disable(r.SCISSOR_TEST),r.disable(r.BLEND),r.clear(r.COLOR_BUFFER_BIT),n.removeColorBuffer(e,0),r.drawBuffers([r.NONE])},e.activateVectorTextures=()=>{t.imageVectorTexture?t.imageVectorTexture.activate():t.vectorTexture.activate(),t.maskVectorTexture&&t.maskVectorTexture.activate()},e.deactivateVectorTextures=()=>{t.imageVectorTexture?t.imageVectorTexture.deactivate():t.vectorTexture.deactivate(),t.maskVectorTexture&&t.maskVectorTexture.deactivate()},e.activateNoiseTexture=function(){switch(arguments.length>0&&void 0!==arguments[0]?arguments[0]:0){case 0:t.noiseTexture.activate();break;case 1:t.eeTexture.activate();break;default:console.error(&quot;Wrong LIC pass number&quot;)}},e.deactivateNoiseTexture=function(){switch(arguments.length>0&&void 0!==arguments[0]?arguments[0]:0){case 0:t.noiseTexture.deactivate();break;case 1:t.eeTexture.deactivate();break;default:console.error(&quot;Wrong LIC pass number&quot;)}},e.attachLICBuffers=()=>{const e=t.textures[t.readIndex],n=t.textures[1-t.readIndex],r=t.framebuffer,o=t.context;e[0].activate(),e[1].activate(),r.removeColorBuffer(0),r.removeColorBuffer(1),r.setColorBuffer(n[0],0),r.setColorBuffer(n[1],1),o.drawBuffers([o.COLOR_ATTACHMENT0,o.COLOR_ATTACHMENT1])},e.detachLICBuffers=()=>{const e=t.textures[t.readIndex],n=t.context,r=t.framebuffer;e[0].deactivate(),e[1].deactivate(),r.removeColorBuffer(0),r.removeColorBuffer(1),n.drawBuffers([n.NONE])},e.attachImageVectorBuffer=()=>{const e=t.framebuffer,n=t.context;t.vectorTexture.activate(),e.removeColorBuffer(0),e.setColorBuffer(t.imageVectorTexture,0),n.drawBuffers([n.COLOR_ATTACHMENT0])},e.detachImageVectorBuffer=()=>{const e=t.context,n=t.framebuffer;t.vectorTexture.deactivate(),n.removeColorBuffer(0),e.drawBuffers([e.NONE])},e.attachEEBuffer=()=>{t.textures[t.readIndex][0].activate(),t.framebuffer.removeColorBuffer(0),t.framebuffer.setColorBuffer(t.eeTexture,0);const e=t.context;e.drawBuffers([e.COLOR_ATTACHMENT0])},e.detachEEBuffer=()=>{const e=t.context;t.framebuffer.removeColorBuffer(0),e.drawBuffers([e.NONE]),t.textures[t.readIndex][0].deactivate()},e.detachBuffers=()=>{const e=t.context,n=t.framebuffer;n.removeColorBuffer(0),n.removeColorBuffer(1),e.drawBuffers([e.NONE]);const r=t.textures[t.readIndex],o=t.textures[1-t.readIndex];r[0]&&r[0].deactivate(),r[1]&&r[1].deactivate(),o[0]&&o[0].deactivate(),o[1]&&o[1].deactivate(),t.eeTexture&&t.eeTexture.deactivate(),t.noiseTexture&&t.noiseTexture.deactivate()},e.getWriteIndex=()=>1-t.readIndex,e.detachBuffers()):console.error(&quot;Pass renderwindow to ping pong manager&quot;);var n,r}(e,t)}var hg={newInstance:Wt.newInstance(mg,&quot;vtkLICPingPongBufferManager&quot;),extend:mg};const vg=0,Tg=1,yg=2,bg=3,xg=1,Cg={shadersNeedBuild:!0,stepSize:1,numberOfSteps:10,enhancedLIC:!0,enhanceContrast:!1,lowContrastEnhancementFactor:0,highContrastEnhancementFactor:0,antiAlias:0,componentIds:[0,1],normalizeVectors:!0,maskThreshold:0,transformVectors:!0,bufs:null,isComposite:!0};function Sg(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Cg,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;context&quot;,&quot;_openGLRenderWindow&quot;,&quot;nuberOfSteps&quot;,&quot;stepSize&quot;,&quot;normalizeVectors&quot;,&quot;maskThreshold&quot;,&quot;enhancedLIC&quot;,&quot;enhanceContrast&quot;,&quot;lowLICContrastEnhancementFactor&quot;,&quot;highLICContrastEnhancementFactor&quot;,&quot;antiAlias&quot;,&quot;componentIds&quot;,&quot;isComposite&quot;]),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){function n(e,t){e.setUniformi(&quot;texLIC&quot;,t.getLICTextureUnit()),e.setUniformi(&quot;texSeedPts&quot;,t.getSeedTextureUnit())}function r(e,t,n){e.attachLICBuffers(),e.renderQuad(t,n),e.detachLICBuffers(),e.swap()}t.classHierarchy.push(&quot;vtkLineIntegralConvolution2D&quot;),e.buildAShader=e=>t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(ug,e,&quot;&quot;),e.dumpTextureValues=function(e,n){let[r,o]=n,a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:t.context,i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:t._openGLRenderWindow,s=arguments.length>4&&void 0!==arguments[4]?arguments[4]:4;const l=Sp.newInstance(),c=a;let u=null;return l.setOpenGLRenderWindow(i),l.saveCurrentBindingsAndBuffers(),l.create(r,o),l.populateFramebuffer(),l.setColorBuffer(e),u=new Float32Array(r*o*s),c.readPixels(0,0,r,o,4===s?c.RGBA:c.RGB,c.FLOAT,u),l.restorePreviousBindingsAndBuffers(),u},e.getTextureMinMax=function(n,r){let o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:t.context,a=arguments.length>3&&void 0!==arguments[3]?arguments[3]:t._openGLRenderWindow;const i=e.dumpTextureValues(n,r,o,a,4);let s=Number.MAX_VALUE,l=Number.MIN_VALUE;for(let e=0;e<i.length;e+=4)if(0===i[e+1]){const t=i[e];t<s&&(s=t),t>l&&(l=t)}return{min:s,max:l}},e.getComponentSelectionProgram=e=>{const t=&quot;xyzw&quot;;return`.${t[e[0]]}${t[e[1]]}`},e.buildShaders=()=>{t.LIC0ShaderProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_LIC0.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n/**\\nThis shader initializes the convolution for the LIC computation.\\n*/\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\nuniform sampler2D texMaskVectors;\\nuniform sampler2D texNoise;\\nuniform sampler2D texLIC;\\n\\nuniform int   uStepNo;         // in step 0 initialize lic and seeds, else just seeds\\nuniform int   uPassNo;         // in pass 1 hpf of pass 0 is convolved.\\nuniform float uMaskThreshold;  // if |V| < uMaskThreshold render transparent\\nuniform vec2  uNoiseBoundsPt1; // tc of upper right pt of noise texture\\n\\nin vec2 tcoordVC;\\n\\n// convert from vector coordinate space to noise coordinate space.\\n// the noise texture is tiled across the *whole* domain\\nvec2 VectorTCToNoiseTC(vec2 vectc)\\n{\\n  return vectc/uNoiseBoundsPt1;\\n}\\n\\n// get the texture coordidnate to lookup noise value. this\\n// depends on the pass number.\\nvec2 getNoiseTC(vec2 vectc)\\n{\\n  // in pass 1 : convert from vector tc to noise tc\\n  // in pass 2 : use vector tc\\n  if (uPassNo == 0)\\n    {\\n    return VectorTCToNoiseTC(vectc);\\n    }\\n  else\\n    {\\n    return vectc;\\n    }\\n}\\n\\n// look up noise value at the given location. The location\\n// is supplied in vector texture coordinates, hence the\\n// need to convert to noise texture coordinates.\\nfloat getNoise(vec2 vectc)\\n{\\n  return texture2D(texNoise, getNoiseTC(vectc)).r;\\n}\\n\\nvoid main(void)\\n{\\n  vec2 vectc = tcoordVC.st;\\n\\n  // lic => (convolution, mask, 0, step count)\\n  if (uStepNo == 0)\\n    {\\n    float maskCriteria = length(texture2D(texMaskVectors, vectc).xyz);\\n    float maskFlag;\\n    if (maskCriteria <= uMaskThreshold)\\n      {\\n      maskFlag = 1.0;\\n      }\\n    else\\n      {\\n      maskFlag = 0.0;\\n      }\\n    float noise = getNoise(vectc);\\n    LICOutput = vec4(noise, maskFlag, 0.0, 1.0);\\n    }\\n  else\\n    {\\n    LICOutput = texture2D(texLIC, vectc);\\n    }\\n\\n  // initial seed\\n  SeedOutput = vec4(vectc, 0.0, 1.0);\\n}\\n&quot;);const n=td.substitute(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_VT.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// move vector field to normalized image space\\n// pre-processing for vtkLineIntegralConvolution2D\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\n// Fragment shader used by the gaussian blur filter render pass.\\n\\nuniform sampler2D texVectors; // input texture\\nuniform vec2      uTexSize;   // size of texture\\n\\nin vec2 tcoordVC;\\n\\nvoid main(void)\\n{\\n  //VTK::LICComponentSelection::Impl\\n  V = V/uTexSize;\\n  gl_FragData[0] = vec4(V, 0.0, 1.0);\\n}\\n&quot;,&quot;//VTK::LICComponentSelection::Impl&quot;,`vec2 V = texture2D(texVectors, tcoordVC.st)${e.getComponentSelectionProgram(t.componentIds)};`).result;t.VTProgram=e.buildAShader(n);const r=td.substitute(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_fs1.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\nuniform sampler2D  texVectors;\\nuniform sampler2D  texNoise;\\nuniform sampler2D  texLIC;\\nuniform sampler2D  texSeedPts;\\n\\nuniform int   uPassNo;          // in pass 1 hpf of pass 0 is convolved.\\nuniform float uStepSize;        // step size in parametric space\\n\\nuniform vec2  uNoiseBoundsPt1;  // tc of upper right pt of noise texture\\n\\nin vec2 tcoordVC;\\n\\n//VTK::LICVectorLookup::Impl\\n\\n// We need to do this manually since CLAMP_TO_BORDER and and borderColor\\n// are very poorly supported in webgl\\nvec2 clampToBorder(vec2 uv){\\n  if(uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0)\\n  {\\n    return vec2(0.0, 0.0);\\n  }\\n  return getVector(uv);\\n}\\n\\n// convert from vector coordinate space to noise coordinate space.\\n// the noise texture is tiled across the whole domain\\nvec2 VectorTCToNoiseTC(vec2 vectc)\\n{\\n  return vectc/uNoiseBoundsPt1;\\n}\\n\\n// get the texture coordidnate to lookup noise value.\\n// in pass 1 repeatedly tile the noise texture across\\n// the computational domain.\\nvec2 getNoiseTC(vec2 tc)\\n{\\n  if (uPassNo == 0)\\n    {\\n    return VectorTCToNoiseTC(tc);\\n    }\\n  else\\n    {\\n    return tc;\\n    }\\n}\\n\\n// look up noise value at the given location. The location\\n// is supplied in vector texture coordinates, hence the need\\n// to convert to either noise or lic texture coordinates in\\n// pass 1 and 2 respectively.\\nfloat getNoise(vec2 vectc)\\n{\\n  return texture2D(texNoise, getNoiseTC(vectc)).r;\\n}\\n\\n// fourth-order Runge-Kutta streamline integration\\n// no bounds checks are made, therefore it's essential\\n// to have the entire texture initialized to 0\\n// and set clamp to border and have border color 0\\n// an integer is set if the step was taken, keeping\\n// an accurate step count is necessary to prevent\\n// boundary artifacts. Don't count the step if\\n// all vector lookups are identically 0. This is\\n// a proxy for \\&quot;stepped outside valid domain\\&quot;\\nvec2 rk4(vec2 pt0, float dt, out bool count)\\n{\\n  count=true;\\n  float dtHalf = dt * 0.5;\\n  vec2 pt1;\\n\\n  vec2 v0 = clampToBorder(pt0);\\n  pt1 = pt0 + v0 * dtHalf;\\n\\n  vec2 v1 = clampToBorder(pt1);\\n  pt1 = pt0 + v1 * dtHalf;\\n\\n  vec2 v2 = clampToBorder(pt1);\\n  pt1 = pt0 + v2 * dt;\\n\\n  vec2 v3 = clampToBorder(pt1);\\n  vec2 vSum = v0 + v1 + v1 + v2 + v2 + v3;\\n\\n  if (vSum == vec2(0.0, 0.0))\\n    {\\n      count = false;\\n    }\\n\\n  pt1 = pt0 + (vSum) * (dt * (1.0/6.0));\\n\\n return pt1;\\n}\\n\\nvoid main(void)\\n{\\n  vec2 lictc = tcoordVC.st;\\n  vec4 lic = texture2D(texLIC, lictc);\\n  vec2 pt0 = texture2D(texSeedPts, lictc).st;\\n\\n  bool count;\\n  vec2 pt1 = rk4(pt0, uStepSize, count);\\n\\n  if (count)\\n    {\\n    // accumulate lic step\\n    // (lic, mask, 0, step count)\\n    float noise = getNoise(pt1);\\n    LICOutput = vec4(lic.r + noise, lic.g, 0.0, lic.a + 1.0);\\n    SeedOutput = vec4(pt1, 0.0, 1.0);\\n    }\\n  else\\n    {\\n    // keep existing values\\n    LICOutput = lic;\\n    SeedOutput = vec4(pt0, 0.0, 1.0);\\n    }\\n}\\n&quot;,&quot;//VTK::LICVectorLookup::Impl&quot;,function(){return arguments.length>0&&void 0!==arguments[0]&&!arguments[0]?&quot;\\n    vec2 getVector( vec2 vectc )\\n\\n      {\\n\\n      return texture2D( texVectors, vectc ).xy;\\n\\n      }\\n\\n    &quot;:&quot;\\n    vec2 getVector( vec2 vectc )\\n\\n      {\\n\\n      vec2 V = texture2D( texVectors, vectc ).xy;\\n\\n      // normalize if |V| not 0\\n\\n      float lenV = length( V );\\n\\n      if ( lenV > 1.0e-8 )\\n\\n        {\\n\\n        return V/lenV;\\n\\n        }\\n\\n      else\\n\\n        {\\n\\n        return vec2( 0.0, 0.0 );\\n\\n        }\\n\\n      }\\n\\n    &quot;}(t.normalizeVectors),!0).result;t.LICIShaderProgram=e.buildAShader(r),t.LICNShaderProgram=e.buildAShader(&quot; //VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_LICN.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\n/**\\nThis shader finalizes the convolution for the LIC computation\\napplying the normalization. eg. if box kernel is used the this\\nis the number of steps taken.\\n*/\\n\\nuniform sampler2D texLIC;\\n\\nin vec2 tcoordVC;\\n\\nvoid main(void)\\n{\\n  vec4 conv = texture2D(texLIC, tcoordVC.st);\\n  conv.r = conv.r/conv.a;\\n  // lic => (convolution, mask, 0, 1)\\n  LICOutput = vec4(conv.rg , 0.0, 1.0);\\n  SeedOutput = vec4(0.0, 0.0, 0.0, 0.0);\\n}\\n&quot;),t.CEProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_CE.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// gray scale contrast enhance stage implemented via histogram stretching\\n// if the min and max are tweaked it can generate out-of-range values\\n// these will be clamped in 0 to 1\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\n\\nuniform sampler2D texLIC;  // most recent lic pass\\nuniform float uMin;        // min gray scale color value\\nuniform float uMaxMinDiff; // max-min\\n\\nin vec2 tcoordVC;\\n\\nvoid main( void )\\n{\\n  vec4 lic = texture2D(texLIC, tcoordVC.st);\\n  if (lic.g!=0.0)\\n    {\\n    LICOutput = lic;\\n    }\\n  else\\n    {\\n    float CElic = clamp((lic.r - uMin)/uMaxMinDiff, 0.0, 1.0);\\n    LICOutput = vec4(CElic, lic.gb, 1.0);\\n    }\\n    SeedOutput = vec4(0.0, 0.0, 0.0, 0.0);\\n}\\n&quot;),t.EEProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_fs2.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// high-pass filter stage employed by vtkLineIntegralConvolution2D\\n// between LIC pass 1 and LIC pass 2. filtered LIC pass 1, becomes\\n// noise for pass2.\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 EEOutput;\\n\\nuniform sampler2D texLIC; // most recent lic pass\\nuniform float     uDx;    // fragment size\\nuniform float     uDy;    // fragment size\\n\\nin vec2 tcoordVC;\\n\\n// kernel for simple laplace edge enhancement.\\n// p=Laplace(p)+p\\nfloat K[9] = float[9](\\n  -1.0, -1.0, -1.0,\\n  -1.0,  9.0, -1.0,\\n  -1.0, -1.0, -1.0\\n  );\\n\\n// determine if the fragment was masked\\nbool Masked(float val) { return val != 0.0; }\\n\\nvoid main(void)\\n{\\n  // tex coord neighbor offsets\\n  vec2 fragDx[9] = vec2[9](\\n    vec2(-uDx, uDy), vec2(0.0, uDy), vec2(uDx, uDy),\\n    vec2(-uDx, 0.0), vec2(0.0, 0.0), vec2(uDx, 0.0),\\n    vec2(-uDx,-uDy), vec2(0.0,-uDy), vec2(uDx,-uDy)\\n    );\\n\\n  vec2 lictc = tcoordVC.st;\\n\\n  // compute the convolution but don't use convovled values if\\n  // any masked fragments on the stencil. Fragments outside\\n  // the valid domain are masked during initialization, and\\n  // texture wrap parameters are clamp to border with border\\n  // color that contains masked flag\\n  float conv = 0.0;\\n  bool dontUse = false;\\n  for (int i=0; i<9; ++i)\\n    {\\n    vec2 tc = lictc + fragDx[i];\\n    vec4 lic = texture2D(texLIC, tc);\\n    dontUse = dontUse || Masked(lic.g);\\n    conv = conv + K[i] * lic.r;\\n    }\\n\\n  if (dontUse)\\n    {\\n    EEOutput = vec4(texture2D(texLIC, lictc).rg, 0.0, 1.0);\\n    }\\n  else\\n    {\\n    conv = clamp(conv, 0.0, 1.0);\\n    EEOutput = vec4(conv,texture2D(texLIC, lictc).g, 0.0, 1.0);\\n    }\\n\\n}\\n&quot;),t.AAHProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_AAH.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// Anti-alias stage in vtkLineIntegralConvolution2D\\n// horizontal pass of a Gaussian convolution\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\nuniform sampler2D texLIC; // input texture\\nuniform float     uDx;    // fragment size\\n\\nin vec2 tcoordVC;\\n\\n// factored 3x3 Gaussian kernel\\n// K^T*K = G\\nfloat K[3] = float[3](0.141421356, 0.707106781, 0.141421356);\\n\\n// determine if the fragment was masked\\nbool Masked(float val){ return val != 0.0; }\\n\\nvoid main(void)\\n{\\n// neighbor offsets\\nvec2 fragDx[3] = vec2[3](vec2(-uDx,0.0), vec2(0.0,0.0), vec2(uDx,0.0));\\n\\n  vec2 lictc = tcoordVC.st;\\n  vec4 lic[3];\\n  bool dontUse = false;\\n  float conv = 0.0;\\n  for (int i=0; i<3; ++i)\\n    {\\n    vec2 tc = lictc + fragDx[i];\\n    lic[i] = texture2D(texLIC, tc);\\n    dontUse = dontUse || Masked(lic[i].g);\\n    conv = conv + K[i] * lic[i].r;\\n    }\\n  // output is (conv, mask, skip, 1)\\n  if (dontUse)\\n    {\\n    LICOutput = vec4(lic[1].rg, 1.0, 1.0);\\n    }\\n  else\\n    {\\n    LICOutput = vec4(conv, lic[1].gb, 1.0);\\n    }\\n  SeedOutput = vec4(0.0, 0.0, 0.0, 0.0);\\n}\\n&quot;),t.AAVProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_AAV.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// Anti-alias stage in vtkLineIntegralConvolution2D\\n// vertical pass of a Gaussian convolution\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\nuniform sampler2D texLIC; // input texture\\nuniform float     uDy;    // fragment size\\n\\nin vec2 tcoordVC;\\n\\n\\n// factored 3x3 Gaussian kernel\\n// K^T*K = G\\nfloat K[3] = float[3](0.141421356, 0.707106781, 0.141421356);\\n\\n// determine if the fragment was masked\\nbool Masked(float val){ return val != 0.0; }\\n\\nvoid main(void)\\n{\\n// neighbor offsets\\nvec2 fragDy[3] = vec2[3](vec2(0.0,-uDy), vec2(0.0,0.0), vec2(0.0,uDy));\\n\\n\\n  vec2 lictc = tcoordVC.st;\\n  vec4 lic[3];\\n  bool dontUse = false;\\n  float conv = 0.0;\\n  for (int i=0; i<3; ++i)\\n    {\\n    vec2 tc = lictc + fragDy[i];\\n    lic[i] = texture2D(texLIC, tc);\\n    dontUse = dontUse || Masked(lic[i].g);\\n    conv = conv + K[i] * lic[i].r;\\n    }\\n  // output is (conv, mask, skip, 1)\\n  if (dontUse)\\n    {\\n    LICOutput = vec4(lic[1].rg, 1.0, 1.0);\\n    }\\n  else\\n    {\\n    LICOutput = vec4(conv, lic[1].gb, 1.0);\\n    }\\n  SeedOutput = vec4(0.0, 0.0, 0.0, 0.0);\\n}\\n&quot;)},e.executeLIC=(o,a,i,s,l,c)=>{if(t._openGLRenderWindow=l,t.context=l.getContext(),Object.assign(t,c),o[0]<=0||o[1]<=0)return null;const u=[1/o[0],1/o[1]];let d=t.stepSize*Math.sqrt(u[0]*u[0]+u[1]*u[1]);d<=0&&(d=1e-10);const p=t.context;let f=t.framebuffer;const g=f?.getSize();f&&g&&o[0]===g&&o[1]===g||(f=Sp.newInstance(),f.setOpenGLRenderWindow(t._openGLRenderWindow),f.saveCurrentBindingsAndBuffers(),f.create(...o),f.populateFramebuffer(),f.restorePreviousBindingsAndBuffers(),t.framebuffer=f),f.saveCurrentBindingsAndBuffers(),f.bind(),p.viewport(0,0,...o),p.scissor(0,0,...o),t.shadersNeedBuild&&(e.buildShaders(),t.shadersNeedBuild=!1),t.bufs?(t.bufs.setVectorTexture(a),t.bufs.setMaskVectorTexture(i),t.bufs.setNoiseTexture(s)):t.bufs=hg.newInstance({openGLRenderWindow:l,doEEPass:t.enhancedLIC,doVTPass:t.transformVectors,vectorTexture:a,maskVectorTexture:i,noiseTexture:s,framebuffer:f,size:o});const m=[(s.getWidth()+1)/o[0],(s.getHeight()+1)/o[1]],h=1/o[0],v=1/o[1],T=t._openGLRenderWindow.getShaderCache();if(t.transformVectors){const e=t.VTProgram;T.readyShaderProgram(e),t.bufs.attachImageVectorBuffer(),e.setUniform2f(&quot;uTexSize&quot;,...o),e.setUniformi(&quot;texVectors&quot;,t.bufs.getVectorTextureUnit()),p.clearColor(0,0,0,0),p.clear(p.COLOR_BUFFER_BIT),t.bufs.renderQuad(o,e),t.bufs.detachImageVectorBuffer()}t.bufs.clearBuffers(t.enhancedLIC),t.bufs.activateVectorTextures(),t.bufs.activateNoiseTexture(0);const{LIC0ShaderProgram:y}=t;T.readyShaderProgram(y),y.setUniformi(&quot;uStepNo&quot;,0),y.setUniformi(&quot;uPassNo&quot;,0),y.setUniformf(&quot;uMaskThreshold&quot;,t.maskThreshold),y.setUniform2f(&quot;uNoiseBoundsPt1&quot;,...m),y.setUniformi(&quot;texMaskVectors&quot;,t.bufs.getMaskVectorTextureUnit()),y.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),y.setUniformi(&quot;texNoise&quot;,t.bufs.getNoiseTextureUnit(0)),r(t.bufs,o,y);const{LICIShaderProgram:b}=t;T.readyShaderProgram(b),b.setUniformi(&quot;uPassNo&quot;,0),b.setUniformf(&quot;uStepSize&quot;,-d),b.setUniform2f(&quot;uNoiseBoundsPt1&quot;,...m),b.setUniformi(&quot;texVectors&quot;,t.bufs.getImageVectorTextureUnit()),b.setUniformi(&quot;texNoise&quot;,t.bufs.getNoiseTextureUnit(0));for(let e=0;e<t.numberOfSteps;++e)n(b,t.bufs),r(t.bufs,o,b);T.readyShaderProgram(y),y.setUniformi(&quot;uStepNo&quot;,1),n(y,t.bufs),r(t.bufs,o,y),T.readyShaderProgram(b),b.setUniformf(&quot;uStepSize&quot;,d);for(let e=0;e<t.numberOfSteps;++e)n(b,t.bufs),r(t.bufs,o,b);t.bufs.deactivateNoiseTexture(0),t.bufs.deactivateVectorTextures();const{LICNShaderProgram:x}=t;if(T.readyShaderProgram(x),x.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),r(t.bufs,o,x),t.enhancedLIC){t.enhanceContrast!==Tg&&t.enhanceContrast!==bg||e.contrastEnhance(!1,o),t.bufs.attachEEBuffer();const{EEProgram:a}=t;T.readyShaderProgram(a),a.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),a.setUniformf(&quot;uDx&quot;,h),a.setUniformf(&quot;uDy&quot;,v),t.bufs.renderQuad(o,a),t.bufs.detachEEBuffer(),t.bufs.detachBuffers(),t.bufs.clearBuffers(!1),t.bufs.activateVectorTextures(),t.bufs.activateNoiseTexture(1),T.readyShaderProgram(y),y.setUniformi(&quot;uStepNo&quot;,0),y.setUniformi(&quot;uPassNo&quot;,1),n(y,t.bufs),y.setUniformi(&quot;texNoise&quot;,t.bufs.getNoiseTextureUnit(1)),r(t.bufs,o,y),T.readyShaderProgram(b),b.setUniformi(&quot;uPassNo&quot;,1),b.setUniformf(&quot;uStepSize&quot;,-d),b.setUniformi(&quot;texNoise&quot;,t.bufs.getNoiseTextureUnit(1));const i=t.numberOfSteps/2;for(let e=0;e<i;++e)n(b,t.bufs),r(t.bufs,o,b);T.readyShaderProgram(y),y.setUniformi(&quot;uStepNo&quot;,1),n(y,t.bufs),r(t.bufs,o,y),T.readyShaderProgram(b),b.setUniformf(&quot;uStepSize&quot;,d);for(let e=0;e<i;++e)n(b,t.bufs),r(t.bufs,o,b);t.bufs.deactivateNoiseTexture(1),t.bufs.deactivateVectorTextures(),T.readyShaderProgram(x),x.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),x.setUniformi(&quot;texSeedPts&quot;,t.bufs.getSeedTextureUnit()),r(t.bufs,o,x)}if(t.antiAlias){const e=t.AAHProgram;T.readyShaderProgram(e),e.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),e.setUniformf(&quot;uDx&quot;,h);const a=t.AAVProgram;T.readyShaderProgram(a),a.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),a.setUniformf(&quot;uDy&quot;,v);for(let i=0;i<t.antiAlias;++i)T.readyShaderProgram(e),n(e,t.bufs),r(t.bufs,o,e),T.readyShaderProgram(a),n(a,t.bufs),r(t.bufs,o,a)}return t.enhanceContrast!==Tg&&t.enhanceContrast!==bg||e.contrastEnhance(!0,o),t.bufs.detachBuffers(),f.restorePreviousBindingsAndBuffers(),t.bufs.getLastLICBuffer()},e.contrastEnhance=(n,o)=>{const a=t._openGLRenderWindow.getShaderCache();let{min:i,max:s}=e.getTextureMinMax(t.bufs.getLastLICBuffer(),o,t.context,t._openGLRenderWindow);(s<=i||s>1||i<0)&&(console.error(&quot;Invalid color range: &quot;,i,s),i=0,s=1);let l=s-i;n&&(i+=l*t.lowLICContrastEnhancementFactor,s-=l*t.highLICContrastEnhancementFactor,l=s-i);const{CEProgram:c}=t;a.readyShaderProgram(c),c.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),c.setUniformf(&quot;uMin&quot;,i),c.setUniformf(&quot;uMaxMinDiff&quot;,l),r(t.bufs,o,c)}}(e,t)}var Ag={newInstance:Wt.newInstance(Sg,&quot;vtkLineIntegralConvolution2D&quot;),extend:Sg};const Ig={enableLIC:!1,nuberOfSteps:40,stepSize:.25,transformVectors:!0,normalizeVectors:!0,maskOnSurface:!1,maskThreshold:0,maskColor:[0,0,0],maskIntensity:0,enhancedLIC:!0,enhanceContrast:vg,lowLICContrastEnhancementFactor:0,highLICContrastEnhancementFactor:0,lowColorContrastEnhancementFactor:0,highColorContrastEnhancementFactor:0,antiAlias:0,colorMode:0,LICIntensity:1,mapModeBias:0,noiseTextureSize:200,noiseTextureType:xg,noiseGrainSize:8,noiseImpulseProbability:.1,noiseImpulseBackgroundValue:0,noiseGeneratorSeed:0,minNoiseValue:0,maxNoiseValue:1,numberOfNoiseLevels:2,shadersNeedBuilding:!0,reallocateTextures:!0,rebuildNoiseTexture:!1,viewPortScale:1};function wg(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ig,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;enableLIC&quot;,&quot;numberOfSteps&quot;,&quot;stepSize&quot;,&quot;normalizeVectors&quot;,&quot;transformVectors&quot;,&quot;maskOnSurface&quot;,&quot;maskThreshold&quot;,&quot;maskColor&quot;,&quot;maskIntensity&quot;,&quot;enhancedLIC&quot;,&quot;enhanceContrast&quot;,&quot;lowLICContrastEnhancementFactor&quot;,&quot;highLICContrastEnhancementFactor&quot;,&quot;lowColorContrastEnhancementFactor&quot;,&quot;highColorContrastEnhancementFactor&quot;,&quot;antiAlias&quot;,&quot;colorMode&quot;,&quot;LICIntensity&quot;,&quot;mapModeBias&quot;,&quot;noiseTextureSize&quot;,&quot;noiseTextureType&quot;,&quot;noiseGrainSize&quot;,&quot;minNoiseValue&quot;,&quot;maxNoiseValue&quot;,&quot;numberOfNoiseLevels&quot;,&quot;noiseImpulseProbability&quot;,&quot;noiseImpulseBackgroundValue&quot;,&quot;noiseGeneratorSeed&quot;,&quot;viewPortScale&quot;,&quot;rebuildNoiseTexture&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkSurfaceLICInterface&quot;)}(0,t)}var Og={newInstance:Wt.newInstance(wg,&quot;vtkSurfaceLICInterface&quot;),extend:wg};const{Representation:Pg}=os;const Rg={context:null,shadersNeedBuilding:!0,reallocateTextures:!0,size:null,licInterface:null};function Mg(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Rg,n),Og.extend(e,t,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;context&quot;,&quot;_openGLRenderWindow&quot;,&quot;reallocateTextures&quot;,&quot;licInterface&quot;,&quot;size&quot;]),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLSurfaceLICInterface&quot;),e.renderQuad=(e,n)=>{const r=t.licQuad,o=t.context;let a=t.licQuadVAO;a||(a=od.newInstance(),a.setOpenGLRenderWindow(t._openGLRenderWindow),t.licQuadVAO=a),t.previousProgramHash!==n.getMd5Hash()&&(a.shaderProgramChanged(),r.getCABO().bind(),a.addAttributeArray(n,r.getCABO(),&quot;vertexDC&quot;,r.getCABO().getVertexOffset(),r.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE),a.addAttributeArray(n,r.getCABO(),&quot;tcoordDC&quot;,r.getCABO().getTCoordOffset(),r.getCABO().getStride(),t.context.FLOAT,2,t.context.FALSE),t.previousProgramHash=n.getMd5Hash()),o.drawArrays(o.TRIANGLES,0,r.getCABO().getElementCount()),a.release()},e.generateNoiseTexture=e=>{if(!t.noiseTexture||t.licInterface.getRebuildNoiseTexture()){t.licInterface.setRebuildNoiseTexture(!1),t.noiseTexture&&t.noiseTexture.releaseGraphicsResources(),oo(t.noiseGeneratorSeed,{global:!0});let n=[];const{noiseTextureType:r,noiseGrainSize:o,numberOfNoiseLevels:a,noiseImpulseProbability:i,noiseImpulseBackgroundValue:s,minNoiseValue:l,maxNoiseValue:c}=t.licInterface.get(&quot;noiseTextureType&quot;,&quot;noiseGrainSize&quot;,&quot;numberOfNoiseLevels&quot;,&quot;noiseImpulseProbability&quot;,&quot;noiseImpulseBackgroundValue&quot;,&quot;minNoiseValue&quot;,&quot;maxNoiseValue&quot;);n=r===xg?function(e,t,n,r,o,a){const i=Math.max(0,Math.min(1,n)),s=Float32Array.from({length:e*e},(()=>{let e=0;if(1===i||Math.random()>1-i)for(let t=0;t<2048;++t)e+=Math.random();return e}));let l=0,c=2049;s.forEach((e=>{c=1===i?e<c?e:c:e<c&&e>0?e:c,l=e>l?e:l}));let u=l-c;0===u&&(c=0,u=0===l?1:l);const d=t-1,p=0!==d?1/d:0,f=a-o;return s.map((e=>{const n=e<c?e:(e-c)/u,i=Math.floor(n*t);return e>=c?1===t?a:o+(i>d?d:i)*p*f:r}))}(Math.floor(e/o),a,i,s,l,c):function(e,t,n,r){let[o,a]=e;const i=r-n;return Float32Array.from({length:o*a},(()=>{let e=Math.random();return e=Math.floor(e*t)/t,e=e*i+n,e>1?1:e<0?0:e}))}([Math.ceil(e/o),Math.ceil(e/o)],a,l,c);const u=1/o,d=Float32Array.from({length:e*e*4},((t,r)=>{const a=r/4;if(r%4==0){const t=Math.floor(a%e*u),r=Math.floor(a/e*u);return n[r*(e/o)+t]}return r%4==1||r%4==3?1:0})),p=Pd.newInstance({wrapS:Pd.Wrap.REPEAT,wrapT:Pd.Wrap.REPEAT,minificationFilter:Pd.Filter.NEAREST,magnificationFilter:Pd.Filter.NEAREST,generateMipMap:!1,openGLDataType:t.context.FLOAT,baseLevel:0,maxLevel:0,autoParameters:!1});p.setOpenGLRenderWindow(t._openGLRenderWindow),p.create2DFromRaw({width:e,height:e,numComps:4,dataType:&quot;Float32Array&quot;,data:d}),p.activate(),p.sendParameters(),p.deactivate(),t.noiseTexture=p}},e.buildAShader=e=>t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(ug,e,&quot;&quot;),e.allocateTextures=()=>{const n=Pd.Filter.NEAREST,r=Pd.Filter.LINEAR,o=t._openGLRenderWindow;t.geometryImage||(t.geometryImage=e.allocateTexture(o,n)),t.vectorImage||(t.vectorImage=e.allocateTexture(o,r)),t.maskVectorImage||(t.maskVectorImage=e.allocateTexture(o,r)),t.LICImage||(t.LICImage=e.allocateTexture(o,n)),t.RGBColorImage||(t.RGBColorImage=e.allocateTexture(o,n)),t.HSLColorImage||(t.HSLColorImage=e.allocateTexture(o,n)),t.depthTexture||(t.depthTexture=e.allocateDepthTexture(o))},e.allocateTexture=(e,n)=>{const r=t.context,o=Pd.newInstance({wrapS:Pd.Wrap.CLAMP_TO_EDGE,wrapT:Pd.Wrap.CLAMP_TO_EDGE,minificationFilter:n,magnificationFilter:n,generateMipmap:!1,openGLDataType:r.FLOAT,baseLevel:0,maxLevel:0,autoParameters:!1});return o.setOpenGLRenderWindow(e),o.setInternalFormat(r.RGBA32F),o.create2DFromRaw({width:t.size[0],height:t.size[1],numComps:4,dataType:&quot;Float32Array&quot;,data:null}),o.activate(),o.sendParameters(),o.deactivate(),o},e.allocateDepthTexture=e=>{const n=t.context,r=Pd.newInstance({generateMipmap:!1,openGLDataType:n.FLOAT,autoParameters:!1});return r.setOpenGLRenderWindow(e),r.createDepthFromRaw({width:t.size[0],height:t.size[1],dataType:&quot;Float32Array&quot;,data:null}),r.activate(),r.sendParameters(),r.deactivate(),r},e.createFBO=()=>{if(!t.framebuffer){t.licHelper=null;const e=Sp.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow),e.saveCurrentBindingsAndBuffers(),e.create(...t.size),e.populateFramebuffer(),t.framebuffer=e,e.restorePreviousBindingsAndBuffers()}},e.completedGeometry=()=>{const e=t.context,n=t.framebuffer;n.removeColorBuffer(0),n.removeColorBuffer(1),n.removeColorBuffer(2),n.removeDepthBuffer(),e.drawBuffers([e.NONE]),n.restorePreviousBindingsAndBuffers()},e.buildAllShaders=()=>{t.shadersNeedBuilding&&(t.licColorPass=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkSurfaceLICMapper_fs2.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// This shader combines surface geometry, LIC, and  scalar colors.\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 RGBOutput;\\nlayout(location = 1) out vec4 HSLOutput;\\n\\nuniform sampler2D texVectors;       // vectors, depth\\nuniform sampler2D texGeomColors;    // scalar colors + lighting\\nuniform sampler2D texLIC;           // image lic\\nuniform int       uScalarColorMode; // select between blend, and map shader\\nuniform float     uLICIntensity;    // blend shader: blending factor for lic'd colors\\nuniform float     uMapBias;         // map shader: adjust the brightness of the result\\nuniform float     uMaskIntensity;   // blending factor for mask color\\nuniform vec3      uMaskColor;       // color for the masked out fragments\\n\\nin vec2 tcoordVC;\\n\\n/**\\nConvert from RGB color space into HSL colorspace.\\n*/\\nvec3 RGBToHSL(vec3 RGB)\\n{\\n  vec3 HSL = vec3(0.0, 0.0, 0.0);\\n\\n  float RGBMin = min(min(RGB.r, RGB.g), RGB.b);\\n  float RGBMax = max(max(RGB.r, RGB.g), RGB.b);\\n  float RGBMaxMinDiff = RGBMax - RGBMin;\\n\\n  HSL.z = (RGBMax + RGBMin) / 2.0;\\n\\n  if (RGBMaxMinDiff == 0.0)\\n    {\\n    // Gray scale\\n    HSL.x = 0.0;\\n    HSL.y = 0.0;\\n    }\\n  else\\n    {\\n    // Color\\n    if (HSL.z < 0.5)\\n      HSL.y = RGBMaxMinDiff / (RGBMax + RGBMin);\\n    else\\n      HSL.y = RGBMaxMinDiff / (2.0 - RGBMax - RGBMin);\\n\\n    float dR\\n      = (((RGBMax - RGB.r) / 6.0) + (RGBMaxMinDiff / 2.0)) / RGBMaxMinDiff;\\n    float dG\\n      = (((RGBMax - RGB.g) / 6.0) + (RGBMaxMinDiff / 2.0)) / RGBMaxMinDiff;\\n    float dB\\n      = (((RGBMax - RGB.b) / 6.0) + (RGBMaxMinDiff / 2.0)) / RGBMaxMinDiff;\\n\\n    if (RGB.r == RGBMax)\\n      HSL.x = dB - dG;\\n    else\\n    if (RGB.g == RGBMax)\\n      HSL.x = (1.0 / 3.0) + dR - dB;\\n    else\\n    if (RGB.b == RGBMax)\\n      HSL.x = (2.0 / 3.0) + dG - dR;\\n\\n    if (HSL.x < 0.0)\\n      HSL.x += 1.0;\\n\\n    if (HSL.x > 1.0)\\n      HSL.x -= 1.0;\\n    }\\n\\n  return HSL;\\n}\\n\\n/**\\nHelper for HSL to RGB conversion.\\n*/\\nfloat Util(float v1, float v2, float vH)\\n{\\n  if (vH < 0.0)\\n    vH += 1.0;\\n\\n  if (vH > 1.0)\\n     vH -= 1.0;\\n\\n  if ((6.0 * vH) < 1.0)\\n    return (v1 + (v2 - v1) * 6.0 * vH);\\n\\n  if ((2.0 * vH) < 1.0)\\n    return (v2);\\n\\n  if ((3.0 * vH) < 2.0)\\n    return (v1 + (v2 - v1) * ((2.0 / 3.0) - vH) * 6.0);\\n\\n  return v1;\\n}\\n\\n/**\\nConvert from HSL space into RGB space.\\n*/\\nvec3 HSLToRGB(vec3 HSL)\\n{\\n  vec3 RGB;\\n  if (HSL.y == 0.0)\\n    {\\n    // Gray\\n    RGB.r = HSL.z;\\n    RGB.g = HSL.z;\\n    RGB.b = HSL.z;\\n    }\\n  else\\n    {\\n    // Chromatic\\n    float v2;\\n    if (HSL.z < 0.5)\\n      v2 = HSL.z * (1.0 + HSL.y);\\n    else\\n      v2 = (HSL.z + HSL.y) - (HSL.y * HSL.z);\\n\\n    float v1 = 2.0 * HSL.z - v2;\\n\\n    RGB.r = Util(v1, v2, HSL.x + (1.0 / 3.0));\\n    RGB.g = Util(v1, v2, HSL.x);\\n    RGB.b = Util(v1, v2, HSL.x - (1.0 / 3.0));\\n    }\\n\\n  return RGB.rgb;\\n}\\n\\nvoid main()\\n{\\n  vec4 lic = texture2D(texLIC, tcoordVC.st);\\n  vec4 geomColor = texture2D(texGeomColors, tcoordVC.st);\\n\\n  // depth is used to determine which fragment belong to us\\n  // and we can change\\n  float depth = texture2D(texVectors, tcoordVC.st).a;\\n\\n  vec3 fragColorRGB;\\n  float valid;\\n  if (depth > 1.0e-3)\\n    {\\n    // we own it\\n    // shade LIC'ed geometry, or apply mask\\n    if (lic.g!=0.0)\\n      {\\n      // it's masked\\n      // apply fragment mask\\n      fragColorRGB = uMaskIntensity * uMaskColor + (1.0 - uMaskIntensity) * geomColor.rgb;\\n      valid = 0.0;\\n      }\\n    else\\n      {\\n      if (uScalarColorMode==0)\\n        {\\n        // blend with scalars\\n        fragColorRGB = lic.rrr * uLICIntensity + geomColor.rgb * (1.0 - uLICIntensity);\\n        }\\n      else\\n        {\\n        // multiply with scalars\\n        fragColorRGB = geomColor.rgb * clamp((uMapBias + lic.r), 0.0, 1.0);\\n        }\\n      if (lic.b != 0.0)\\n        {\\n        // didn't have the required guard pixels\\n        // don't consider it in min max estimation\\n        // for histpgram stretching\\n        valid = 0.0;\\n        }\\n      else\\n        {\\n        // ok to use in min/max estimates for histogram\\n        // stretching\\n        valid = 1.0;\\n        }\\n      }\\n    }\\n  else\\n    {\\n    // we don't own it\\n    // pass through scalars\\n    fragColorRGB = geomColor.rgb;\\n    valid = 0.0;\\n    }\\n\\n  // if no further stages this texture is\\n  // copied to the screen\\n  RGBOutput = vec4(fragColorRGB, geomColor.a);\\n\\n  // if further stages, move to hsl space for contrast\\n  // enhancement. encoding validity saves moving a texture to the cpu\\n  vec3 fragColorHSL = RGBToHSL(fragColorRGB);\\n  HSLOutput = vec4(fragColorHSL, valid);\\n}\\n&quot;),t.licCopyPass=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkSurfaceLICMapper_DCpy.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// This shader copies fragments and depths to the output buffer\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nuniform sampler2D texDepth;     // z values from vertex shader\\nuniform sampler2D texRGBColors; // final rgb LIC colors\\n\\nin vec2 tcoordVC;\\n\\nvoid main()\\n{\\n  gl_FragDepth = texture2D(texDepth, tcoordVC).x;\\n  gl_FragData[0] = texture2D(texRGBColors, tcoordVC);\\n\\n  // since we render a screen aligned quad\\n  // we're going to be writing fragments\\n  // not touched by the original geometry\\n  // it's critical not to modify those\\n  // fragments.\\n  if (gl_FragDepth == 1.0)\\n    {\\n    discard;\\n    }\\n}\\n&quot;),t.enhanceContrastPass=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkSurfaceLICMapper_CE.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// color contrast enhance stage implemented via histogram stretching\\n// on lightness channel. if the min and max are tweaked it can generate\\n// out-of-range values these will be clamped in 0 to 1\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nuniform sampler2D texGeomColors; // scalars + lighting\\nuniform sampler2D texLIC;        // image lic, mask\\nuniform sampler2D texHSLColors;  // hsla colors\\n\\nuniform float     uLMin;         // min lightness over all fragments\\nuniform float     uLMaxMinDiff;  // max - min lightness over all fragments\\n\\nin vec2 tcoordVC;\\n\\nvec3 HSLToRGB(vec3 HSL)\\n{\\n  vec3 RGB;\\n  float v;\\n  float h = HSL.x;\\n  float sl = HSL.y;\\n  float l = HSL.z;\\n\\n  v = (l <= 0.5) ? (l * (1.0 + sl)) : (l + sl - l * sl);\\n  if (v <= 0.0) {\\n    RGB = vec3(0.0,0.0,0.0);\\n  } else {\\n    float m;\\n    int sextant;\\n    float fract, vsf, mid1, mid2;\\n\\n    m = l + l - v;\\n    h *= 6.0;\\n    sextant = int(h);\\n    fract = h - float(sextant);\\n\\n    vsf = (v - m) * fract;\\n    mid1 = m + vsf;\\n    mid2 = v - vsf;\\n    switch (sextant) {\\n      case 0: RGB.r = v; RGB.g = mid1; RGB.b = m; break;\\n      case 1: RGB.r = mid2; RGB.g = v; RGB.b = m; break;\\n      case 2: RGB.r = m; RGB.g = v; RGB.b = mid1; break;\\n      case 3: RGB.r = m; RGB.g = mid2; RGB.b = v; break;\\n      case 4: RGB.r = mid1; RGB.g = m; RGB.b = v; break;\\n      case 5: RGB.r = v; RGB.g = m; RGB.b = mid2; break;\\n    }\\n  }\\n  return RGB;\\n}\\n\\nvoid main()\\n{\\n  // lookup hsl color , mask\\n  vec4 fragColor = texture2D(texHSLColors, tcoordVC.st);\\n\\n  // don't modify masked fragments (masked => lic.g==1)\\n  vec4 lic = texture2D(texLIC, tcoordVC.st);\\n  if (lic.g==0.0)\\n    {\\n    // normalize lightness channel\\n    fragColor.z = clamp((fragColor.z - uLMin)/uLMaxMinDiff, 0.0, 1.0);\\n    }\\n\\n  // back into rgb space\\n  fragColor.rgb = HSLToRGB(fragColor.xyz);\\n\\n  // add alpha\\n  vec4 geomColor = texture2D(texGeomColors, tcoordVC.st);\\n  fragColor.a = geomColor.a;\\n\\n  gl_FragData[0] = fragColor;\\n}\\n&quot;),t.shadersNeedBuilding=!1)},e.initializeResources=()=>{e.createFBO(),e.generateNoiseTexture(t.licInterface.getNoiseTextureSize()),e.allocateTextures(),e.buildAllShaders(),t.licQuad||(t.licQuad=function(e){const t=ld.newInstance();t.setOpenGLRenderWindow(e);const n=new Float32Array(12);for(let e=0;e<4;e++)n[3*e]=e%2*2-1,n[3*e+1]=e>1?1:-1,n[3*e+2]=0;const r=new Float32Array([0,0,1,0,0,1,1,1]),o=new Uint16Array(8);o[0]=3,o[1]=0,o[2]=1,o[3]=3,o[4]=3,o[5]=0,o[6]=3,o[7]=2;const a=xs.newInstance({numberOfComponents:3,values:n});a.setName(&quot;points&quot;);const i=xs.newInstance({numberOfComponents:1,values:o}),s=xs.newInstance({numberOfComponents:2,values:r});return t.getCABO().createVBO(i,&quot;polys&quot;,Pg.SURFACE,{points:a,cellOffset:0,tcoords:s}),t}(t._openGLRenderWindow)),t.licHelper||(t.licHelper=Ag.newInstance())},e.prepareForGeometry=()=>{const e=t.framebuffer;e.saveCurrentBindingsAndBuffers(),e.bind(),t.geometryImage.activate(),t.vectorImage.activate(),t.maskVectorImage.activate(),e.removeColorBuffer(0),e.removeColorBuffer(2),e.removeColorBuffer(3),e.setColorBuffer(t.geometryImage,0),e.setColorBuffer(t.vectorImage,2),e.setColorBuffer(t.maskVectorImage,3),e.setDepthBuffer(t.depthTexture);const n=t.context;n.drawBuffers([n.COLOR_ATTACHMENT0,n.NONE,n.COLOR_ATTACHMENT2,n.COLOR_ATTACHMENT3]),n.viewport(0,0,...t.size),n.scissor(0,0,...t.size),n.disable(n.BLEND),n.disable(n.DEPTH_TEST),n.disable(n.SCISSOR_TEST),n.clearColor(0,0,0,0),n.clear(n.DEPTH_BUFFER_BIT|n.COLOR_BUFFER_BIT)},e.copyToScreen=n=>{t.RGBColorImage.activate(),t.depthTexture.activate(),t.licCopyPass||e.initializeResources();const r=t.licCopyPass;t._openGLRenderWindow.getShaderCache().readyShaderProgram(r);const o=t.context;o.viewport(0,0,...n),o.scissor(0,0,...n),o.disable(o.BLEND),o.enable(o.DEPTH_TEST),o.disable(o.SCISSOR_TEST),r.setUniformi(&quot;texDepth&quot;,t.depthTexture.getTextureUnit()),r.setUniformi(&quot;texRGBColors&quot;,t.RGBColorImage.getTextureUnit()),e.renderQuad(n,r),t.RGBColorImage.deactivate(),t.depthTexture.deactivate()},e.combineColorsAndLIC=()=>{const n=t.context,r=t.framebuffer;r.saveCurrentBindingsAndBuffers(),r.bind(),r.create(...t.size),r.removeColorBuffer(0),r.removeColorBuffer(1),r.setColorBuffer(t.RGBColorImage,0),r.setColorBuffer(t.HSLColorImage,1),n.drawBuffers([n.COLOR_ATTACHMENT0,n.COLOR_ATTACHMENT1]),n.disable(n.DEPTH_TEST),n.clearColor(0,0,0,0),n.clear(n.COLOR_BUFFER_BIT),t.vectorImage.activate(),t.geometryImage.activate(),t.LICImage.activate(),t.licColorPass||e.initializeResources();const o=t.licColorPass;t._openGLRenderWindow.getShaderCache().readyShaderProgram(o),o.setUniformi(&quot;texVectors&quot;,t.vectorImage.getTextureUnit()),o.setUniformi(&quot;texGeomColors&quot;,t.geometryImage.getTextureUnit());const{colorMode:a,LICIntensity:i,mapModeBias:s,maskIntensity:l,maskColor:c,enhanceContrast:u,lowColorContrastEnhancementFactor:d,highColorContrastEnhancementFactor:p}=t.licInterface.get(&quot;colorMode&quot;,&quot;LICIntensity&quot;,&quot;mapModeBias&quot;,&quot;maskIntensity&quot;,&quot;maskColor&quot;,&quot;enhanceContrast&quot;,&quot;lowColorContrastEnhancementFactor&quot;,&quot;highColorContrastEnhancementFactor&quot;);if(o.setUniformi(&quot;texLIC&quot;,t.LICImage.getTextureUnit()),o.setUniformi(&quot;uScalarColorMode&quot;,a),o.setUniformf(&quot;uLICIntensity&quot;,i),o.setUniformf(&quot;uMapBias&quot;,s),o.setUniformf(&quot;uMaskIntensity&quot;,l),o.setUniform3f(&quot;uMaskColor&quot;,...c),e.renderQuad(t.size,o),t.vectorImage.deactivate(),t.geometryImage.deactivate(),t.LICImage.deactivate(),r.removeColorBuffer(0),r.removeColorBuffer(1),n.drawBuffers([n.NONE]),u===yg||u===bg){let o=0,a=1,i=a-o;o+=i*d,a-=i*p,i=a-o,r.setColorBuffer(t.RGBColorImage),n.drawBuffers([n.COLOR_ATTACHMENT0]),t.geometryImage.activate(),t.HSLColorImage.activate(),t.LICImage.activate(),t.enhanceContrastPass||e.initializeResources();const{enhanceContrastPass:s}=t;t._openGLRenderWindow.getShaderCache().readyShaderProgram(s),s.setUniformi(&quot;texGeomColors&quot;,t.geometryImage.getTextureUnit()),s.setUniformi(&quot;texHSLColors&quot;,t.HSLColorImage.getTextureUnit()),s.setUniformi(&quot;texLIC&quot;,t.LICImage.getTextureUnit()),s.setUniformf(&quot;uLMin&quot;,o),s.setUniformf(&quot;uLMaxMinDiff&quot;,i),e.renderQuad(t.size,s),t.geometryImage.deactivate(),t.HSLColorImage.deactivate(),t.LICImage.deactivate(),r.removeColorBuffer(0),n.drawBuffers([n.NONE])}r.restorePreviousBindingsAndBuffers()},e.applyLIC=()=>{const e=t.licInterface.get(&quot;stepSize&quot;,&quot;numberOfSteps&quot;,&quot;enhancedLIC&quot;,&quot;enhanceContrast&quot;,&quot;lowLICContrastEnhancementFactor&quot;,&quot;highLICContrastEnhancementFactor&quot;,&quot;antiAlias&quot;,&quot;normalizeVectors&quot;,&quot;maskThreshold&quot;,&quot;transformVectors&quot;),n=t.licHelper.executeLIC(t.size,t.vectorImage,t.maskVectorImage,t.noiseTexture,t._openGLRenderWindow,e);if(!n)return console.error(&quot;Failed to compute image LIC&quot;),void(t.LICImage=null);t.LICImage=n},e.setSize=n=>{Array.isArray(n)&&2===n.length&&(t.size&&t.size[0]===n[0]&&t.size[1]===n[1]||(t.size=n,e.releaseGraphicsResources()))},e.releaseGraphicsResources=()=>{t.geometryImage&&(t.geometryImage.releaseGraphicsResources(),t.geometryImage=null),t.vectorImage&&(t.vectorImage.releaseGraphicsResources(),t.vectorImage=null),t.maskVectorImage&&(t.maskVectorImage.releaseGraphicsResources(),t.maskVectorImage=null),t.LICImage&&(t.LICImage.releaseGraphicsResources(),t.LICImage=null),t.RGBColorImage&&(t.RGBColorImage.releaseGraphicsResources(),t.RGBColorImage=null),t.HSLColorImage&&(t.HSLColorImage.releaseGraphicsResources(),t.HSLColorImage=null),t.depthTexture&&(t.depthTexture.releaseGraphicsResources(),t.depthTexture=null),t.framebuffer&&(t.framebuffer.releaseGraphicsResources(),t.framebuffer=null)}}(e,t)}var Eg={newInstance:Wt.newInstance(Mg,&quot;vtkSurfaceLICInterface&quot;),extend:Mg};const{vtkErrorMacro:Vg}=Ht,Dg={canDrawLIC:!1,rebuildLICShaders:!1,rebuildLICBuffers:!1,openGLLicInterface:null};const Lg=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Dg,n),$d.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLSurfaceLICMapper&quot;);const n={...e};e.getNeedToRebuildShaders=(e,r,o)=>t.rebuildLICShaders||n.getNeedToRebuildShaders(e,r,o),e.replaceShaderValues=(e,r,o)=>{const a=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);let i=e.Vertex,s=e.Fragment;const l=t.renderable.getInputArrayToProcess(0);if(l&&t.canDrawLIC){s=td.substitute(s,&quot;//VTK::Output::Dec&quot;,[&quot;//VTK::Output::Dec&quot;,&quot;layout(location = 2) out vec4 vectorTexture;&quot;,&quot;layout(location = 3) out vec4 maskVectorTexture;&quot;]).result;const n=`${l.getName()}MC`;0===a&&t.lastBoundBO.set({lastLightComplexity:1},!0),i=td.substitute(i,&quot;//VTK::TCoord::Dec&quot;,[`attribute vec3 ${n};`,&quot;out vec3 licOutput;&quot;,&quot;//VTK::TCoord::Dec&quot;]).result,i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[`licOutput = ${n};`,&quot;//VTK::TCoord::Impl&quot;]).result,s=td.substitute(s,&quot;//VTK::TCoord::Dec&quot;,[&quot;uniform int uMaskOnSurface;&quot;,&quot;uniform mat3 normalMatrix;&quot;,&quot;in vec3 licOutput;&quot;,&quot;//VTK::TCoord::Dec&quot;]).result,s=td.substitute(s,&quot;//VTK::TCoord::Impl&quot;,[&quot;// projected vectors&quot;,&quot;  vec3 tcoordLIC = normalMatrix * licOutput;&quot;,&quot;  vec3 normN = normalize(normalVCVSOutput);&quot;,&quot;  float k = dot(tcoordLIC, normN);&quot;,&quot;  vec3 projected = (tcoordLIC - k*normN);&quot;,&quot;  vectorTexture = vec4(projected.x, projected.y, 0.0 , 1.0);&quot;,&quot;// vectors for fragment masking&quot;,&quot;  if (uMaskOnSurface == 0)&quot;,&quot;    {&quot;,&quot;    maskVectorTexture = vec4(licOutput, 1.0);&quot;,&quot;    }&quot;,&quot;  else&quot;,&quot;    {&quot;,&quot;    maskVectorTexture = vec4(projected.x, projected.y, 0.0 , 1.0);&quot;,&quot;    }&quot;,&quot;//VTK::TCoord::Impl&quot;],!1).result,e.Vertex=i}t.rebuildLICShaders=!1,e.Fragment=s,n.replaceShaderValues(e,r,o),a>0&&t.lastBoundBO.set({lastLightComplexity:a},!0)},e.setMapperShaderParameters=(e,r,o)=>{n.setMapperShaderParameters(e,r,o),t.canDrawLIC&&e.getProgram().setUniformi(&quot;uMaskOnSurface&quot;,t.maskOnSurface)},e.getNeedToRebuildBufferObjects=(e,r)=>t.rebuildLICBuffers||n.getNeedToRebuildBufferObjects(e,r),e.buildBufferObjects=(e,r)=>{if(t.canDrawLIC){const e=t.renderable.getInputArrayToProcess(0);e&&e.getNumberOfComponents()>1&&t.renderable.setCustomShaderAttributes([e.getName()])}t.rebuildLICBuffers=!1,n.buildBufferObjects(e,r)},e.pushState=e=>{t.stateCache={[e.BLEND]:e.isEnabled(e.BLEND),[e.DEPTH_TEST]:e.isEnabled(e.DEPTH_TEST),[e.SCISSOR_TEST]:e.isEnabled(e.SCISSOR_TEST),[e.CULL_FACE]:e.isEnabled(e.CULL_FACE)}},e.popState=e=>{const n=n=>t.stateCache[n]?e.enable(n):e.disable(n);n(e.BLEND),n(e.DEPTH_TEST),n(e.SCISSOR_TEST),n(e.CULL_FACE)},e.renderPiece=(r,o)=>{let a=!0;t._openGLRenderWindow.getWebgl2()||(Vg(&quot;SurfaceLICMapper Requires WebGL 2&quot;),a=!1),t.context.getExtension(&quot;EXT_color_buffer_float&quot;)&&t.context.getExtension(&quot;OES_texture_float_linear&quot;)||(Vg(&quot;SurfaceLICMapper requires the EXT_color_buffer_float and OES_texture_float_linear WebGL2 extensions.&quot;),a=!1),t.currentInput=t.renderable.getInputData(),t.currentInput||(Vg(&quot;No input&quot;),a=!1);let i=t.renderable.getLicInterface();i||(i=Og.newInstance(),t.renderable.setLicInterface(i)),t.openGLLicInterface||(t.openGLLicInterface=Eg.newInstance()),i!==t.openGLLicInterface.getLicInterface()&&t.openGLLicInterface.setLicInterface(i);const s=t.renderable.getInputArrayToProcess(0);if(i.getEnableLIC()&&(!s||s.getNumberOfComponents()<2)&&(Vg(&quot;No vector input array&quot;),a=!1),i.getEnableLIC()||(a=!1),t.canDrawLIC!==a&&(t.rebuildLICShaders=!0,t.rebuildLICBuffers=!0),t.canDrawLIC=a,!a||!i.getEnableLIC())return void n.renderPiece(r,o);const l=t.context,c=o.getProperty().getBackfaceCulling(),u=o.getProperty().getFrontfaceCulling();c||u?u?(t._openGLRenderWindow.enableCullFace(),l.cullFace(l.FRONT)):(t._openGLRenderWindow.enableCullFace(),l.cullFace(l.BACK)):t._openGLRenderWindow.disableCullFace();const d=t._openGLRenderWindow.getSize(),p=d.map((e=>Math.round(e*i.getViewPortScale())));t.openGLLicInterface.setSize(p),t.openGLLicInterface.setOpenGLRenderWindow(t._openGLRenderWindow),t.openGLLicInterface.setContext(t.context),e.pushState(t.context),t.openGLLicInterface.initializeResources(),t.openGLLicInterface.prepareForGeometry(),e.popState(t.context),n.renderPieceStart(r,o),n.renderPieceDraw(r,o),n.renderPieceFinish(r,o),e.pushState(t.context),t.VBOBuildTime.modified(),t.openGLLicInterface.completedGeometry(),t.context.disable(t.context.CULL_FACE),t.openGLLicInterface.applyLIC(),t.openGLLicInterface.combineColorsAndLIC(),t.openGLLicInterface.copyToScreen(d),e.popState(t.context)}}(e,t),Ct(e,t,[&quot;openGLLicInterface&quot;])}),&quot;vtkOpenGLSurfaceLICMapper&quot;);Jt(&quot;vtkSurfaceLICMapper&quot;,Lg);const{vtkErrorMacro:Bg}=Ht,Ng={};const Fg=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ng,n),$d.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLSphereMapper&quot;);const n={...e};e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkSphereMapperVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// this shader implements imposters in OpenGL for Spheres\\n\\nattribute vec4 vertexMC;\\nattribute vec2 offsetMC;\\n\\n// optional normal declaration\\n//VTK::Normal::Dec\\n\\n//VTK::Picking::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\nuniform mat3 normalMatrix; // transform model coordinate directions to view coordinates\\n\\n// material property values\\n//VTK::Color::Dec\\n\\n// clipping plane vars\\n//VTK::Clip::Dec\\n\\n// camera and actor matrix values\\n//VTK::Camera::Dec\\n\\nvarying vec4 vertexVCVSOutput;\\nvarying float radiusVCVSOutput;\\nvarying vec3 centerVCVSOutput;\\n\\nuniform int cameraParallel;\\nuniform float scaleFactor;\\n\\nvoid main()\\n{\\n  //VTK::Picking::Impl\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Clip::Impl\\n\\n  // compute the projected vertex position\\n  vec2 scaledOffsetMC = scaleFactor * offsetMC;\\n  vertexVCVSOutput = MCVCMatrix * vertexMC;\\n  centerVCVSOutput = vertexVCVSOutput.xyz;\\n  radiusVCVSOutput = length(scaledOffsetMC)*0.5;\\n\\n  // make the triangle face the camera\\n  if (cameraParallel == 0)\\n    {\\n    vec3 dir = normalize(-vertexVCVSOutput.xyz);\\n    vec3 base2 = normalize(cross(dir,vec3(1.0,0.0,0.0)));\\n    vec3 base1 = cross(base2,dir);\\n    vertexVCVSOutput.xyz = vertexVCVSOutput.xyz + scaledOffsetMC.x*base1 + scaledOffsetMC.y*base2;\\n    }\\n  else\\n    {\\n    // add in the offset\\n    vertexVCVSOutput.xy = vertexVCVSOutput.xy + scaledOffsetMC;\\n    }\\n\\n  gl_Position = VCPCMatrix * vertexVCVSOutput;\\n}\\n&quot;,e.Fragment=Md,e.Geometry=&quot;&quot;},e.replaceShaderValues=(e,r,o)=>{let a=e.Vertex,i=e.Fragment;a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 VCPCMatrix;\\n&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Dec&quot;,[&quot;varying vec4 vertexVCVSOutput;&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vec4 vertexVC = vertexVCVSOutput;\\n&quot;]).result,i=td.substitute(i,&quot;//VTK::Normal::Dec&quot;,[&quot;uniform float invertedDepth;\\n&quot;,&quot;uniform int cameraParallel;\\n&quot;,&quot;varying float radiusVCVSOutput;\\n&quot;,&quot;varying vec3 centerVCVSOutput;\\n&quot;,&quot;uniform mat4 VCPCMatrix;\\n&quot;]).result;let s=&quot;&quot;;t.context.getExtension(&quot;EXT_frag_depth&quot;)&&(s=&quot;gl_FragDepthEXT = (pos.z / pos.w + 1.0) / 2.0;\\n&quot;),t._openGLRenderWindow.getWebgl2()&&(s=&quot;gl_FragDepth = (pos.z / pos.w + 1.0) / 2.0;\\n&quot;),i=td.substitute(i,&quot;//VTK::Depth::Impl&quot;,[&quot;  vec3 EyePos;\\n&quot;,&quot;  vec3 EyeDir;\\n&quot;,&quot;  if (cameraParallel != 0) {\\n&quot;,&quot;    EyePos = vec3(vertexVC.x, vertexVC.y, vertexVC.z + 3.0*radiusVCVSOutput);\\n&quot;,&quot;    EyeDir = vec3(0.0,0.0,-1.0); }\\n&quot;,&quot;  else {\\n&quot;,&quot;    EyeDir = vertexVC.xyz;\\n&quot;,&quot;    EyePos = vec3(0.0,0.0,0.0);\\n&quot;,&quot;    float lengthED = length(EyeDir);\\n&quot;,&quot;    EyeDir = normalize(EyeDir);\\n&quot;,&quot;    if (lengthED > radiusVCVSOutput*3.0) {\\n&quot;,&quot;      EyePos = vertexVC.xyz - EyeDir*3.0*radiusVCVSOutput; }\\n&quot;,&quot;    }\\n&quot;,&quot;  EyePos = EyePos - centerVCVSOutput;\\n&quot;,&quot;  EyePos = EyePos/radiusVCVSOutput;\\n&quot;,&quot;  float b = 2.0*dot(EyePos,EyeDir);\\n&quot;,&quot;  float c = dot(EyePos,EyePos) - 1.0;\\n&quot;,&quot;  float d = b*b - 4.0*c;\\n&quot;,&quot;  vec3 normalVCVSOutput = vec3(0.0,0.0,1.0);\\n&quot;,&quot;  if (d < 0.0) { discard; }\\n&quot;,&quot;  else {\\n&quot;,&quot;    float t = (-b - invertedDepth*sqrt(d))*0.5;\\n&quot;,&quot;    normalVCVSOutput = invertedDepth*normalize(EyePos + t*EyeDir);\\n&quot;,&quot;    vertexVC.xyz = normalVCVSOutput*radiusVCVSOutput + centerVCVSOutput;\\n&quot;,&quot;    }\\n&quot;,&quot;  vec4 pos = VCPCMatrix * vertexVC;\\n&quot;,s]).result,i=td.substitute(i,&quot;//VTK::Normal::Impl&quot;,&quot;&quot;).result,t.haveSeenDepthRequest&&(i=td.substitute(i,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float computedZ = (pos.z / pos.w + 1.0) / 2.0;&quot;,&quot;float iz = floor(computedZ * 65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result),e.Vertex=a,e.Fragment=i,n.replaceShaderValues(e,r,o)},e.setMapperShaderParameters=(e,r,o)=>{if(e.getCABO().getElementCount()&&(t.VBOBuildTime>e.getAttributeUpdateTime().getMTime()||e.getShaderSourceTime().getMTime()>e.getAttributeUpdateTime().getMTime())&&e.getProgram().isAttributeUsed(&quot;offsetMC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;offsetMC&quot;,12,e.getCABO().getStride(),t.context.FLOAT,2,!1)||Bg(&quot;Error setting 'offsetMC' in shader VAO.&quot;)),e.getProgram().isUniformUsed(&quot;invertedDepth&quot;)&&e.getProgram().setUniformf(&quot;invertedDepth&quot;,t.invert?-1:1),e.getProgram().isUniformUsed(&quot;scaleFactor&quot;)){const n=t.currentInput.getPointData();null!=t.renderable.getScaleArray()&&n.hasArray(t.renderable.getScaleArray())?e.getProgram().setUniformf(&quot;scaleFactor&quot;,t.renderable.getScaleFactor()):e.getProgram().setUniformf(&quot;scaleFactor&quot;,1)}n.setMapperShaderParameters(e,r,o)},e.setCameraShaderParameters=(e,n,r)=>{const o=e.getProgram(),a=n.getActiveCamera(),i=t.openGLCamera.getKeyMatrices(n);o.isUniformUsed(&quot;VCPCMatrix&quot;)&&o.setUniformMatrix(&quot;VCPCMatrix&quot;,i.vcpc);const s=new Float64Array(16);if(o.isUniformUsed(&quot;MCVCMatrix&quot;))if(r.getIsIdentity())p(s,i.wcvc),e.getCABO().getCoordShiftAndScaleEnabled()&&b(s,s,e.getCABO().getInverseShiftAndScaleMatrix()),o.setUniformMatrix(&quot;MCVCMatrix&quot;,s);else{const n=t.openGLActor.getKeyMatrices();b(s,i.wcvc,n.mcwc),e.getCABO().getCoordShiftAndScaleEnabled()&&b(s,s,e.getCABO().getInverseShiftAndScaleMatrix()),o.setUniformMatrix(&quot;MCVCMatrix&quot;,s)}o.isUniformUsed(&quot;cameraParallel&quot;)&&e.getProgram().setUniformi(&quot;cameraParallel&quot;,a.getParallelProjection())},e.getOpenGLMode=(e,n)=>t.context.TRIANGLES,e.buildBufferObjects=(e,n)=>{const r=t.currentInput;if(null===r)return;t.renderable.mapScalars(r,1);const o=t.renderable.getColorMapColors(),a=t.primitives[t.primTypes.Tris].getCABO(),i=r.getPointData(),s=r.getPoints(),l=s.getNumberOfPoints(),c=s.getData();let u=null;null!=t.renderable.getScaleArray()&&i.hasArray(t.renderable.getScaleArray())&&(u=i.getArray(t.renderable.getScaleArray()).getData());let d=null,p=0,f=null;o?(p=o.getNumberOfComponents(),a.setColorOffset(0),a.setColorBOStride(4),d=o.getData(),f=new Uint8Array(3*l*4),a.getColorBO()||a.setColorBO(zu.newInstance()),a.getColorBO().setOpenGLRenderWindow(t._openGLRenderWindow)):a.getColorBO()&&a.setColorBO(null),a.setColorComponents(p);const g=new Float32Array(5*l*3);a.setStride(20);const m=Math.cos(vo(30));let h=0,v=0;const{useShiftAndScale:T,coordShift:y,coordScale:b}=Wu(s);T&&a.setCoordShiftAndScale(y,b);let x=0,C=0;for(let e=0;e<l;++e){let n=t.renderable.getRadius();u&&(n=u[e]),h=3*e;const r=(c[h++]-y[0])*b[0],o=(c[h++]-y[1])*b[1],a=(c[h++]-y[2])*b[2];g[x++]=r,g[x++]=o,g[x++]=a,g[x++]=-2*n*m,g[x++]=-n,d&&(v=e*p,f[C++]=d[v],f[C++]=d[v+1],f[C++]=d[v+2],f[C++]=d[v+3]),g[x++]=r,g[x++]=o,g[x++]=a,g[x++]=2*n*m,g[x++]=-n,d&&(f[C++]=d[v],f[C++]=d[v+1],f[C++]=d[v+2],f[C++]=d[v+3]),g[x++]=r,g[x++]=o,g[x++]=a,g[x++]=0,g[x++]=2*n,d&&(f[C++]=d[v],f[C++]=d[v+1],f[C++]=d[v+2],f[C++]=d[v+3])}a.setElementCount(x/5),a.upload(g,Fu.ARRAY_BUFFER),o&&a.getColorBO().upload(f,Fu.ARRAY_BUFFER),t.VBOBuildTime.modified()}}(e,t)}),&quot;vtkOpenGLSphereMapper&quot;);Jt(&quot;vtkSphereMapper&quot;,Fg);const{vtkErrorMacro:_g}=Ht,kg={};const Gg=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,kg,n),$d.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLStickMapper&quot;);const n={...e};e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkStickMapperVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// this shader implements imposters in OpenGL for Sticks\\n\\nattribute vec4 vertexMC;\\nattribute vec3 orientMC;\\nattribute vec4 offsetMC;\\nattribute float radiusMC;\\n\\n// optional normal declaration\\n//VTK::Normal::Dec\\n\\n//VTK::Picking::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\nuniform mat3 normalMatrix; // transform model coordinate directions to view coordinates\\n\\n// material property values\\n//VTK::Color::Dec\\n\\n// clipping plane vars\\n//VTK::Clip::Dec\\n\\n// camera and actor matrix values\\n//VTK::Camera::Dec\\n\\nvarying vec4 vertexVCVSOutput;\\nvarying float radiusVCVSOutput;\\nvarying float lengthVCVSOutput;\\nvarying vec3 centerVCVSOutput;\\nvarying vec3 orientVCVSOutput;\\n\\nuniform int cameraParallel;\\n\\nvoid main()\\n{\\n  //VTK::Picking::Impl\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Clip::Impl\\n\\n  vertexVCVSOutput = MCVCMatrix * vertexMC;\\n  centerVCVSOutput = vertexVCVSOutput.xyz;\\n  radiusVCVSOutput = radiusMC;\\n  lengthVCVSOutput = length(orientMC);\\n  orientVCVSOutput = normalMatrix * normalize(orientMC);\\n\\n  // make sure it is pointing out of the screen\\n  if (orientVCVSOutput.z < 0.0)\\n    {\\n    orientVCVSOutput = -orientVCVSOutput;\\n    }\\n\\n  // make the basis\\n  vec3 xbase;\\n  vec3 ybase;\\n  vec3 dir = vec3(0.0,0.0,1.0);\\n  if (cameraParallel == 0)\\n    {\\n    dir = normalize(-vertexVCVSOutput.xyz);\\n    }\\n  if (abs(dot(dir,orientVCVSOutput)) == 1.0)\\n    {\\n    xbase = normalize(cross(vec3(0.0,1.0,0.0),orientVCVSOutput));\\n    ybase = cross(xbase,orientVCVSOutput);\\n    }\\n  else\\n    {\\n    xbase = normalize(cross(orientVCVSOutput,dir));\\n    ybase = cross(orientVCVSOutput,xbase);\\n    }\\n\\n  vec3 offsets = offsetMC.xyz*2.0-1.0;\\n  vertexVCVSOutput.xyz = vertexVCVSOutput.xyz +\\n    radiusVCVSOutput*offsets.x*xbase +\\n    radiusVCVSOutput*offsets.y*ybase +\\n    0.5*lengthVCVSOutput*offsets.z*orientVCVSOutput;\\n\\n  gl_Position = VCPCMatrix * vertexVCVSOutput;\\n}\\n&quot;,e.Fragment=Md,e.Geometry=&quot;&quot;},e.replaceShaderValues=(e,r,o)=>{let a=e.Vertex,i=e.Fragment;a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 VCPCMatrix;\\n&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Dec&quot;,&quot;varying vec4 vertexVCVSOutput;&quot;).result,i=td.substitute(i,&quot;//VTK::PositionVC::Impl&quot;,&quot;  vec4 vertexVC = vertexVCVSOutput;\\n&quot;).result,i=td.substitute(i,&quot;//VTK::Normal::Dec&quot;,[&quot;uniform int cameraParallel;\\n&quot;,&quot;varying float radiusVCVSOutput;\\n&quot;,&quot;varying vec3 orientVCVSOutput;\\n&quot;,&quot;varying float lengthVCVSOutput;\\n&quot;,&quot;varying vec3 centerVCVSOutput;\\n&quot;,&quot;uniform mat4 VCPCMatrix;\\n&quot;]).result;let s=&quot;&quot;;t.context.getExtension(&quot;EXT_frag_depth&quot;)&&(s=&quot;  gl_FragDepthEXT = (pos.z / pos.w + 1.0) / 2.0;\\n&quot;),t._openGLRenderWindow.getWebgl2()&&(s=&quot;gl_FragDepth = (pos.z / pos.w + 1.0) / 2.0;\\n&quot;),i=td.substitute(i,&quot;//VTK::Depth::Impl&quot;,[&quot;  vec3 EyePos;\\n&quot;,&quot;  vec3 EyeDir;\\n&quot;,&quot;  if (cameraParallel != 0) {\\n&quot;,&quot;    EyePos = vec3(vertexVC.x, vertexVC.y, vertexVC.z + 3.0*radiusVCVSOutput);\\n&quot;,&quot;    EyeDir = vec3(0.0,0.0,-1.0); }\\n&quot;,&quot;  else {\\n&quot;,&quot;    EyeDir = vertexVC.xyz;\\n&quot;,&quot;    EyePos = vec3(0.0,0.0,0.0);\\n&quot;,&quot;    float lengthED = length(EyeDir);\\n&quot;,&quot;    EyeDir = normalize(EyeDir);\\n&quot;,&quot;    if (lengthED > radiusVCVSOutput*3.0) {\\n&quot;,&quot;      EyePos = vertexVC.xyz - EyeDir*3.0*radiusVCVSOutput; }\\n&quot;,&quot;    }\\n&quot;,&quot;  EyePos = EyePos - centerVCVSOutput;\\n&quot;,&quot;  vec3 base1;\\n&quot;,&quot;  if (abs(orientVCVSOutput.z) < 0.99) {\\n&quot;,&quot;    base1 = normalize(cross(orientVCVSOutput,vec3(0.0,0.0,1.0))); }\\n&quot;,&quot;  else {\\n&quot;,&quot;    base1 = normalize(cross(orientVCVSOutput,vec3(0.0,1.0,0.0))); }\\n&quot;,&quot;  vec3 base2 = cross(orientVCVSOutput,base1);\\n&quot;,&quot;  EyePos = vec3(dot(EyePos,base1),dot(EyePos,base2),dot(EyePos,orientVCVSOutput));\\n&quot;,&quot;  EyeDir = vec3(dot(EyeDir,base1),dot(EyeDir,base2),dot(EyeDir,orientVCVSOutput));\\n&quot;,&quot;  EyePos = EyePos/radiusVCVSOutput;\\n&quot;,&quot;  float a = EyeDir.x*EyeDir.x + EyeDir.y*EyeDir.y;\\n&quot;,&quot;  float b = 2.0*(EyePos.x*EyeDir.x + EyePos.y*EyeDir.y);\\n&quot;,&quot;  float c = EyePos.x*EyePos.x + EyePos.y*EyePos.y - 1.0;\\n&quot;,&quot;  float d = b*b - 4.0*a*c;\\n&quot;,&quot;  vec3 normalVCVSOutput = vec3(0.0,0.0,1.0);\\n&quot;,&quot;  if (d < 0.0) { discard; }\\n&quot;,&quot;  else {\\n&quot;,&quot;    float t =  (-b - sqrt(d))/(2.0*a);\\n&quot;,&quot;    float tz = EyePos.z + t*EyeDir.z;\\n&quot;,&quot;    vec3 iPoint = EyePos + t*EyeDir;\\n&quot;,&quot;    if (abs(iPoint.z)*radiusVCVSOutput > lengthVCVSOutput*0.5) {\\n&quot;,&quot;      float t2 = (-b + sqrt(d))/(2.0*a);\\n&quot;,&quot;      float tz2 = EyePos.z + t2*EyeDir.z;\\n&quot;,&quot;      if (tz2*radiusVCVSOutput > lengthVCVSOutput*0.5 || tz*radiusVCVSOutput < -0.5*lengthVCVSOutput) { discard; }\\n&quot;,&quot;      else {\\n&quot;,&quot;        normalVCVSOutput = orientVCVSOutput;\\n&quot;,&quot;        float t3 = (lengthVCVSOutput*0.5/radiusVCVSOutput - EyePos.z)/EyeDir.z;\\n&quot;,&quot;        iPoint = EyePos + t3*EyeDir;\\n&quot;,&quot;        vertexVC.xyz = radiusVCVSOutput*(iPoint.x*base1 + iPoint.y*base2 + iPoint.z*orientVCVSOutput) + centerVCVSOutput;\\n&quot;,&quot;        }\\n&quot;,&quot;      }\\n&quot;,&quot;    else {\\n&quot;,&quot;      normalVCVSOutput = iPoint.x*base1 + iPoint.y*base2;\\n&quot;,&quot;      vertexVC.xyz = radiusVCVSOutput*(normalVCVSOutput + iPoint.z*orientVCVSOutput) + centerVCVSOutput;\\n&quot;,&quot;      }\\n&quot;,&quot;    }\\n&quot;,&quot;  vec4 pos = VCPCMatrix * vertexVC;\\n&quot;,s]).result,i=td.substitute(i,&quot;//VTK::Normal::Impl&quot;,&quot;&quot;).result,t.haveSeenDepthRequest&&(i=td.substitute(i,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float computedZ = (pos.z / pos.w + 1.0) / 2.0;&quot;,&quot;float iz = floor(computedZ * 65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result),e.Vertex=a,e.Fragment=i,n.replaceShaderValues(e,r,o)},e.setMapperShaderParameters=(e,r,o)=>{e.getCABO().getElementCount()&&(t.VBOBuildTime>e.getAttributeUpdateTime().getMTime()||e.getShaderSourceTime().getMTime()>e.getAttributeUpdateTime().getMTime())&&(e.getProgram().isAttributeUsed(&quot;orientMC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;orientMC&quot;,12,e.getCABO().getStride(),t.context.FLOAT,3,!1)||_g(&quot;Error setting 'orientMC' in shader VAO.&quot;)),e.getProgram().isAttributeUsed(&quot;offsetMC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO().getColorBO(),&quot;offsetMC&quot;,0,e.getCABO().getColorBOStride(),t.context.UNSIGNED_BYTE,3,!0)||_g(&quot;Error setting 'offsetMC' in shader VAO.&quot;)),e.getProgram().isAttributeUsed(&quot;radiusMC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;radiusMC&quot;,24,e.getCABO().getStride(),t.context.FLOAT,1,!1)||_g(&quot;Error setting 'radiusMC' in shader VAO.&quot;))),n.setMapperShaderParameters(e,r,o)},e.setCameraShaderParameters=(e,n,r)=>{const o=e.getProgram(),a=n.getActiveCamera(),i=t.openGLCamera.getKeyMatrices(n);if(o.isUniformUsed(&quot;VCPCMatrix&quot;)&&o.setUniformMatrix(&quot;VCPCMatrix&quot;,i.vcpc),r.getIsIdentity())o.isUniformUsed(&quot;MCVCMatrix&quot;)&&o.setUniformMatrix(&quot;MCVCMatrix&quot;,i.wcvc),o.isUniformUsed(&quot;normalMatrix&quot;)&&o.setUniformMatrix3x3(&quot;normalMatrix&quot;,i.normalMatrix);else{const e=t.openGLActor.getKeyMatrices();if(o.isUniformUsed(&quot;MCVCMatrix&quot;)){const t=new Float64Array(16);b(t,i.wcvc,e.mcwc),o.setUniformMatrix(&quot;MCVCMatrix&quot;,t)}if(o.isUniformUsed(&quot;normalMatrix&quot;)){const t=new Float64Array(9);Te(t,i.normalMatrix,e.normalMatrix),o.setUniformMatrix3x3(&quot;normalMatrix&quot;,t)}}o.isUniformUsed(&quot;cameraParallel&quot;)&&e.getProgram().setUniformi(&quot;cameraParallel&quot;,a.getParallelProjection())},e.getOpenGLMode=(e,n)=>t.context.TRIANGLES,e.buildBufferObjects=(e,n)=>{const r=t.currentInput;if(null===r)return;t.renderable.mapScalars(r,1);const o=t.renderable.getColorMapColors(),a=t.primitives[t.primTypes.Tris].getCABO(),i=r.getPointData(),s=r.getPoints(),l=s.getNumberOfPoints(),c=s.getData();let u=3;u+=4;let d=null,p=0;a.setColorBOStride(4),a.getColorBO()||a.setColorBO(zu.newInstance()),a.getColorBO().setOpenGLRenderWindow(t._openGLRenderWindow),o&&(p=o.getNumberOfComponents(),a.setColorOffset(4),d=o.getData(),a.setColorBOStride(8)),a.setColorComponents(p),a.setStride(28);const f=new Float32Array(7*l*12),g=new Uint8Array(12*l*(d?8:4));let m=null,h=null;null!=t.renderable.getScaleArray()&&i.hasArray(t.renderable.getScaleArray())&&(m=i.getArray(t.renderable.getScaleArray()).getData()),null!=t.renderable.getOrientationArray()&&i.hasArray(t.renderable.getOrientationArray())?h=i.getArray(t.renderable.getOrientationArray()).getData():_g([&quot;Error setting orientationArray.\\n&quot;,&quot;You have to specify the stick orientation&quot;]);const v=[0,1,3,0,3,2,2,3,5,2,5,4];let T=0,y=0,b=0,x=0;for(let e=0;e<l;++e){let n=t.renderable.getLength(),r=t.renderable.getRadius();m&&(n=m[2*e],r=m[2*e+1]);for(let t=0;t<v.length;++t)T=3*e,f[b++]=c[T++],f[b++]=c[T++],f[b++]=c[T++],T=3*e,f[b++]=h[T++]*n,f[b++]=h[T++]*n,f[b++]=h[T++]*n,f[b++]=r,g[x++]=v[t]%2*255,g[x++]=v[t]>=4?255:0,g[x++]=v[t]>=2?255:0,g[x++]=255,y=e*p,d&&(g[x++]=d[y],g[x++]=d[y+1],g[x++]=d[y+2],g[x++]=d[y+3])}a.setElementCount(b/7),a.upload(f,Fu.ARRAY_BUFFER),a.getColorBO().upload(g,Fu.ARRAY_BUFFER),t.VBOBuildTime.modified()}}(e,t)}),&quot;vtkOpenGLStickMapper&quot;);Jt(&quot;vtkStickMapper&quot;,Gg);const Ug=[];Ug[&quot;-&quot;.charCodeAt(0)]=62,Ug[&quot;_&quot;.charCodeAt(0)]=63;const zg=&quot;ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/&quot;;for(let e=0;e<64;e++)Ug[zg.charCodeAt(e)]=e;function Wg(e){return void 0!==Ug[e.charCodeAt(0)]}function Hg(e,t,n,r){const{start:o,count:a}=t,i=a%4,s=Math.floor(a/4);let l=o,c=null,u=n;for(let t=0;t<s;t++){for(;!Wg(e[l]);)l++;for(c=Ug[e.charCodeAt(l++)]<<18;!Wg(e[l]);)l++;for(c|=Ug[e.charCodeAt(l++)]<<12;!Wg(e[l]);)l++;for(c|=Ug[e.charCodeAt(l++)]<<6;!Wg(e[l]);)l++;c|=Ug[e.charCodeAt(l++)],r[u++]=c>>16&255,r[u++]=c>>8&255,r[u++]=255&c}switch(i){case 3:for(;!Wg(e[l]);)l++;for(c=Ug[e.charCodeAt(l++)]<<10;!Wg(e[l]);)l++;for(c|=Ug[e.charCodeAt(l++)]<<4;!Wg(e[l]);)l++;c|=Ug[e.charCodeAt(l++)]>>2,r[u++]=c>>8&255,r[u++]=255&c;break;case 2:for(;!Wg(e[l]);)l++;for(c=Ug[e.charCodeAt(l++)]<<2;!Wg(e[l]);)l++;c|=Ug[e.charCodeAt(l++)]>>4,r[u++]=255&c;break;case 1:throw new Error(&quot;BASE64: remain 1 should not happen&quot;)}return u}function jg(e,t,n){const r=(e<<16)+(t<<8)+n;return zg[r>>18]+zg[r>>12&63]+zg[r>>6&63]+zg[63&r]}function Kg(e){const t=new Uint8Array(e),n=e.byteLength%3,r=e.byteLength-n,o=Array(r/3);for(let e=0;e<o.length;e++){const n=3*e;o[e]=jg(t[n],t[n+1],t[n+2])}if(n>0){const e=jg(t[r],t[r+1]||0,t[r+2]||0);1===n?o.push(`${e.substr(0,2)}==`):2===n&&o.push(`${e.substr(0,3)}=`)}return o.join(&quot;&quot;)}var $g={toArrayBuffer:function(e){const t=function(e){const t=e.length,n=[];let r=null;for(let o=0;o<t;o++)Wg(e[o])?(r||(r={start:o,count:0}),r.count++,r.end=o):&quot;=&quot;===e[o]&&r&&(n.push(r),r=null);return r&&n.push(r),n}(e),n=t[t.length-1].end+1,r=(4-n%4)%4,o=new ArrayBuffer(3*(n+r)/4-r),a=new Uint8Array(o);let i=0;for(let n=0;n<t.length;n++)i+=Hg(e,t[n],i,a),i+=(4-t[n].count%4)%4;return o},fromArrayBuffer:Kg};const qg={};function Xg(e,t){qg[e]=t}var Yg={get:function(){let e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return qg[arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;http&quot;](e)},has:function(e){return!!qg[e]},registerType:Xg},Zg=Uint8Array,Qg=Uint16Array,Jg=Uint32Array,em=new Zg([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),tm=new Zg([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),nm=new Zg([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),rm=function(e,t){for(var n=new Qg(31),r=0;r<31;++r)n[r]=t+=1<<e[r-1];var o=new Jg(n[30]);for(r=1;r<30;++r)for(var a=n[r];a<n[r+1];++a)o[a]=a-n[r]<<5|r;return[n,o]},om=rm(em,2),am=om[0],im=om[1];am[28]=258,im[258]=28;for(var sm=rm(tm,0),lm=sm[0],cm=(sm[1],new Qg(32768)),um=0;um<32768;++um){var dm=(43690&um)>>>1|(21845&um)<<1;dm=(61680&(dm=(52428&dm)>>>2|(13107&dm)<<2))>>>4|(3855&dm)<<4,cm[um]=((65280&dm)>>>8|(255&dm)<<8)>>>1}var pm=function(e,t,n){for(var r=e.length,o=0,a=new Qg(t);o<r;++o)e[o]&&++a[e[o]-1];var i,s=new Qg(t);for(o=0;o<t;++o)s[o]=s[o-1]+a[o-1]<<1;if(n){i=new Qg(1<<t);var l=15-t;for(o=0;o<r;++o)if(e[o])for(var c=o<<4|e[o],u=t-e[o],d=s[e[o]-1]++<<u,p=d|(1<<u)-1;d<=p;++d)i[cm[d]>>>l]=c}else for(i=new Qg(r),o=0;o<r;++o)e[o]&&(i[o]=cm[s[e[o]-1]++]>>>15-e[o]);return i},fm=new Zg(288);for(um=0;um<144;++um)fm[um]=8;for(um=144;um<256;++um)fm[um]=9;for(um=256;um<280;++um)fm[um]=7;for(um=280;um<288;++um)fm[um]=8;var gm=new Zg(32);for(um=0;um<32;++um)gm[um]=5;var mm=pm(fm,9,1),hm=pm(gm,5,1),vm=function(e){for(var t=e[0],n=1;n<e.length;++n)e[n]>t&&(t=e[n]);return t},Tm=function(e,t,n){var r=t/8|0;return(e[r]|e[r+1]<<8)>>(7&t)&n},ym=function(e,t){var n=t/8|0;return(e[n]|e[n+1]<<8|e[n+2]<<16)>>(7&t)},bm=function(e,t,n){(null==t||t<0)&&(t=0),(null==n||n>e.length)&&(n=e.length);var r=new(2==e.BYTES_PER_ELEMENT?Qg:4==e.BYTES_PER_ELEMENT?Jg:Zg)(n-t);return r.set(e.subarray(t,n)),r},xm=[&quot;unexpected EOF&quot;,&quot;invalid block type&quot;,&quot;invalid length/literal&quot;,&quot;invalid distance&quot;,&quot;stream finished&quot;,&quot;no stream handler&quot;,,&quot;no callback&quot;,&quot;invalid UTF-8 data&quot;,&quot;extra field too long&quot;,&quot;date not in range 1980-2099&quot;,&quot;filename too long&quot;,&quot;stream finishing&quot;,&quot;invalid zip data&quot;],Cm=function(e,t,n){var r=new Error(t||xm[e]);if(r.code=e,Error.captureStackTrace&&Error.captureStackTrace(r,Cm),!n)throw r;return r},Sm=function(e,t,n){var r=e.length;if(!r||n&&n.f&&!n.l)return t||new Zg(0);var o=!t||n,a=!n||n.i;n||(n={}),t||(t=new Zg(3*r));var i,s=function(e){var n=t.length;if(e>n){var r=new Zg(Math.max(2*n,e));r.set(t),t=r}},l=n.f||0,c=n.p||0,u=n.b||0,d=n.l,p=n.d,f=n.m,g=n.n,m=8*r;do{if(!d){l=Tm(e,c,1);var h=Tm(e,c+1,3);if(c+=3,!h){var v=e[(i=c,(P=4+((i+7)/8|0))-4)]|e[P-3]<<8,T=P+v;if(T>r){a&&Cm(0);break}o&&s(u+v),t.set(e.subarray(P,T),u),n.b=u+=v,n.p=c=8*T,n.f=l;continue}if(1==h)d=mm,p=hm,f=9,g=5;else if(2==h){var y=Tm(e,c,31)+257,b=Tm(e,c+10,15)+4,x=y+Tm(e,c+5,31)+1;c+=14;for(var C=new Zg(x),S=new Zg(19),A=0;A<b;++A)S[nm[A]]=Tm(e,c+3*A,7);c+=3*b;var I=vm(S),w=(1<<I)-1,O=pm(S,I,1);for(A=0;A<x;){var P,R=O[Tm(e,c,w)];if(c+=15&R,(P=R>>>4)<16)C[A++]=P;else{var M=0,E=0;for(16==P?(E=3+Tm(e,c,3),c+=2,M=C[A-1]):17==P?(E=3+Tm(e,c,7),c+=3):18==P&&(E=11+Tm(e,c,127),c+=7);E--;)C[A++]=M}}var V=C.subarray(0,y),D=C.subarray(y);f=vm(V),g=vm(D),d=pm(V,f,1),p=pm(D,g,1)}else Cm(1);if(c>m){a&&Cm(0);break}}o&&s(u+131072);for(var L=(1<<f)-1,B=(1<<g)-1,N=c;;N=c){var F=(M=d[ym(e,c)&L])>>>4;if((c+=15&M)>m){a&&Cm(0);break}if(M||Cm(2),F<256)t[u++]=F;else{if(256==F){N=c,d=null;break}var _=F-254;if(F>264){var k=em[A=F-257];_=Tm(e,c,(1<<k)-1)+am[A],c+=k}var G=p[ym(e,c)&B],U=G>>>4;if(G||Cm(3),c+=15&G,D=lm[U],U>3&&(k=tm[U],D+=ym(e,c)&(1<<k)-1,c+=k),c>m){a&&Cm(0);break}o&&s(u+131072);for(var z=u+_;u<z;u+=4)t[u]=t[u-D],t[u+1]=t[u+1-D],t[u+2]=t[u+2-D],t[u+3]=t[u+3-D];u=z}}n.l=d,n.p=N,n.b=u,n.f=l,d&&(l=1,n.m=f,n.d=p,n.n=g)}while(!l);return u==t.length?t:bm(t,0,u)},Am=new Zg(0),Im=function(e,t){return e[t]|e[t+1]<<8},wm=function(e,t){return(e[t]|e[t+1]<<8|e[t+2]<<16|e[t+3]<<24)>>>0},Om=function(e,t){return wm(e,t)+4294967296*wm(e,t+4)};function Pm(e,t){return Sm(e,t)}function Rm(e,t){return Sm(e.subarray(function(e){31==e[0]&&139==e[1]&&8==e[2]||Cm(6,&quot;invalid gzip data&quot;);var t=e[3],n=10;4&t&&(n+=e[10]|2+(e[11]<<8));for(var r=(t>>3&1)+(t>>4&1);r>0;r-=!e[n++]);return n+(2&t)}(e),-8),t||new Zg((r=(n=e).length,(n[r-4]|n[r-3]<<8|n[r-2]<<16|n[r-1]<<24)>>>0)));var n,r}function Mm(e,t){return Sm(((8!=(15&(n=e)[0])||n[0]>>>4>7||(n[0]<<8|n[1])%31)&&Cm(6,&quot;invalid zlib data&quot;),32&n[1]&&Cm(6,&quot;invalid zlib data: preset dictionaries not supported&quot;),e.subarray(2,-4)),t);var n}function Em(e,t){return 31==e[0]&&139==e[1]&&8==e[2]?Rm(e,t):8!=(15&e[0])||e[0]>>4>7||(e[0]<<8|e[1])%31?Pm(e,t):Mm(e,t)}var Vm=&quot;undefined&quot;!=typeof TextEncoder&&new TextEncoder,Dm=&quot;undefined&quot;!=typeof TextDecoder&&new TextDecoder;try{Dm.decode(Am,{stream:!0})}catch(e){}function Lm(e,t){if(t){for(var n=&quot;&quot;,r=0;r<e.length;r+=16384)n+=String.fromCharCode.apply(null,e.subarray(r,r+16384));return n}if(Dm)return Dm.decode(e);var o=function(e){for(var t=&quot;&quot;,n=0;;){var r=e[n++],o=(r>127)+(r>223)+(r>239);if(n+o>e.length)return[t,bm(e,n-1)];o?3==o?(r=((15&r)<<18|(63&e[n++])<<12|(63&e[n++])<<6|63&e[n++])-65536,t+=String.fromCharCode(55296|r>>10,56320|1023&r)):t+=1&o?String.fromCharCode((31&r)<<6|63&e[n++]):String.fromCharCode((15&r)<<12|(63&e[n++])<<6|63&e[n++]):t+=String.fromCharCode(r)}}(e),a=o[0];return o[1].length&&Cm(8),a}var Bm=function(e,t){return t+30+Im(e,t+26)+Im(e,t+28)},Nm=function(e,t,n){var r=Im(e,t+28),o=Lm(e.subarray(t+46,t+46+r),!(2048&Im(e,t+8))),a=t+46+r,i=wm(e,t+20),s=n&&4294967295==i?Fm(e,a):[i,wm(e,t+24),wm(e,t+42)],l=s[0],c=s[1],u=s[2];return[Im(e,t+10),l,c,o,a+Im(e,t+30)+Im(e,t+32),u]},Fm=function(e,t){for(;1!=Im(e,t);t+=4+Im(e,t+2));return[Om(e,t+12),Om(e,t+4),Om(e,t+20)]};function _m(e,t){for(var n={},r=e.length-22;101010256!=wm(e,r);--r)(!r||e.length-r>65558)&&Cm(13);var o=Im(e,r+8);if(!o)return{};var a=wm(e,r+16),i=4294967295==a;i&&(r=wm(e,r-12),101075792!=wm(e,r)&&Cm(13),o=wm(e,r+32),a=wm(e,r+48));for(var s=t&&t.filter,l=0;l<o;++l){var c=Nm(e,a,i),u=c[0],d=c[1],p=c[2],f=c[3],g=c[4],m=c[5],h=Bm(e,m);a=g,s&&!s({name:f,size:d,originalSize:p,compression:u})||(u?8==u?n[f]=Pm(e.subarray(h,h+d),new Zg(p)):Cm(14,&quot;unknown compression type &quot;+u):n[f]=bm(e,h,h+d))}return n}function km(){const e=new ArrayBuffer(4),t=new Uint8Array(e),n=new Uint32Array(e);return t[0]=161,t[1]=178,t[2]=195,t[3]=212,3569595041===n[0]?&quot;LittleEndian&quot;:2712847316===n[0]?&quot;BigEndian&quot;:null}&quot;function&quot;==typeof queueMicrotask?queueMicrotask:&quot;function&quot;==typeof setTimeout&&setTimeout;var Gm=km(),Um=function(e,t){if(t<2)return;const n=new Int8Array(e),r=n.length,o=[];for(let e=0;e<r;e+=t){for(let r=0;r<t;r++)o.push(n[e+r]);for(let r=0;r<t;r++)n[e+r]=o.pop()}};const{vtkErrorMacro:zm,vtkDebugMacro:Wm}=Wt;let Hm=0;function jm(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};const r=new XMLHttpRequest;return r.open(e,t,!0),n.headers&&Object.entries(n.headers).forEach((e=>{let[t,n]=e;return r.setRequestHeader(t,n)})),n.progressCallback&&r.addEventListener(&quot;progress&quot;,n.progressCallback),r}const Km={fetchArray:function(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return n.ref&&!n.ref.pending?new Promise(((o,a)=>{let i=null;i=n.ref.url?n.ref.url:[t,n.ref.basepath,r.compression?`${n.ref.id}.gz`:n.ref.id].join(&quot;/&quot;);const s=jm(&quot;GET&quot;,i,r);s.onreadystatechange=t=>{1===s.readyState&&(n.ref.pending=!0,1==++Hm&&e?.invokeBusy&&e.invokeBusy(!0)),4===s.readyState&&(n.ref.pending=!1,200===s.status||0===s.status?(n.buffer=s.response,r.compression&&(&quot;string&quot;===n.dataType||&quot;JSON&quot;===n.dataType?n.buffer=Lm(Em(new Uint8Array(n.buffer))):n.buffer=Em(new Uint8Array(n.buffer)).buffer),&quot;JSON&quot;===n.ref.encode?n.values=JSON.parse(n.buffer):(Gm!==n.ref.encode&&Gm&&(Wm(`Swap bytes of ${n.name}`),Um(n.buffer,ls[n.dataType])),n.values=Wt.newTypedArray(n.dataType,n.buffer)),n.values.length!==n.size&&zm(`Error in FetchArray: ${n.name}, does not have the proper array size. Got ${n.values.length}, instead of ${n.size}`),delete n.ref,0==--Hm&&e?.invokeBusy&&e.invokeBusy(!1),e?.modified&&e.modified(),o(n)):a({xhr:s,e:t}))},s.responseType=r.compression||&quot;string&quot;!==n.dataType?&quot;arraybuffer&quot;:&quot;text&quot;,s.send()})):Promise.resolve(n)},fetchJSON:function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return new Promise(((r,o)=>{const a=jm(&quot;GET&quot;,t,n);a.onreadystatechange=t=>{1===a.readyState&&1==++Hm&&e?.invokeBusy&&e.invokeBusy(!0),4===a.readyState&&(0==--Hm&&e?.invokeBusy&&e.invokeBusy(!1),200===a.status||0===a.status?n.compression?r(JSON.parse(Lm(Em(new Uint8Array(a.response))))):r(JSON.parse(a.responseText)):o({xhr:a,e:t}))},a.responseType=n.compression?&quot;arraybuffer&quot;:&quot;text&quot;,a.send()}))},fetchText:function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return n&&n.compression&&&quot;gz&quot;!==n.compression&&(zm(&quot;Supported algorithms are: [gz]&quot;),zm(`Unkown compression algorithm: ${n.compression}`)),new Promise(((r,o)=>{const a=jm(&quot;GET&quot;,t,n);a.onreadystatechange=t=>{1===a.readyState&&1==++Hm&&e?.invokeBusy&&e.invokeBusy(!0),4===a.readyState&&(0==--Hm&&e?.invokeBusy&&e.invokeBusy(!1),200===a.status||0===a.status?n.compression?r(Lm(Em(new Uint8Array(a.response)))):r(a.responseText):o({xhr:a,e:t}))},a.responseType=n.compression?&quot;arraybuffer&quot;:&quot;text&quot;,a.send()}))},fetchBinary:function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return t&&t.compression&&&quot;gz&quot;!==t.compression&&(zm(&quot;Supported algorithms are: [gz]&quot;),zm(`Unkown compression algorithm: ${t.compression}`)),new Promise(((n,r)=>{const o=jm(&quot;GET&quot;,e,t);o.onreadystatechange=e=>{4===o.readyState&&(200===o.status||0===o.status?t.compression?n(Em(new Uint8Array(o.response)).buffer):n(o.response):r({xhr:o,e:e}))},o.responseType=&quot;arraybuffer&quot;,o.send()}))},fetchImage:function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return new Promise(((e,r)=>{const o=new Image;n.crossOrigin&&(o.crossOrigin=n.crossOrigin),o.onload=()=>e(o),o.onerror=r,o.src=t}))}};Xg(&quot;http&quot;,(e=>Km));const{vtkDebugMacro:$m}=Wt,qm={position:[0,0,1],focalPoint:[0,0,0],viewUp:[0,1,0],directionOfProjection:[0,0,-1],parallelProjection:!1,useHorizontalViewAngle:!1,viewAngle:30,parallelScale:1,clippingRange:[.01,1000.01],windowCenter:[0,0],viewPlaneNormal:[0,0,1],useOffAxisProjection:!1,screenBottomLeft:[-.5,-.5,-.5],screenBottomRight:[.5,-.5,-.5],screenTopRight:[.5,.5,-.5],freezeFocalPoint:!1,projectionMatrix:null,viewMatrix:null,modelTransformMatrix:null,cameraLightTransform:u(),physicalTranslation:[0,0,0],physicalScale:1,physicalViewUp:[0,1,0],physicalViewNorth:[0,0,-1]};function Xm(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,qm,n),Wt.obj(e,t),Wt.get(e,t,[&quot;distance&quot;]),Wt.setGet(e,t,[&quot;parallelProjection&quot;,&quot;useHorizontalViewAngle&quot;,&quot;viewAngle&quot;,&quot;parallelScale&quot;,&quot;useOffAxisProjection&quot;,&quot;freezeFocalPoint&quot;,&quot;physicalScale&quot;]),Wt.getArray(e,t,[&quot;directionOfProjection&quot;,&quot;viewPlaneNormal&quot;,&quot;position&quot;,&quot;focalPoint&quot;]),Wt.setGetArray(e,t,[&quot;clippingRange&quot;,&quot;windowCenter&quot;],2),Wt.setGetArray(e,t,[&quot;viewUp&quot;,&quot;screenBottomLeft&quot;,&quot;screenBottomRight&quot;,&quot;screenTopRight&quot;,&quot;physicalTranslation&quot;,&quot;physicalViewUp&quot;,&quot;physicalViewNorth&quot;],3),function(e,t){t.classHierarchy.push(&quot;vtkCamera&quot;);const n=new Float64Array(3),r=new Float64Array([0,0,-1]),o=new Float64Array([0,1,0]),a=m(new Float64Array(16)),i=m(new Float64Array(16)),s=new Float64Array(3),l=new Float64Array(3),c=new Float64Array(3),u=m(new Float64Array(16)),d=m(new Float64Array(16)),f=new Float64Array(3),g=new Float64Array(3);function T(){t.viewPlaneNormal[0]=-t.directionOfProjection[0],t.viewPlaneNormal[1]=-t.directionOfProjection[1],t.viewPlaneNormal[2]=-t.directionOfProjection[2]}e.orthogonalizeViewUp=()=>{const n=e.getViewMatrix();t.viewUp[0]=n[4],t.viewUp[1]=n[5],t.viewUp[2]=n[6],e.modified()},e.setPosition=(n,r,o)=>{n===t.position[0]&&r===t.position[1]&&o===t.position[2]||(t.position[0]=n,t.position[1]=r,t.position[2]=o,e.computeDistance(),e.modified())},e.setFocalPoint=(n,r,o)=>{n===t.focalPoint[0]&&r===t.focalPoint[1]&&o===t.focalPoint[2]||(t.focalPoint[0]=n,t.focalPoint[1]=r,t.focalPoint[2]=o,e.computeDistance(),e.modified())},e.setDistance=n=>{if(t.distance===n)return;t.distance=n,t.distance<1e-20&&(t.distance=1e-20,$m(&quot;Distance is set to minimum.&quot;));const r=t.directionOfProjection;t.focalPoint[0]=t.position[0]+r[0]*t.distance,t.focalPoint[1]=t.position[1]+r[1]*t.distance,t.focalPoint[2]=t.position[2]+r[2]*t.distance,e.modified()},e.computeDistance=()=>{const e=t.focalPoint[0]-t.position[0],n=t.focalPoint[1]-t.position[1],r=t.focalPoint[2]-t.position[2];if(t.distance=Math.sqrt(e*e+n*n+r*r),t.distance<1e-20){t.distance=1e-20,$m(&quot;Distance is set to minimum.&quot;);const e=t.directionOfProjection;t.focalPoint[0]=t.position[0]+e[0]*t.distance,t.focalPoint[1]=t.position[1]+e[1]*t.distance,t.focalPoint[2]=t.position[2]+e[2]*t.distance}t.directionOfProjection[0]=e/t.distance,t.directionOfProjection[1]=n/t.distance,t.directionOfProjection[2]=r/t.distance,T()},e.dolly=n=>{if(n<=0)return;const r=t.distance/n;e.setPosition(t.focalPoint[0]-r*t.directionOfProjection[0],t.focalPoint[1]-r*t.directionOfProjection[1],t.focalPoint[2]-r*t.directionOfProjection[2])},e.roll=n=>{const r=t.position,o=t.focalPoint,a=t.viewUp,i=new Float64Array([a[0],a[1],a[2],0]);m(u);const s=new Float64Array([o[0]-r[0],o[1]-r[1],o[2]-r[2]]);S(u,u,vo(n),s),La(i,i,u),t.viewUp[0]=i[0],t.viewUp[1]=i[1],t.viewUp[2]=i[2],e.modified()},e.azimuth=n=>{const r=t.focalPoint;m(d),x(d,d,r),S(d,d,vo(n),t.viewUp),x(d,d,[-r[0],-r[1],-r[2]]),In(f,t.position,d),e.setPosition(f[0],f[1],f[2])},e.yaw=n=>{const r=t.position;m(d),x(d,d,r),S(d,d,vo(n),t.viewUp),x(d,d,[-r[0],-r[1],-r[2]]),In(g,t.focalPoint,d),e.setFocalPoint(g[0],g[1],g[2])},e.elevation=n=>{const r=t.focalPoint,o=e.getViewMatrix(),a=[-o[0],-o[1],-o[2]];m(d),x(d,d,r),S(d,d,vo(n),a),x(d,d,[-r[0],-r[1],-r[2]]),In(f,t.position,d),e.setPosition(f[0],f[1],f[2])},e.pitch=n=>{const r=t.position,o=e.getViewMatrix(),a=[o[0],o[1],o[2]];m(d),x(d,d,r),S(d,d,vo(n),a),x(d,d,[-r[0],-r[1],-r[2]]),In(g,t.focalPoint,d),e.setFocalPoint(...g)},e.zoom=n=>{n<=0||(t.parallelProjection?t.parallelScale/=n:t.viewAngle/=n,e.modified())},e.translate=(n,r,o)=>{const a=[n,r,o];Ro(t.position,a,t.position),Ro(t.focalPoint,a,t.focalPoint),e.computeDistance(),e.modified()},e.applyTransform=n=>{const r=[...t.viewUp,1],o=[],a=[],i=[];r[0]+=t.position[0],r[1]+=t.position[1],r[2]+=t.position[2],La(o,[...t.position,1],n),La(a,[...t.focalPoint,1],n),La(i,r,n),i[0]-=o[0],i[1]-=o[1],i[2]-=o[2],e.setPosition(...o.slice(0,3)),e.setFocalPoint(...a.slice(0,3)),e.setViewUp(...i.slice(0,3))},e.getThickness=()=>t.clippingRange[1]-t.clippingRange[0],e.setThickness=n=>{let r=n;r<1e-20&&(r=1e-20,$m(&quot;Thickness is set to minimum.&quot;)),e.setClippingRange(t.clippingRange[0],t.clippingRange[0]+r)},e.setThicknessFromFocalPoint=n=>{let r=n;r<1e-20&&(r=1e-20,$m(&quot;Thickness is set to minimum.&quot;)),e.setClippingRange(t.distance-r/2,t.distance+r/2)},e.setRoll=e=>{},e.getRoll=()=>{},e.setObliqueAngles=(e,t)=>{},e.getOrientation=()=>{},e.getOrientationWXYZ=()=>{},e.getFrustumPlanes=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:1,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:new Float64Array(24);const r=[[1,0,0,1],[-1,0,0,1],[0,1,0,1],[0,-1,0,1],[0,0,1,1],[0,0,-1,1]],o=e.getCompositeProjectionMatrix(t,-1,1);for(let e=0;e<6;e++)La(r[e],r[e],o),_o(r[e]),n[4*e+0]=r[e][0],n[4*e+1]=r[e][1],n[4*e+2]=r[e][2],n[4*e+3]=r[e][3];return n},e.getCameraLightTransformMatrix=e=>(p(e,t.cameraLightTransform),e),e.computeCameraLightTransform=()=>{p(a,e.getViewMatrix()),v(a,a),P(i,[t.distance,t.distance,t.distance]),b(a,a,i),m(t.cameraLightTransform),x(t.cameraLightTransform,a,[0,0,-1])},e.deepCopy=e=>{},e.physicalOrientationToWorldDirection=e=>{const t=_a(e[0],e[1],e[2],e[3]),n=Ba(),r=_a(0,0,1,0);var o,a;return a=t,(o=n)[0]=-a[0],o[1]=-a[1],o[2]=-a[2],o[3]=a[3],Fa(r,t,r),Fa(r,r,n),[r[0],r[1],r[2]]},e.getPhysicalToWorldMatrix=t=>{e.getWorldToPhysicalMatrix(t),v(t,t)},e.getWorldToPhysicalMatrix=e=>{m(e);const n=[3];Bo(t.physicalViewNorth,t.physicalViewUp,n),e[0]=n[0],e[1]=n[1],e[2]=n[2],e[4]=t.physicalViewUp[0],e[5]=t.physicalViewUp[1],e[6]=t.physicalViewUp[2],e[8]=-t.physicalViewNorth[0],e[9]=-t.physicalViewNorth[1],e[10]=-t.physicalViewNorth[2],h(e,e),hn(s,1/t.physicalScale,1/t.physicalScale,1/t.physicalScale),C(e,e,s),x(e,e,t.physicalTranslation)},e.computeViewParametersFromViewMatrix=i=>{v(a,i),In(s,n,a),e.computeDistance();const u=t.distance;e.setPosition(s[0],s[1],s[2]),In(l,r,a),Tn(l,l,s),Cn(l,l),e.setDirectionOfProjection(l[0],l[1],l[2]),In(c,o,a),Tn(c,c,s),Cn(c,c),e.setViewUp(c[0],c[1],c[2]),e.setDistance(u)},e.computeViewParametersFromPhysicalMatrix=t=>{e.getWorldToPhysicalMatrix(a),b(a,t,a),e.computeViewParametersFromViewMatrix(a)},e.setModelTransformMatrix=e=>{t.modelTransformMatrix=e},e.getModelTransformMatrix=()=>t.modelTransformMatrix,e.setViewMatrix=n=>{t.viewMatrix=n,t.viewMatrix&&(p(a,t.viewMatrix),e.computeViewParametersFromViewMatrix(a),h(t.viewMatrix,t.viewMatrix))},e.getViewMatrix=()=>{if(t.viewMatrix)return t.modelTransformMatrix?(b(a,t.viewMatrix,t.modelTransformMatrix),a):t.viewMatrix;X(a,t.position,t.focalPoint,t.viewUp),h(a,a);const e=new Float64Array(16);return t.modelTransformMatrix?b(e,a,t.modelTransformMatrix):p(e,a),e},e.setProjectionMatrix=e=>{t.projectionMatrix=e},e.getProjectionMatrix=(e,n,r)=>{const o=new Float64Array(16);if(m(o),t.projectionMatrix){const e=1/t.physicalScale;return hn(s,e,e,e),p(o,t.projectionMatrix),C(o,o,s),h(o,o),o}m(a);const i=t.clippingRange[1]-t.clippingRange[0],l=[t.clippingRange[0]+(n+1)*i/2,t.clippingRange[0]+(r+1)*i/2];if(t.parallelProjection){const n=t.parallelScale*e,r=t.parallelScale,o=(t.windowCenter[0]-1)*n,i=(t.windowCenter[0]+1)*n,s=(t.windowCenter[1]-1)*r,c=(t.windowCenter[1]+1)*r;$(a,o,i,s,c,l[0],l[1]),h(a,a)}else{if(t.useOffAxisProjection)throw new Error(&quot;Off-Axis projection is not supported at this time&quot;);{const n=Math.tan(vo(t.viewAngle)/2);let r,o;!0===t.useHorizontalViewAngle?(r=t.clippingRange[0]*n,o=t.clippingRange[0]*n/e):(r=t.clippingRange[0]*n*e,o=t.clippingRange[0]*n);const i=(t.windowCenter[0]-1)*r,s=(t.windowCenter[0]+1)*r,c=(t.windowCenter[1]-1)*o,u=(t.windowCenter[1]+1)*o,d=l[0],p=l[1];a[0]=2*d/(s-i),a[5]=2*d/(u-c),a[2]=(i+s)/(s-i),a[6]=(c+u)/(u-c),a[10]=-(d+p)/(p-d),a[14]=-1,a[11]=-2*d*p/(p-d),a[15]=0}}return p(o,a),o},e.getCompositeProjectionMatrix=(t,n,r)=>{const o=e.getViewMatrix(),a=e.getProjectionMatrix(t,n,r);return b(a,o,a),a},e.setDirectionOfProjection=(e,n,r)=>{if(t.directionOfProjection[0]===e&&t.directionOfProjection[1]===n&&t.directionOfProjection[2]===r)return;t.directionOfProjection[0]=e,t.directionOfProjection[1]=n,t.directionOfProjection[2]=r;const o=t.directionOfProjection;t.focalPoint[0]=t.position[0]+o[0]*t.distance,t.focalPoint[1]=t.position[1]+o[1]*t.distance,t.focalPoint[2]=t.position[2]+o[2]*t.distance,T()},e.setDeviceAngles=(n,r,o,a)=>{const i=[3];Bo(t.physicalViewNorth,t.physicalViewUp,i);const s=m(new Float64Array(16));S(s,s,vo(n),t.physicalViewUp),S(s,s,vo(r),i),S(s,s,vo(o),t.physicalViewNorth),S(s,s,vo(-a),t.physicalViewUp);const l=new Float64Array([-t.physicalViewUp[0],-t.physicalViewUp[1],-t.physicalViewUp[2]]),c=new Float64Array(t.physicalViewNorth);In(l,l,s),In(c,c,s),e.setDirectionOfProjection(l[0],l[1],l[2]),e.setViewUp(c[0],c[1],c[2]),e.modified()},e.setOrientationWXYZ=(t,n,r,o)=>{const a=m(new Float64Array(16));if(0!==t&&(0!==n||0!==r||0!==o)){const e=vo(t),i=Ba();Na(i,[n,r,o],e),G(a,i)}const i=new Float64Array(3);In(i,[0,0,-1],a);const s=new Float64Array(3);In(s,[0,1,0],a),e.setDirectionOfProjection(...i),e.setViewUp(...s),e.modified()},e.computeClippingRange=e=>{let n=null,r=null;n=t.viewPlaneNormal,r=t.position;const o=-n[0],a=-n[1],i=-n[2],s=-(o*r[0]+a*r[1]+i*r[2]),l=[o*e[0]+a*e[2]+i*e[4]+s,1e-18];for(let t=0;t<2;t++)for(let n=0;n<2;n++)for(let r=0;r<2;r++){const c=o*e[r]+a*e[2+n]+i*e[4+t]+s;l[0]=c<l[0]?c:l[0],l[1]=c>l[1]?c:l[1]}return l}}(e,t)}var Ym={newInstance:Wt.newInstance(Xm,&quot;vtkCamera&quot;),extend:Xm};const Zm={switch:!0,intensity:1,color:[1,1,1],position:[0,0,1],focalPoint:[0,0,0],positional:!1,exponent:1,coneAngle:30,coneFalloff:5,attenuationValues:[1,0,0],transformMatrix:null,lightType:&quot;SceneLight&quot;,shadowAttenuation:1,direction:[0,0,0],directionMTime:0};function Qm(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Zm,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;intensity&quot;,&quot;switch&quot;,&quot;positional&quot;,&quot;exponent&quot;,&quot;coneAngle&quot;,&quot;coneFalloff&quot;,&quot;transformMatrix&quot;,&quot;lightType&quot;,&quot;shadowAttenuation&quot;,&quot;attenuationValues&quot;]),Wt.setGetArray(e,t,[&quot;color&quot;,&quot;position&quot;,&quot;focalPoint&quot;,&quot;attenuationValues&quot;],3),function(e,t){t.classHierarchy.push(&quot;vtkLight&quot;);const n=new Float64Array(3);e.getTransformedPosition=()=>(t.transformMatrix?In(n,t.position,t.transformMatrix):hn(n,t.position[0],t.position[1],t.position[2]),n),e.getTransformedFocalPoint=()=>(t.transformMatrix?In(n,t.focalPoint,t.transformMatrix):hn(n,t.focalPoint[0],t.focalPoint[1],t.focalPoint[2]),n),e.getDirection=()=>(t.directionMTime<t.mtime&&(Rn(t.direction,t.focalPoint,t.position),Fo(t.direction),t.directionMTime=t.mtime),t.direction),e.setDirection=e=>{const n=new Float64Array(3);Rn(n,t.position,e),t.focalPoint=n},e.setDirectionAngle=(t,n)=>{const r=vo(t),o=vo(n);e.setPosition(Math.cos(r)*Math.sin(o),Math.sin(r),Math.cos(r)*Math.cos(o)),e.setFocalPoint(0,0,0),e.setPositional(0)},e.setLightTypeToHeadLight=()=>{e.setLightType(&quot;HeadLight&quot;)},e.setLightTypeToCameraLight=()=>{e.setLightType(&quot;CameraLight&quot;)},e.setLightTypeToSceneLight=()=>{e.setTransformMatrix(null),e.setLightType(&quot;SceneLight&quot;)},e.lightTypeIsHeadLight=()=>&quot;HeadLight&quot;===t.lightType,e.lightTypeIsSceneLight=()=>&quot;SceneLight&quot;===t.lightType,e.lightTypeIsCameraLight=()=>&quot;CameraLight&quot;===t.lightType}(e,t)}var Jm={newInstance:Wt.newInstance(Qm,&quot;vtkLight&quot;),extend:Qm,LIGHT_TYPES:[&quot;HeadLight&quot;,&quot;CameraLight&quot;,&quot;SceneLight&quot;]};const{vtkErrorMacro:eh}=Wt;const th={background:[0,0,0],background2:[.2,.2,.2],gradientBackground:!1,viewport:[0,0,1,1],aspect:[1,1],pixelAspect:[1,1],props:[],actors2D:[]};function nh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,th,n),Wt.obj(e,t),Wt.event(e,t,&quot;event&quot;),Wt.setGetArray(e,t,[&quot;viewport&quot;],4),Wt.setGetArray(e,t,[&quot;background&quot;,&quot;background2&quot;],3),function(e,t){function n(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];t.push(e);const r=e.getNestedProps();if(r&&r.length)for(let e=0;e<r.length;e++)n(r[e],t);return t}t.classHierarchy.push(&quot;vtkViewport&quot;),e.getViewProps=()=>t.props,e.hasViewProp=e=>t.props.includes(e),e.addViewProp=n=>{n&&!e.hasViewProp(n)&&t.props.push(n)},e.removeViewProp=e=>{const n=t.props.filter((t=>t!==e));t.props.length!==n.length&&(t.props=n)},e.removeAllViewProps=()=>{t.props=[]},e.getViewPropsWithNestedProps=()=>{let r=[];const o=e.getActors2D();o.sort(((e,t)=>e.getLayerNumber()-t.getLayerNumber()));const a=t.props.filter((e=>!o.includes(e)));for(let e=0;e<a.length;e++)n(a[e],r);return r=r.concat(o),r},e.addActor2D=e.addViewProp,e.removeActor2D=t=>{e.removeViewProp(t)},e.getActors2D=()=>(t.actors2D=[],t.props.forEach((e=>{t.actors2D=t.actors2D.concat(e.getActors2D())})),t.actors2D),e.displayToView=()=>eh(&quot;call displayToView on your view instead&quot;),e.viewToDisplay=()=>eh(&quot;callviewtodisplay on your view instead&quot;),e.getSize=()=>eh(&quot;call getSize on your View instead&quot;),e.normalizedDisplayToProjection=(t,n,r)=>{const o=e.normalizedDisplayToNormalizedViewport(t,n,r);return e.normalizedViewportToProjection(o[0],o[1],o[2])},e.normalizedDisplayToNormalizedViewport=(e,n,r)=>{const o=[t.viewport[2]-t.viewport[0],t.viewport[3]-t.viewport[1]];return[(e-t.viewport[0])/o[0],(n-t.viewport[1])/o[1],r]},e.normalizedViewportToProjection=(e,t,n)=>[2*e-1,2*t-1,2*n-1],e.projectionToNormalizedDisplay=(t,n,r)=>{const o=e.projectionToNormalizedViewport(t,n,r);return e.normalizedViewportToNormalizedDisplay(o[0],o[1],o[2])},e.normalizedViewportToNormalizedDisplay=(e,n,r)=>{const o=[t.viewport[2]-t.viewport[0],t.viewport[3]-t.viewport[1]];return[e*o[0]+t.viewport[0],n*o[1]+t.viewport[1],r]},e.projectionToNormalizedViewport=(e,t,n)=>[.5*(e+1),.5*(t+1),.5*(n+1)],e.PickPropFrom=()=>eh(&quot;vtkViewport::PickPropFrom - NOT IMPLEMENTED&quot;)}(e,t)}var rh={newInstance:Wt.newInstance(nh,&quot;vtkViewport&quot;),extend:nh};const{vtkDebugMacro:oh,vtkErrorMacro:ah,vtkWarningMacro:ih}=Ht;function sh(e){return()=>ah(`vtkRenderer::${e} - NOT IMPLEMENTED`)}const lh={pickedProp:null,activeCamera:null,allBounds:[],ambient:[1,1,1],allocatedRenderTime:100,timeFactor:1,automaticLightCreation:!0,twoSidedLighting:!0,lastRenderTimeInSeconds:-1,renderWindow:null,lights:[],actors:[],volumes:[],lightFollowCamera:!0,numberOfPropsRendered:0,propArray:null,pathArray:null,layer:0,preserveColorBuffer:!1,preserveDepthBuffer:!1,computeVisiblePropBounds:Pa(),interactive:!0,nearClippingPlaneTolerance:0,clippingRangeExpansion:.05,erase:!0,draw:!0,useShadows:!1,useDepthPeeling:!1,occlusionRatio:0,maximumNumberOfPeels:4,selector:null,delegate:null,texturedBackground:!1,backgroundTexture:null,environmentTexture:null,environmentTextureDiffuseStrength:1,environmentTextureSpecularStrength:1,useEnvironmentTextureAsBackground:!1,pass:0};function ch(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};for(Object.assign(t,lh,n),rh.extend(e,t,n),t.background||(t.background=[0,0,0,1]);t.background.length<3;)t.background.push(0);3===t.background.length&&t.background.push(1),Tt(e,t,[&quot;_renderWindow&quot;,&quot;allocatedRenderTime&quot;,&quot;timeFactor&quot;,&quot;lastRenderTimeInSeconds&quot;,&quot;numberOfPropsRendered&quot;,&quot;lastRenderingUsedDepthPeeling&quot;,&quot;selector&quot;]),Ct(e,t,[&quot;twoSidedLighting&quot;,&quot;lightFollowCamera&quot;,&quot;automaticLightCreation&quot;,&quot;erase&quot;,&quot;draw&quot;,&quot;nearClippingPlaneTolerance&quot;,&quot;clippingRangeExpansion&quot;,&quot;backingStore&quot;,&quot;interactive&quot;,&quot;layer&quot;,&quot;preserveColorBuffer&quot;,&quot;preserveDepthBuffer&quot;,&quot;useDepthPeeling&quot;,&quot;occlusionRatio&quot;,&quot;maximumNumberOfPeels&quot;,&quot;delegate&quot;,&quot;backgroundTexture&quot;,&quot;texturedBackground&quot;,&quot;environmentTexture&quot;,&quot;environmentTextureDiffuseStrength&quot;,&quot;environmentTextureSpecularStrength&quot;,&quot;useEnvironmentTextureAsBackground&quot;,&quot;useShadows&quot;,&quot;pass&quot;]),St(e,t,[&quot;actors&quot;,&quot;volumes&quot;,&quot;lights&quot;]),It(e,t,[&quot;background&quot;],4,1),wt(0,t,[&quot;renderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkRenderer&quot;);const n={type:&quot;ComputeVisiblePropBoundsEvent&quot;,renderer:e},r={type:&quot;ResetCameraClippingRangeEvent&quot;,renderer:e},o={type:&quot;ResetCameraEvent&quot;,renderer:e};e.updateCamera=()=>(t.activeCamera||(oh(&quot;No cameras are on, creating one.&quot;),e.getActiveCameraAndResetIfCreated()),t.activeCamera.render(e),!0),e.updateLightsGeometryToFollowCamera=()=>{const n=e.getActiveCameraAndResetIfCreated();t.lights.forEach((e=>{e.lightTypeIsSceneLight()||(e.lightTypeIsHeadLight()?(e.setPositionFrom(n.getPositionByReference()),e.setFocalPointFrom(n.getFocalPointByReference()),e.modified(n.getMTime())):e.lightTypeIsCameraLight()?e.setTransformMatrix(n.getCameraLightTransformMatrix(u())):ah(&quot;light has unknown light type&quot;,e.get()))}))},e.updateLightGeometry=()=>!t.lightFollowCamera||e.updateLightsGeometryToFollowCamera(),e.allocateTime=sh(&quot;allocateTime&quot;),e.updateGeometry=sh(&quot;updateGeometry&quot;),e.getVTKWindow=()=>t._renderWindow,e.setLayer=n=>{oh(e.getClassName(),e,&quot;setting Layer to &quot;,n),t.layer!==n&&(t.layer=n,e.modified()),e.setPreserveColorBuffer(!!n)},e.setActiveCamera=n=>t.activeCamera!==n&&(t.activeCamera=n,e.modified(),e.invokeEvent({type:&quot;ActiveCameraEvent&quot;,camera:n}),!0),e.makeCamera=()=>{const t=Ym.newInstance();return e.invokeEvent({type:&quot;CreateCameraEvent&quot;,camera:t}),t},e.getActiveCamera=()=>(t.activeCamera||(t.activeCamera=e.makeCamera()),t.activeCamera),e.getActiveCameraAndResetIfCreated=()=>(t.activeCamera||(e.getActiveCamera(),e.resetCamera()),t.activeCamera),e.getActors=()=>(t.actors=[],t.props.forEach((e=>{t.actors=t.actors.concat(e.getActors())})),t.actors),e.addActor=e.addViewProp,e.removeActor=n=>{t.actors=t.actors.filter((e=>e!==n)),e.removeViewProp(n),e.modified()},e.removeAllActors=()=>{e.getActors().forEach((t=>{e.removeViewProp(t)})),t.actors=[],e.modified()},e.getVolumes=()=>(t.volumes=[],t.props.forEach((e=>{t.volumes=t.volumes.concat(e.getVolumes())})),t.volumes),e.addVolume=e.addViewProp,e.removeVolume=n=>{t.volumes=t.volumes.filter((e=>e!==n)),e.removeViewProp(n),e.modified()},e.removeAllVolumes=()=>{e.getVolumes().forEach((t=>{e.removeViewProp(t)})),t.volumes=[],e.modified()},e.hasLight=e=>t.lights.includes(e),e.addLight=n=>{n&&!e.hasLight(n)&&(t.lights.push(n),e.modified())},e.removeLight=n=>{t.lights=t.lights.filter((e=>e!==n)),e.modified()},e.removeAllLights=()=>{t.lights=[],e.modified()},e.setLightCollection=n=>{t.lights=n,e.modified()},e.makeLight=Jm.newInstance,e.createLight=()=>{t.automaticLightCreation&&(t._createdLight&&(e.removeLight(t._createdLight),t._createdLight.delete(),t._createdLight=null),t._createdLight=e.makeLight(),e.addLight(t._createdLight),t._createdLight.setLightTypeToHeadLight(),t._createdLight.setPosition(e.getActiveCamera().getPosition()),t._createdLight.setFocalPoint(e.getActiveCamera().getFocalPoint()))},e.normalizedDisplayToWorld=(t,n,r,o)=>{let a=e.normalizedDisplayToProjection(t,n,r);return a=e.projectionToView(a[0],a[1],a[2],o),e.viewToWorld(a[0],a[1],a[2])},e.worldToNormalizedDisplay=(t,n,r,o)=>{let a=e.worldToView(t,n,r);return a=e.viewToProjection(a[0],a[1],a[2],o),e.projectionToNormalizedDisplay(a[0],a[1],a[2])},e.viewToWorld=(e,n,r)=>{if(null===t.activeCamera)return ah(&quot;ViewToWorld: no active camera, cannot compute view to world, returning 0,0,0&quot;),[0,0,0];const o=t.activeCamera.getViewMatrix();v(o,o),h(o,o);const a=new Float64Array([e,n,r]);return In(a,a,o),a},e.projectionToView=(e,n,r,o)=>{if(null===t.activeCamera)return ah(&quot;ProjectionToView: no active camera, cannot compute projection to view, returning 0,0,0&quot;),[0,0,0];const a=t.activeCamera.getProjectionMatrix(o,-1,1);v(a,a),h(a,a);const i=new Float64Array([e,n,r]);return In(i,i,a),i},e.worldToView=(e,n,r)=>{if(null===t.activeCamera)return ah(&quot;WorldToView: no active camera, cannot compute view to world, returning 0,0,0&quot;),[0,0,0];const o=t.activeCamera.getViewMatrix();h(o,o);const a=new Float64Array([e,n,r]);return In(a,a,o),a},e.viewToProjection=(e,n,r,o)=>{if(null===t.activeCamera)return ah(&quot;ViewToProjection: no active camera, cannot compute view to projection, returning 0,0,0&quot;),[0,0,0];const a=t.activeCamera.getProjectionMatrix(o,-1,1);h(a,a);const i=new Float64Array([e,n,r]);return In(i,i,a),i},e.computeVisiblePropBounds=()=>{t.allBounds[0]=Gi.INIT_BOUNDS[0],t.allBounds[1]=Gi.INIT_BOUNDS[1],t.allBounds[2]=Gi.INIT_BOUNDS[2],t.allBounds[3]=Gi.INIT_BOUNDS[3],t.allBounds[4]=Gi.INIT_BOUNDS[4],t.allBounds[5]=Gi.INIT_BOUNDS[5];let r=!0;e.invokeEvent(n);for(let e=0;e<t.props.length;++e){const n=t.props[e];if(n.getVisibility()&&n.getUseBounds()){const e=n.getBounds();e&&ya(e)&&(r=!1,e[0]<t.allBounds[0]&&(t.allBounds[0]=e[0]),e[1]>t.allBounds[1]&&(t.allBounds[1]=e[1]),e[2]<t.allBounds[2]&&(t.allBounds[2]=e[2]),e[3]>t.allBounds[3]&&(t.allBounds[3]=e[3]),e[4]<t.allBounds[4]&&(t.allBounds[4]=e[4]),e[5]>t.allBounds[5]&&(t.allBounds[5]=e[5]))}}return r&&(Ta(t.allBounds),oh(&quot;Can't compute bounds, no 3D props are visible&quot;)),t.allBounds},e.resetCamera=function(){const n=(arguments.length>0&&void 0!==arguments[0]?arguments[0]:null)||e.computeVisiblePropBounds(),r=[0,0,0];if(!ya(n))return oh(&quot;Cannot reset camera!&quot;),!1;let a=null;if(!e.getActiveCamera())return ah(&quot;Trying to reset non-existent camera&quot;),!1;a=t.activeCamera.getViewPlaneNormal(),t.activeCamera.setViewAngle(30),r[0]=(n[0]+n[1])/2,r[1]=(n[2]+n[3])/2,r[2]=(n[4]+n[5])/2;let i=n[1]-n[0],s=n[3]-n[2],l=n[5]-n[4];i*=i,s*=s,l*=l;let c=i+s+l;c=0===c?1:c,c=.5*Math.sqrt(c);const u=vo(t.activeCamera.getViewAngle()),d=c,p=c/Math.sin(.5*u),f=t.activeCamera.getViewUp();return Math.abs(Lo(f,a))>.999&&(ih(&quot;Resetting view-up since view plane normal is parallel&quot;),t.activeCamera.setViewUp(-f[2],f[0],f[1])),t.activeCamera.setFocalPoint(r[0],r[1],r[2]),t.activeCamera.setPosition(r[0]+p*a[0],r[1]+p*a[1],r[2]+p*a[2]),e.resetCameraClippingRange(n),t.activeCamera.setParallelScale(d),t.activeCamera.setPhysicalScale(c),t.activeCamera.setPhysicalTranslation(-r[0],-r[1],-r[2]),e.invokeEvent(o),!0},e.resetCameraClippingRange=function(){const n=(arguments.length>0&&void 0!==arguments[0]?arguments[0]:null)||e.computeVisiblePropBounds();if(!ya(n))return oh(&quot;Cannot reset camera clipping range!&quot;),!1;if(e.getActiveCameraAndResetIfCreated(),!t.activeCamera)return ah(&quot;Trying to reset clipping range of non-existent camera&quot;),!1;const o=t.activeCamera.computeClippingRange(n);let a=0;if(t.activeCamera.getParallelProjection())a=.2*t.activeCamera.getParallelScale();else{const e=vo(t.activeCamera.getViewAngle());a=.2*Math.tan(e/2)*o[1]}return o[1]-o[0]<a&&(a=a-o[1]+o[0],o[1]+=a/2,o[0]-=a/2),o[0]<0&&(o[0]=0),o[0]=.99*o[0]-(o[1]-o[0])*t.clippingRangeExpansion,o[1]=1.01*o[1]+(o[1]-o[0])*t.clippingRangeExpansion,o[0]=o[0]>=o[1]?.01*o[1]:o[0],t.nearClippingPlaneTolerance||(t.nearClippingPlaneTolerance=.01),o[0]<t.nearClippingPlaneTolerance*o[1]&&(o[0]=t.nearClippingPlaneTolerance*o[1]),t.activeCamera.setClippingRange(o[0],o[1]),e.invokeEvent(r),!1},e.setRenderWindow=e=>{e!==t._renderWindow&&(t._vtkWindow=e,t._renderWindow=e)},e.visibleActorCount=()=>t.props.filter((e=>e.getVisibility())).length,e.visibleVolumeCount=e.visibleActorCount,e.getMTime=()=>{let e=t.mtime;const n=t.activeCamera?t.activeCamera.getMTime():0;n>e&&(e=n);const r=t._createdLight?t._createdLight.getMTime():0;return r>e&&(e=r),e},e.getTransparent=()=>!!t.preserveColorBuffer,e.isActiveCameraCreated=()=>!!t.activeCamera}(e,t)}var uh={newInstance:Mt(ch,&quot;vtkRenderer&quot;),extend:ch};const dh=Object.create(null);function ph(e,t){dh[e]=t}function fh(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return dh[e]&&dh[e](t)}const gh={defaultViewAPI:&quot;WebGL&quot;,renderers:[],views:[],interactor:null,neverRendered:!0,numberOfLayers:1,childRenderWindows:[]};function mh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,gh,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;interactor&quot;,&quot;numberOfLayers&quot;,&quot;_views&quot;,&quot;defaultViewAPI&quot;]),Wt.get(e,t,[&quot;neverRendered&quot;]),Wt.getArray(e,t,[&quot;renderers&quot;,&quot;childRenderWindows&quot;]),Wt.moveToProtected(e,t,[&quot;views&quot;]),Wt.event(e,t,&quot;completion&quot;),function(e,t){t.classHierarchy.push(&quot;vtkRenderWindow&quot;),e.addRenderer=n=>{e.hasRenderer(n)||(n.setRenderWindow(e),t.renderers.push(n),e.modified())},e.removeRenderer=n=>{t.renderers=t.renderers.filter((e=>e!==n)),e.modified()},e.hasRenderer=e=>-1!==t.renderers.indexOf(e),e.newAPISpecificView=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return fh(e||t.defaultViewAPI,n)},e.addView=n=>{e.hasView(n)||(n.setRenderable(e),t._views.push(n),e.modified())},e.removeView=n=>{t._views=t._views.filter((e=>e!==n)),e.modified()},e.hasView=e=>-1!==t._views.indexOf(e),e.preRender=()=>{t.renderers.forEach((e=>{e.isActiveCameraCreated()||e.resetCamera()}))},e.render=()=>{e.preRender(),t.interactor?t.interactor.render():t._views.forEach((e=>e.traverseAllPasses()))},e.getStatistics=()=>{const e={propCount:0,invisiblePropCount:0,gpuMemoryMB:0};return t._views.forEach((t=>{t.getGraphicsMemoryInfo&&(e.gpuMemoryMB+=t.getGraphicsMemoryInfo()/1e6)})),t.renderers.forEach((n=>{const r=n.getViewProps(),o=t._views[0].getViewNodeFor(n);r.forEach((t=>{if(t.getVisibility()){e.propCount+=1;const n=t.getMapper&&t.getMapper();if(n&&n.getPrimitiveCount){const t=o.getViewNodeFor(n);if(t){t.getAllocatedGPUMemoryInBytes&&(e.gpuMemoryMB+=t.getAllocatedGPUMemoryInBytes()/1e6);const r=n.getPrimitiveCount();Object.keys(r).forEach((t=>{e[t]||(e[t]=0),e[t]+=r[t]}))}}}else e.invisiblePropCount+=1}))})),e.str=Object.keys(e).map((t=>`${t}: ${e[t]}`)).join(&quot;\\n&quot;),e},e.captureImages=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;image/png&quot;,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return Wt.setImmediate(e.render),t._views.map((e=>e.captureNextImage?e.captureNextImage(n,r):void 0)).filter((e=>!!e))},e.addRenderWindow=n=>!t.childRenderWindows.includes(n)&&(t.childRenderWindows.push(n),e.modified(),!0),e.removeRenderWindow=n=>{const r=t.childRenderWindows.findIndex((e=>e===n));return!(r<0||(t.childRenderWindows.splice(r,1),e.modified(),0))}}(e,t)}var hh={newInstance:Wt.newInstance(mh,&quot;vtkRenderWindow&quot;),extend:mh,registerViewConstructor:ph,listViewAPIs:function(){return Object.keys(dh)},newAPISpecificView:fh};const vh={Unknown:0,LeftController:1,RightController:2},Th={Unknown:0,Trigger:1,TrackPad:2,Grip:3,Thumbstick:4,A:5,B:6,ApplicationMenu:7};var yh={Device:vh,Input:Th,Axis:{Unknown:0,TouchpadX:1,TouchpadY:2,ThumbstickX:3,ThumbstickY:4},MouseButton:{LeftButton:1,MiddleButton:2,RightButton:3}};const{Device:bh,Input:xh}=yh,{vtkWarningMacro:Ch,vtkErrorMacro:Sh,normalizeWheel:Ah,vtkOnceErrorMacro:Ih}=Wt,wh={ctrlKey:!1,altKey:!1,shiftKey:!1},Oh={&quot;xr-standard&quot;:[xh.Trigger,xh.Grip,xh.TrackPad,xh.Thumbstick,xh.A,xh.B]},Ph=[&quot;StartAnimation&quot;,&quot;Animation&quot;,&quot;EndAnimation&quot;,&quot;PointerEnter&quot;,&quot;PointerLeave&quot;,&quot;MouseEnter&quot;,&quot;MouseLeave&quot;,&quot;StartMouseMove&quot;,&quot;MouseMove&quot;,&quot;EndMouseMove&quot;,&quot;LeftButtonPress&quot;,&quot;LeftButtonRelease&quot;,&quot;MiddleButtonPress&quot;,&quot;MiddleButtonRelease&quot;,&quot;RightButtonPress&quot;,&quot;RightButtonRelease&quot;,&quot;KeyPress&quot;,&quot;KeyDown&quot;,&quot;KeyUp&quot;,&quot;StartMouseWheel&quot;,&quot;MouseWheel&quot;,&quot;EndMouseWheel&quot;,&quot;StartPinch&quot;,&quot;Pinch&quot;,&quot;EndPinch&quot;,&quot;StartPan&quot;,&quot;Pan&quot;,&quot;EndPan&quot;,&quot;StartRotate&quot;,&quot;Rotate&quot;,&quot;EndRotate&quot;,&quot;Button3D&quot;,&quot;Move3D&quot;,&quot;StartPointerLock&quot;,&quot;EndPointerLock&quot;,&quot;StartInteraction&quot;,&quot;Interaction&quot;,&quot;EndInteraction&quot;,&quot;AnimationFrameRateUpdate&quot;];function Rh(e){e.cancelable&&e.preventDefault()}function Mh(e){const t=Object.create(null);return e.forEach((e=>{let{pointerId:n,position:r}=e;t[n]=r})),t}const Eh={renderWindow:null,interactorStyle:null,picker:null,pickingManager:null,initialized:!1,enabled:!1,enableRender:!0,currentRenderer:null,lightFollowCamera:!0,desiredUpdateRate:30,stillUpdateRate:2,container:null,recognizeGestures:!0,currentGesture:&quot;Start&quot;,animationRequest:null,lastFrameTime:.1,recentAnimationFrameRate:10,wheelTimeoutID:0,moveTimeoutID:0,lastGamepadValues:{},preventDefaultOnPointerDown:!1,preventDefaultOnPointerUp:!1,mouseScrollDebounceByPass:!1};function Vh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Eh,n),Wt.obj(e,t),t._animationExtendedEnd=0,Wt.event(e,t,&quot;RenderEvent&quot;),Ph.forEach((n=>Wt.event(e,t,n))),Wt.get(e,t,[&quot;initialized&quot;,&quot;interactorStyle&quot;,&quot;lastFrameTime&quot;,&quot;recentAnimationFrameRate&quot;,&quot;_view&quot;]),Wt.setGet(e,t,[&quot;container&quot;,&quot;lightFollowCamera&quot;,&quot;enabled&quot;,&quot;enableRender&quot;,&quot;recognizeGestures&quot;,&quot;desiredUpdateRate&quot;,&quot;stillUpdateRate&quot;,&quot;picker&quot;,&quot;preventDefaultOnPointerDown&quot;,&quot;preventDefaultOnPointerUp&quot;,&quot;mouseScrollDebounceByPass&quot;]),Wt.moveToProtected(e,t,[&quot;view&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkRenderWindowInteractor&quot;);const n={...e},r=new Set,o=new Map;let a=1;function i(n,r){t._forcedRenderer||(t.currentRenderer=e.findPokedRenderer(n,r))}e.start=()=>{(t.initialized||(e.initialize(),t.initialized))&&e.startEventLoop()},e.setRenderWindow=e=>{Sh(&quot;you want to call setView(view) instead of setRenderWindow on a vtk.js interactor&quot;)},e.setInteractorStyle=n=>{t.interactorStyle!==n&&(null!=t.interactorStyle&&t.interactorStyle.setInteractor(null),t.interactorStyle=n,null!=t.interactorStyle&&t.interactorStyle.getInteractor()!==e&&t.interactorStyle.setInteractor(e))},e.initialize=()=>{t.initialized=!0,e.enable(),e.render()},e.enable=()=>e.setEnabled(!0),e.disable=()=>e.setEnabled(!1),e.startEventLoop=()=>Ch(&quot;empty event loop&quot;),e.getCurrentRenderer=()=>(t.currentRenderer||i(0,0),t.currentRenderer);const s=t._getScreenEventPositionFor||function(e){const n=t._view.getCanvas(),r=n.getBoundingClientRect(),a=n.width/r.width,s=n.height/r.height,l={x:a*(e.clientX-r.left),y:s*(r.height-e.clientY+r.top),z:0,movementX:a*e.movementX,movementY:s*e.movementY};return(o.size<=1||!t.currentRenderer)&&i(l.x,l.y),l};function l(e){return{controlKey:e.ctrlKey,altKey:e.altKey,shiftKey:e.shiftKey}}function c(e){const t=l(e);return{key:e.key,keyCode:e.charCode,...t}}function u(e){return e.pointerType||&quot;&quot;}const d=()=>{if(null===t.container)return;const{container:n}=t;n.addEventListener(&quot;contextmenu&quot;,Rh),n.addEventListener(&quot;wheel&quot;,e.handleWheel),n.addEventListener(&quot;DOMMouseScroll&quot;,e.handleWheel),n.addEventListener(&quot;pointerenter&quot;,e.handlePointerEnter),n.addEventListener(&quot;pointerleave&quot;,e.handlePointerLeave),n.addEventListener(&quot;pointermove&quot;,e.handlePointerMove,{passive:!1}),n.addEventListener(&quot;pointerdown&quot;,e.handlePointerDown,{passive:!1}),n.addEventListener(&quot;pointerup&quot;,e.handlePointerUp),n.addEventListener(&quot;pointercancel&quot;,e.handlePointerCancel),n.addEventListener(&quot;keypress&quot;,e.handleKeyPress),n.addEventListener(&quot;keydown&quot;,e.handleKeyDown),document.addEventListener(&quot;keyup&quot;,e.handleKeyUp),document.addEventListener(&quot;pointerlockchange&quot;,e.handlePointerLockChange),n.tabIndex=0,n.style.touchAction=&quot;none&quot;,n.style.userSelect=&quot;none&quot;,n.style.webkitTapHighlightColor=&quot;rgba(0,0,0,0)&quot;};e.bindEvents=e=>{null!==e&&n.setContainer(e)&&d()};const p=()=>{clearTimeout(t.moveTimeoutID),clearTimeout(t.wheelTimeoutID),t.moveTimeoutID=0,t.wheelTimeoutID=0,a=1;const{container:n}=t;n&&(n.removeEventListener(&quot;contextmenu&quot;,Rh),n.removeEventListener(&quot;wheel&quot;,e.handleWheel),n.removeEventListener(&quot;DOMMouseScroll&quot;,e.handleWheel),n.removeEventListener(&quot;pointerenter&quot;,e.handlePointerEnter),n.removeEventListener(&quot;pointerleave&quot;,e.handlePointerLeave),n.removeEventListener(&quot;pointermove&quot;,e.handlePointerMove,{passive:!1}),n.removeEventListener(&quot;pointerdown&quot;,e.handlePointerDown,{passive:!1}),n.removeEventListener(&quot;pointerup&quot;,e.handlePointerUp),n.removeEventListener(&quot;pointercancel&quot;,e.handlePointerCancel),n.removeEventListener(&quot;keypress&quot;,e.handleKeyPress),n.removeEventListener(&quot;keydown&quot;,e.handleKeyDown)),document.removeEventListener(&quot;keyup&quot;,e.handleKeyUp),document.removeEventListener(&quot;pointerlockchange&quot;,e.handlePointerLockChange),o.clear()};function f(){t._view&&t.enabled&&t.enableRender&&(t.inRender=!0,t._view.traverseAllPasses(),t.inRender=!1),e.invokeRenderEvent()}e.unbindEvents=()=>{p(),n.setContainer(null)},e.handleKeyPress=t=>{const n=c(t);e.keyPressEvent(n)},e.handleKeyDown=t=>{const n=c(t);e.keyDownEvent(n)},e.handleKeyUp=t=>{const n=c(t);e.keyUpEvent(n)},e.handlePointerEnter=t=>{const n={...l(t),position:s(t),deviceType:u(t)};e.pointerEnterEvent(n),&quot;mouse&quot;===n.deviceType&&e.mouseEnterEvent(n)},e.handlePointerLeave=t=>{const n={...l(t),position:s(t),deviceType:u(t)};e.pointerLeaveEvent(n),&quot;mouse&quot;===n.deviceType&&e.mouseLeaveEvent(n)},e.handlePointerDown=n=>{if(!(n.button>2||e.isPointerLocked()))switch(t.preventDefaultOnPointerDown&&Rh(n),n.target.hasPointerCapture(n.pointerId)&&n.target.releasePointerCapture(n.pointerId),t.container.setPointerCapture(n.pointerId),o.has(n.pointerId)&&Ch(&quot;[RenderWindowInteractor] duplicate pointerId detected&quot;),o.set(n.pointerId,{pointerId:n.pointerId,position:s(n)}),n.pointerType){case&quot;pen&quot;:case&quot;touch&quot;:e.handleTouchStart(n);break;default:e.handleMouseDown(n)}},e.handlePointerUp=n=>{if(o.has(n.pointerId))switch(t.preventDefaultOnPointerUp&&Rh(n),o.delete(n.pointerId),t.container.releasePointerCapture(n.pointerId),n.pointerType){case&quot;pen&quot;:case&quot;touch&quot;:e.handleTouchEnd(n);break;default:e.handleMouseUp(n)}},e.handlePointerCancel=t=>{if(o.has(t.pointerId))switch(o.delete(t.pointerId),t.pointerType){case&quot;pen&quot;:case&quot;touch&quot;:e.handleTouchEnd(t);break;default:e.handleMouseUp(t)}},e.handlePointerMove=t=>{switch(o.has(t.pointerId)&&(o.get(t.pointerId).position=s(t)),t.pointerType){case&quot;pen&quot;:case&quot;touch&quot;:e.handleTouchMove(t);break;default:e.handleMouseMove(t)}},e.handleMouseDown=t=>{const n={...l(t),position:s(t),deviceType:u(t)};switch(t.button){case 0:e.leftButtonPressEvent(n);break;case 1:e.middleButtonPressEvent(n);break;case 2:e.rightButtonPressEvent(n);break;default:Sh(`Unknown mouse button pressed: ${t.button}`)}},e.requestPointerLock=()=>{t.container&&t.container.requestPointerLock()},e.exitPointerLock=()=>document.exitPointerLock?.(),e.isPointerLocked=()=>!!t.container&&document.pointerLockElement===t.container,e.handlePointerLockChange=()=>{e.isPointerLocked()?e.startPointerLockEvent():e.endPointerLockEvent()},e.requestAnimation=n=>{void 0!==n?r.has(n)?Ch(&quot;requester is already registered for animating&quot;):(r.add(n),t.animationRequest||1!==r.size||t.xrAnimation||(t._animationStartTime=Date.now(),t._animationFrameCount=0,t.animationRequest=requestAnimationFrame(e.handleAnimation),e.startAnimationEvent())):Sh(&quot;undefined requester, can not start animating&quot;)},e.extendAnimation=n=>{const o=Date.now()+n;t._animationExtendedEnd=Math.max(t._animationExtendedEnd,o),t.animationRequest||0!==r.size||t.xrAnimation||(t._animationStartTime=Date.now(),t._animationFrameCount=0,t.animationRequest=requestAnimationFrame(e.handleAnimation),e.startAnimationEvent())},e.isAnimating=()=>t.xrAnimation||null!==t.animationRequest,e.cancelAnimation=function(n){let o=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(r.has(n))r.delete(n),t.animationRequest&&0===r.size&&Date.now()>t._animationExtendedEnd&&(cancelAnimationFrame(t.animationRequest),t.animationRequest=null,e.endAnimationEvent(),e.render());else if(!o){const e=n&&n.getClassName?n.getClassName():n;Ch(`${e} did not request an animation`)}},e.switchToXRAnimation=()=>{t.animationRequest&&(cancelAnimationFrame(t.animationRequest),t.animationRequest=null),t.xrAnimation=!0},e.returnFromXRAnimation=()=>{t.xrAnimation=!1,0!==r.size&&(t.recentAnimationFrameRate=10,t.animationRequest=requestAnimationFrame(e.handleAnimation))},e.updateXRGamepads=(n,r,o)=>{n.inputSources.forEach((n=>{const a=null==n.gripSpace?null:r.getPose(n.gripSpace,o),i=null==n.gripSpace?null:r.getPose(n.targetRaySpace,o),s=n.gamepad,l=n.handedness;if(s){s.index in t.lastGamepadValues||(t.lastGamepadValues[s.index]={left:{buttons:{}},right:{buttons:{}},none:{buttons:{}}});for(let r=0;r<s.buttons.length;++r)r in t.lastGamepadValues[s.index][l].buttons||(t.lastGamepadValues[s.index][l].buttons[r]=!1),t.lastGamepadValues[s.index][l].buttons[r]!==s.buttons[r].pressed&&null!=a&&(e.button3DEvent({gamepad:s,position:a.transform.position,orientation:a.transform.orientation,targetPosition:i.transform.position,targetOrientation:i.transform.orientation,pressed:s.buttons[r].pressed,device:&quot;left&quot;===n.handedness?bh.LeftController:bh.RightController,input:Oh[s.mapping]&&Oh[s.mapping][r]?Oh[s.mapping][r]:xh.Trigger}),t.lastGamepadValues[s.index][l].buttons[r]=s.buttons[r].pressed),t.lastGamepadValues[s.index][l].buttons[r]&&null!=a&&e.move3DEvent({gamepad:s,position:a.transform.position,orientation:a.transform.orientation,targetPosition:i.transform.position,targetOrientation:i.transform.orientation,device:&quot;left&quot;===n.handedness?bh.LeftController:bh.RightController})}}))},e.handleMouseMove=n=>{const r={...l(n),position:s(n),deviceType:u(n)};0===t.moveTimeoutID?e.startMouseMoveEvent(r):(e.mouseMoveEvent(r),clearTimeout(t.moveTimeoutID)),t.moveTimeoutID=setTimeout((()=>{e.endMouseMoveEvent(),t.moveTimeoutID=0}),200)},e.handleAnimation=()=>{const n=Date.now();t._animationFrameCount++,n-t._animationStartTime>1e3&&t._animationFrameCount>1&&(t.recentAnimationFrameRate=1e3*(t._animationFrameCount-1)/(n-t._animationStartTime),t.lastFrameTime=1/t.recentAnimationFrameRate,e.animationFrameRateUpdateEvent(),t._animationStartTime=n,t._animationFrameCount=1),e.animationEvent(),f(),r.size>0||Date.now()<t._animationExtendedEnd?t.animationRequest=requestAnimationFrame(e.handleAnimation):(cancelAnimationFrame(t.animationRequest),t.animationRequest=null,e.endAnimationEvent(),e.render())},e.handleWheel=n=>{Rh(n);const r={...Ah(n),...l(n),position:s(n),deviceType:u(n)};0===t.wheelTimeoutID&&(a=Math.abs(r.spinY)>=.3?Math.abs(r.spinY):1),r.spinY/=a,0===t.wheelTimeoutID?(e.startMouseWheelEvent(r),e.mouseWheelEvent(r)):(e.mouseWheelEvent(r),clearTimeout(t.wheelTimeoutID)),t.mouseScrollDebounceByPass?(e.extendAnimation(600),e.endMouseWheelEvent(),t.wheelTimeoutID=0):t.wheelTimeoutID=setTimeout((()=>{e.extendAnimation(600),e.endMouseWheelEvent(),t.wheelTimeoutID=0}),200)},e.handleMouseUp=t=>{const n={...l(t),position:s(t),deviceType:u(t)};switch(t.button){case 0:e.leftButtonReleaseEvent(n);break;case 1:e.middleButtonReleaseEvent(n);break;case 2:e.rightButtonReleaseEvent(n);break;default:Sh(`Unknown mouse button released: ${t.button}`)}},e.handleTouchStart=n=>{const r=[...o.values()];if(t.recognizeGestures&&r.length>1){const t=Mh(o);if(2===r.length){const t={...l(wh),position:r[0].position,deviceType:u(n)};e.leftButtonReleaseEvent(t)}e.recognizeGesture(&quot;TouchStart&quot;,t)}else if(1===r.length){const t={...l(wh),position:s(n),deviceType:u(n)};e.leftButtonPressEvent(t)}},e.handleTouchMove=n=>{const r=[...o.values()];if(t.recognizeGestures&&r.length>1){const t=Mh(o);e.recognizeGesture(&quot;TouchMove&quot;,t)}else if(1===r.length){const t={...l(wh),position:r[0].position,deviceType:u(n)};e.mouseMoveEvent(t)}},e.handleTouchEnd=n=>{const r=[...o.values()];if(t.recognizeGestures)if(0===r.length){const t={...l(wh),position:s(n),deviceType:u(n)};e.leftButtonReleaseEvent(t)}else if(1===r.length){const t=Mh(o);e.recognizeGesture(&quot;TouchEnd&quot;,t);const a={...l(wh),position:r[0].position,deviceType:u(n)};e.leftButtonPressEvent(a)}else{const t=Mh(o);e.recognizeGesture(&quot;TouchMove&quot;,t)}else if(1===r.length){const t={...l(wh),position:r[0].position,deviceType:u(n)};e.leftButtonReleaseEvent(t)}},e.setView=n=>{t._view!==n&&(t._view=n,t._view.getRenderable().setInteractor(e),e.modified())},e.getFirstRenderer=()=>t._view?.getRenderable()?.getRenderersByReference()?.[0],e.findPokedRenderer=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;if(!t._view)return null;const r=t._view?.getRenderable()?.getRenderers();if(!r||0===r.length)return null;r.sort(((e,t)=>e.getLayer()-t.getLayer()));let o=null,a=null,i=null,s=r.length;for(;s--;){const l=r[s];if(t._view.isInViewport(e,n,l)&&l.getInteractive()){i=l;break}null===o&&l.getInteractive()&&(o=l),null===a&&t._view.isInViewport(e,n,l)&&(a=l)}return null===i&&(i=o),null===i&&(i=a),null==i&&(i=r[0]),i},e.render=()=>{e.isAnimating()||t.inRender||f()},Ph.forEach((n=>{const r=n.charAt(0).toLowerCase()+n.slice(1);e[`${r}Event`]=r=>{if(!t.enabled)return;if(!e.getCurrentRenderer())return void Ih(&quot;\\n          Can not forward events without a current renderer on the interactor.\\n        &quot;);const o={type:n,pokedRenderer:t.currentRenderer,firstRenderer:e.getFirstRenderer(),...r};e[`invoke${n}`](o)}})),e.recognizeGesture=(n,r)=>{if(Object.keys(r).length>2)return;if(t.startingEventPositions||(t.startingEventPositions={}),&quot;TouchStart&quot;===n)return Object.keys(r).forEach((e=>{t.startingEventPositions[e]=r[e]})),void(t.currentGesture=&quot;Start&quot;);if(&quot;TouchEnd&quot;===n)return&quot;Pinch&quot;===t.currentGesture&&(e.render(),e.endPinchEvent()),&quot;Rotate&quot;===t.currentGesture&&(e.render(),e.endRotateEvent()),&quot;Pan&quot;===t.currentGesture&&(e.render(),e.endPanEvent()),t.currentGesture=&quot;Start&quot;,void(t.startingEventPositions={});let o=0;const a=[],i=[];Object.keys(r).forEach((e=>{a[o]=r[e],i[o]=t.startingEventPositions[e],o++}));const s=Math.sqrt((i[0].x-i[1].x)*(i[0].x-i[1].x)+(i[0].y-i[1].y)*(i[0].y-i[1].y)),l=Math.sqrt((a[0].x-a[1].x)*(a[0].x-a[1].x)+(a[0].y-a[1].y)*(a[0].y-a[1].y));let c=To(Math.atan2(i[1].y-i[0].y,i[1].x-i[0].x)),u=To(Math.atan2(a[1].y-a[0].y,a[1].x-a[0].x)),d=u-c;u=u+180>=360?u-180:u+180,c=c+180>=360?c-180:c+180,Math.abs(u-c)<Math.abs(d)&&(d=u-c);const p=[];if(p[0]=(a[0].x-i[0].x+a[1].x-i[1].x)/2,p[1]=(a[0].y-i[0].y+a[1].y-i[1].y)/2,&quot;TouchMove&quot;===n)if(&quot;Start&quot;===t.currentGesture){let n=.01*Math.sqrt(t.container.clientWidth*t.container.clientWidth+t.container.clientHeight*t.container.clientHeight);n<15&&(n=15);const o=Math.abs(l-s),a=3.1415926*l*Math.abs(d)/360,i=Math.sqrt(p[0]*p[0]+p[1]*p[1]);if(o>n&&o>a&&o>i){t.currentGesture=&quot;Pinch&quot;;const n={scale:1,touches:r};e.startPinchEvent(n)}else if(a>n&&a>i){t.currentGesture=&quot;Rotate&quot;;const n={rotation:0,touches:r};e.startRotateEvent(n)}else if(i>n){t.currentGesture=&quot;Pan&quot;;const n={translation:[0,0],touches:r};e.startPanEvent(n)}}else{if(&quot;Rotate&quot;===t.currentGesture){const t={rotation:d,touches:r};e.rotateEvent(t)}if(&quot;Pinch&quot;===t.currentGesture){const t={scale:l/s,touches:r};e.pinchEvent(t)}if(&quot;Pan&quot;===t.currentGesture){const t={translation:p,touches:r};e.panEvent(t)}}},e.handleVisibilityChange=()=>{t._animationStartTime=Date.now(),t._animationFrameCount=0},e.setCurrentRenderer=e=>{t._forcedRenderer=!!e,t.currentRenderer=e},e.setContainer=e=>{p();const t=n.setContainer(e??null);return t&&d(),t},e.delete=()=>{for(;r.size;)e.cancelAnimation(r.values().next().value);void 0!==document.hidden&&document.removeEventListener(&quot;visibilitychange&quot;,e.handleVisibilityChange),t.container&&e.setContainer(null),n.delete()},void 0!==document.hidden&&document.addEventListener(&quot;visibilitychange&quot;,e.handleVisibilityChange,!1)}(e,t)}var Dh={newInstance:Wt.newInstance(Vh,&quot;vtkRenderWindowInteractor&quot;),extend:Vh,handledEvents:Ph,...yh};const{vtkErrorMacro:Lh,VOID:Bh}=Wt,Nh={enabled:!0,priority:0,processEvents:!0,subscribedEvents:[]};function Fh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Nh,n),Wt.obj(e,t),Wt.event(e,t,&quot;InteractionEvent&quot;),Wt.event(e,t,&quot;StartInteractionEvent&quot;),Wt.event(e,t,&quot;EndInteractionEvent&quot;),Wt.get(e,t,[&quot;_interactor&quot;,&quot;enabled&quot;]),Wt.setGet(e,t,[&quot;priority&quot;,&quot;processEvents&quot;]),Wt.moveToProtected(e,t,[&quot;interactor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkInteractorObserver&quot;);const n={...e};function r(){for(;t.subscribedEvents.length;)t.subscribedEvents.pop().unsubscribe()}function o(){Dh.handledEvents.forEach((n=>{e[`handle${n}`]&&t.subscribedEvents.push(t._interactor[`on${n}`]((r=>t.processEvents?e[`handle${n}`](r):Bh),t.priority))}))}e.setInteractor=n=>{n!==t._interactor&&(r(),t._interactor=n,n&&t.enabled&&o(),e.modified())},e.setEnabled=n=>{n!==t.enabled&&(r(),n&&(t._interactor?o():Lh(&quot;\\n          The interactor must be set before subscribing to events\\n        &quot;)),t.enabled=n,e.modified())},e.computeDisplayToWorld=(e,n,r,o)=>e?t._interactor.getView().displayToWorld(n,r,o,e):null,e.computeWorldToDisplay=(e,n,r,o)=>e?t._interactor.getView().worldToDisplay(n,r,o,e):null,e.setPriority=e=>{n.setPriority(e)&&t._interactor&&(r(),o())}}(e,t)}var _h={newInstance:Wt.newInstance(Fh,&quot;vtkInteractorObserver&quot;),extend:Fh,computeWorldToDisplay:function(e,t,n,r){return e.getRenderWindow().getViews()[0].worldToDisplay(t,n,r,e)},computeDisplayToWorld:function(e,t,n,r){return e.getRenderWindow().getViews()[0].displayToWorld(t,n,r,e)}},kh={States:{IS_START:0,IS_NONE:0,IS_ROTATE:1,IS_PAN:2,IS_SPIN:3,IS_DOLLY:4,IS_CAMERA_POSE:11,IS_WINDOW_LEVEL:1024,IS_SLICE:1025}};const{States:Gh}=kh,Uh={Rotate:Gh.IS_ROTATE,Pan:Gh.IS_PAN,Spin:Gh.IS_SPIN,Dolly:Gh.IS_DOLLY,CameraPose:Gh.IS_CAMERA_POSE,WindowLevel:Gh.IS_WINDOW_LEVEL,Slice:Gh.IS_SLICE},zh={state:Gh.IS_NONE,handleObservers:1,autoAdjustCameraClippingRange:1};function Wh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,zh,n),_h.extend(e,t,n),Wt.setGet(e,t,[&quot;focusedRenderer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkInteractorStyle&quot;),Object.keys(Uh).forEach((n=>{Wt.event(e,t,`Start${n}Event`),e[`start${n}`]=()=>{t.state===Gh.IS_NONE&&(t.state=Uh[n],t._interactor.requestAnimation(e),e.invokeStartInteractionEvent({type:&quot;StartInteractionEvent&quot;}),e[`invokeStart${n}Event`]({type:`Start${n}Event`}))},Wt.event(e,t,`End${n}Event`),e[`end${n}`]=()=>{t.state===Uh[n]&&(t.state=Gh.IS_NONE,t._interactor.cancelAnimation(e),e.invokeEndInteractionEvent({type:&quot;EndInteractionEvent&quot;}),e[`invokeEnd${n}Event`]({type:`End${n}Event`}),t._interactor.render())}})),t.getRenderer=e=>t.focusedRenderer||e.pokedRenderer,e.handleKeyPress=e=>{const n=t._interactor;let r=null;switch(e.key){case&quot;r&quot;:case&quot;R&quot;:t.getRenderer(e).resetCamera(),n.render();break;case&quot;w&quot;:case&quot;W&quot;:r=t.getRenderer(e).getActors(),r.forEach((e=>{const t=e.getProperty();t.setRepresentationToWireframe&&t.setRepresentationToWireframe()})),n.render();break;case&quot;s&quot;:case&quot;S&quot;:r=t.getRenderer(e).getActors(),r.forEach((e=>{const t=e.getProperty();t.setRepresentationToSurface&&t.setRepresentationToSurface()})),n.render();break;case&quot;v&quot;:case&quot;V&quot;:r=t.getRenderer(e).getActors(),r.forEach((e=>{const t=e.getProperty();t.setRepresentationToPoints&&t.setRepresentationToPoints()})),n.render()}}}(e,t)}var Hh={newInstance:Wt.newInstance(Wh,&quot;vtkInteractorStyle&quot;),extend:Wh,...kh};const{States:jh}=kh,Kh={motionFactor:10,zoomFactor:10};function $h(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Kh,n),Hh.extend(e,t,n),Wt.setGet(e,t,[&quot;motionFactor&quot;,&quot;zoomFactor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkInteractorStyleTrackballCamera&quot;),e.handleMouseMove=n=>{const r=n.position,o=t.getRenderer(n);switch(t.state){case jh.IS_ROTATE:e.handleMouseRotate(o,r),e.invokeInteractionEvent({type:&quot;InteractionEvent&quot;});break;case jh.IS_PAN:e.handleMousePan(o,r),e.invokeInteractionEvent({type:&quot;InteractionEvent&quot;});break;case jh.IS_DOLLY:e.handleMouseDolly(o,r),e.invokeInteractionEvent({type:&quot;InteractionEvent&quot;});break;case jh.IS_SPIN:e.handleMouseSpin(o,r),e.invokeInteractionEvent({type:&quot;InteractionEvent&quot;})}t.previousPosition=r},e.handleButton3D=n=>{!n||!n.pressed||n.device!==vh.RightController||n.input!==Th.Trigger&&n.input!==Th.TrackPad?!n||n.pressed||n.device!==vh.RightController||n.input!==Th.Trigger&&n.input!==Th.TrackPad||t.state!==jh.IS_CAMERA_POSE||e.endCameraPose():e.startCameraPose()},e.handleMove3D=n=>{t.state===jh.IS_CAMERA_POSE&&e.updateCameraPose(n)},e.updateCameraPose=e=>{const n=t.getRenderer(e).getActiveCamera(),r=n.getPhysicalTranslation(),o=.025*n.getPhysicalScale(),a=n.physicalOrientationToWorldDirection([e.orientation.x,e.orientation.y,e.orientation.z,e.orientation.w]);n.setPhysicalTranslation(r[0]+a[0]*o,r[1]+a[1]*o,r[2]+a[2]*o)},e.handleLeftButtonPress=n=>{const r=n.position;t.previousPosition=r,n.shiftKey?n.controlKey||n.altKey?e.startDolly():e.startPan():n.controlKey||n.altKey?e.startSpin():e.startRotate()},e.handleLeftButtonRelease=()=>{switch(t.state){case jh.IS_DOLLY:e.endDolly();break;case jh.IS_PAN:e.endPan();break;case jh.IS_SPIN:e.endSpin();break;case jh.IS_ROTATE:e.endRotate()}},e.handleStartMouseWheel=()=>{e.startDolly()},e.handleEndMouseWheel=()=>{e.endDolly()},e.handleStartPinch=n=>{t.previousScale=n.scale,e.startDolly()},e.handleEndPinch=()=>{e.endDolly()},e.handleStartRotate=n=>{t.previousRotation=n.rotation,e.startRotate()},e.handleEndRotate=()=>{e.endRotate()},e.handleStartPan=n=>{t.previousTranslation=n.translation,e.startPan()},e.handleEndPan=()=>{e.endPan()},e.handlePinch=n=>{e.dollyByFactor(t.getRenderer(n),n.scale/t.previousScale),t.previousScale=n.scale},e.handlePan=n=>{const r=t.getRenderer(n).getActiveCamera();let o=r.getFocalPoint();o=e.computeWorldToDisplay(t.getRenderer(n),o[0],o[1],o[2]);const a=o[2],i=n.translation,s=t.previousTranslation,l=e.computeDisplayToWorld(t.getRenderer(n),o[0]+i[0]-s[0],o[1]+i[1]-s[1],a),c=e.computeDisplayToWorld(t.getRenderer(n),o[0],o[1],a),u=[];u[0]=c[0]-l[0],u[1]=c[1]-l[1],u[2]=c[2]-l[2],o=r.getFocalPoint();const d=r.getPosition();r.setFocalPoint(u[0]+o[0],u[1]+o[1],u[2]+o[2]),r.setPosition(u[0]+d[0],u[1]+d[1],u[2]+d[2]),t._interactor.getLightFollowCamera()&&t.getRenderer(n).updateLightsGeometryToFollowCamera(),r.orthogonalizeViewUp(),t.previousTranslation=n.translation},e.handleRotate=e=>{const n=t.getRenderer(e).getActiveCamera();n.roll(e.rotation-t.previousRotation),n.orthogonalizeViewUp(),t.previousRotation=e.rotation},e.handleMouseRotate=(e,n)=>{if(!t.previousPosition)return;const r=t._interactor,o=n.x-t.previousPosition.x,a=n.y-t.previousPosition.y,i=r.getView().getViewportSize(e);let s=-.1,l=-.1;i[0]&&i[1]&&(s=-20/i[1],l=-20/i[0]);const c=o*l*t.motionFactor,u=a*s*t.motionFactor,d=e.getActiveCamera();Number.isNaN(c)||Number.isNaN(u)||(d.azimuth(c),d.elevation(u),d.orthogonalizeViewUp()),t.autoAdjustCameraClippingRange&&e.resetCameraClippingRange(),r.getLightFollowCamera()&&e.updateLightsGeometryToFollowCamera()},e.handleMouseSpin=(e,n)=>{if(!t.previousPosition)return;const r=t._interactor,o=e.getActiveCamera(),a=r.getView().getViewportCenter(e),i=To(Math.atan2(t.previousPosition.y-a[1],t.previousPosition.x-a[0])),s=To(Math.atan2(n.y-a[1],n.x-a[0]))-i;Number.isNaN(s)||(o.roll(s),o.orthogonalizeViewUp())},e.handleMousePan=(n,r)=>{if(!t.previousPosition)return;const o=n.getActiveCamera();let a=o.getFocalPoint();a=e.computeWorldToDisplay(n,a[0],a[1],a[2]);const i=a[2],s=e.computeDisplayToWorld(n,r.x,r.y,i),l=e.computeDisplayToWorld(n,t.previousPosition.x,t.previousPosition.y,i),c=[];c[0]=l[0]-s[0],c[1]=l[1]-s[1],c[2]=l[2]-s[2],a=o.getFocalPoint();const u=o.getPosition();o.setFocalPoint(c[0]+a[0],c[1]+a[1],c[2]+a[2]),o.setPosition(c[0]+u[0],c[1]+u[1],c[2]+u[2]),t._interactor.getLightFollowCamera()&&n.updateLightsGeometryToFollowCamera()},e.handleMouseDolly=(n,r)=>{if(!t.previousPosition)return;const o=r.y-t.previousPosition.y,a=t._interactor.getView().getViewportCenter(n),i=t.motionFactor*o/a[1];e.dollyByFactor(n,1.1**i)},e.handleMouseWheel=n=>{const r=1-n.spinY/t.zoomFactor;e.dollyByFactor(t.getRenderer(n),r)},e.dollyByFactor=(e,n)=>{if(Number.isNaN(n))return;const r=e.getActiveCamera();r.getParallelProjection()?r.setParallelScale(r.getParallelScale()/n):(r.dolly(n),t.autoAdjustCameraClippingRange&&e.resetCameraClippingRange()),t._interactor.getLightFollowCamera()&&e.updateLightsGeometryToFollowCamera()}}(e,t)}var qh={newInstance:Wt.newInstance($h,&quot;vtkInteractorStyleTrackballCamera&quot;),extend:$h};function Xh(e){return e}function Yh(e){return null===e||&quot;null&quot;===e?null:&quot;true&quot;===e||&quot;false&quot;!==e&&(void 0!==e&&&quot;undefined&quot;!==e?&quot;[&quot;===e[0]&&&quot;]&quot;===e[e.length-1]?e.substring(1,e.length-1).split(&quot;,&quot;).map((e=>Yh(e.trim()))):&quot;&quot;===e||Number.isNaN(Number(e))?e:Number(e):void 0)}var Zh=function(){let e=!(arguments.length>0&&void 0!==arguments[0])||arguments[0],t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:window.location.search;const n={},r=e?Yh:Xh;return new URLSearchParams(t).forEach(((e,t)=>{t&&(n[t]=!e||r(e))})),n};const Qh={delegates:[],currentOperation:null,preDelegateOperations:[],postDelegateOperations:[],currentParent:null};function Jh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Qh,n),Wt.obj(e,t),Wt.get(e,t,[&quot;currentOperation&quot;]),Wt.setGet(e,t,[&quot;delegates&quot;,&quot;_currentParent&quot;,&quot;preDelegateOperations&quot;,&quot;postDelegateOperations&quot;]),Wt.moveToProtected(e,t,[&quot;currentParent&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkRenderPass&quot;),e.getOperation=()=>t.currentOperation,e.setCurrentOperation=e=>{t.currentOperation=e,t.currentTraverseOperation=`traverse${Wt.capitalize(t.currentOperation)}`},e.getTraverseOperation=()=>t.currentTraverseOperation,e.traverse=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;t.deleted||(t._currentParent=r,t.preDelegateOperations.forEach((t=>{e.setCurrentOperation(t),n.traverse(e)})),t.delegates.forEach((t=>{t.traverse(n,e)})),t.postDelegateOperations.forEach((t=>{e.setCurrentOperation(t),n.traverse(e)})))}}(e,t)}var ev={newInstance:Wt.newInstance(Jh,&quot;vtkRenderPass&quot;),extend:Jh};const{Representation:tv}=os,{vtkErrorMacro:nv}=Wt;function rv(e){const t=td.substitute(e.Fragment,&quot;//VTK::RenderPassFragmentShader::Impl&quot;,&quot;\\n      float weight = gl_FragData[0].a * pow(max(1.1 - gl_FragCoord.z, 0.0), 2.0);\\n      gl_FragData[0] = vec4(gl_FragData[0].rgb*weight, gl_FragData[0].a);\\n      gl_FragData[1].r = weight;\\n    &quot;,!1);e.Fragment=t.result}const ov={framebuffer:null,copyShader:null,tris:null};function av(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ov,n),ev.extend(e,t,n),t.VBOBuildTime={},Wt.obj(t.VBOBuildTime,{mtime:0}),t.tris=ld.newInstance(),Wt.get(e,t,[&quot;framebuffer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLOrderIndependentTranslucentPass&quot;),e.createVertexBuffer=()=>{const e=new Float32Array([-1,-1,-1,1,-1,-1,-1,1,-1,1,1,-1]),n=new Float32Array([0,0,1,0,0,1,1,1]),r=new Uint16Array([4,0,1,3,2]),o=xs.newInstance({numberOfComponents:3,values:e});o.setName(&quot;points&quot;);const a=xs.newInstance({numberOfComponents:2,values:n});a.setName(&quot;tcoords&quot;);const i=xs.newInstance({numberOfComponents:1,values:r});t.tris.getCABO().createVBO(i,&quot;polys&quot;,tv.SURFACE,{points:o,tcoords:a,cellOffset:0}),t.VBOBuildTime.modified()},e.createFramebuffer=e=>{const n=e.getSize(),r=e.getContext();t.framebuffer=Sp.newInstance(),t.framebuffer.setOpenGLRenderWindow(e),t.framebuffer.create(...n),t.framebuffer.saveCurrentBindingsAndBuffers(),t.framebuffer.bind(),t.translucentRGBATexture=Pd.newInstance(),t.translucentRGBATexture.setInternalFormat(r.RGBA16F),t.translucentRGBATexture.setFormat(r.RGBA),t.translucentRGBATexture.setOpenGLDataType(r.HALF_FLOAT),t.translucentRGBATexture.setOpenGLRenderWindow(e),t.translucentRGBATexture.create2DFromRaw({width:n[0],height:n[1],numComps:4,dataType:&quot;Float32Array&quot;,data:null}),t.translucentRTexture=Pd.newInstance(),t.translucentRTexture.setInternalFormat(r.R16F),t.translucentRTexture.setFormat(r.RED),t.translucentRTexture.setOpenGLDataType(r.HALF_FLOAT),t.translucentRTexture.setOpenGLRenderWindow(e),t.translucentRTexture.create2DFromRaw({width:n[0],height:n[1],numComps:1,dataType:&quot;Float32Array&quot;,data:null}),t.translucentZTexture=Pd.newInstance(),t.translucentZTexture.setOpenGLRenderWindow(e),t.translucentZTexture.createDepthFromRaw({width:n[0],height:n[1],dataType:&quot;Float32Array&quot;,data:null}),t.framebuffer.setColorBuffer(t.translucentRGBATexture,0),t.framebuffer.setColorBuffer(t.translucentRTexture,1),t.framebuffer.setDepthBuffer(t.translucentZTexture)},e.createCopyShader=e=>{t.copyShader=e.getShaderCache().readyShaderProgramArray([&quot;//VTK::System::Dec&quot;,&quot;attribute vec4 vertexDC;&quot;,&quot;attribute vec2 tcoordTC;&quot;,&quot;varying vec2 tcoord;&quot;,&quot;void main() { tcoord = tcoordTC; gl_Position = vertexDC; }&quot;].join(&quot;\\n&quot;),&quot;//VTK::System::Dec\\n\\nin vec2 tcoord;\\n\\nuniform sampler2D translucentRTexture;\\nuniform sampler2D translucentRGBATexture;\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nvoid main()\\n{\\n  vec4 t1Color = texture(translucentRGBATexture, tcoord);\\n  float t2Color = texture(translucentRTexture, tcoord).r;\\n  gl_FragData[0] = vec4(t1Color.rgb/max(t2Color,0.01), 1.0 - t1Color.a);\\n}\\n&quot;,&quot;&quot;)},e.createVBO=n=>{const r=n.getContext();t.tris.setOpenGLRenderWindow(n),e.createVertexBuffer();const o=t.copyShader;t.tris.getCABO().bind(),t.copyVAO.addAttributeArray(o,t.tris.getCABO(),&quot;vertexDC&quot;,t.tris.getCABO().getVertexOffset(),t.tris.getCABO().getStride(),r.FLOAT,3,r.FALSE)||nv(&quot;Error setting vertexDC in copy shader VAO.&quot;),t.copyVAO.addAttributeArray(o,t.tris.getCABO(),&quot;tcoordTC&quot;,t.tris.getCABO().getTCoordOffset(),t.tris.getCABO().getStride(),r.FLOAT,2,r.FALSE)||nv(&quot;Error setting vertexDC in copy shader VAO.&quot;)},e.traverse=(n,r,o)=>{if(t.deleted)return;const a=n.getSize(),i=n.getContext();if(t._supported=!1,r.getSelector()||!i||!n.getWebgl2()||!i.getExtension(&quot;EXT_color_buffer_half_float&quot;)&&!i.getExtension(&quot;EXT_color_buffer_float&quot;))return e.setCurrentOperation(&quot;translucentPass&quot;),void r.traverse(e);if(t._supported=!0,null===t.framebuffer)e.createFramebuffer(n);else{const r=t.framebuffer.getSize();null===r||r[0]!==a[0]||r[1]!==a[1]?(t.framebuffer.releaseGraphicsResources(),t.translucentRGBATexture.releaseGraphicsResources(n),t.translucentRTexture.releaseGraphicsResources(n),t.translucentZTexture.releaseGraphicsResources(n),e.createFramebuffer(n)):(t.framebuffer.saveCurrentBindingsAndBuffers(),t.framebuffer.bind())}i.drawBuffers([i.COLOR_ATTACHMENT0]),i.clearBufferfv(i.COLOR,0,[0,0,0,0]),i.clearBufferfv(i.DEPTH,0,[1]),i.colorMask(!1,!1,!1,!1),o.getOpaqueActorCount()>0&&(o.setCurrentOperation(&quot;opaqueZBufferPass&quot;),r.traverse(o)),i.colorMask(!0,!0,!0,!0),i.drawBuffers([i.COLOR_ATTACHMENT0,i.COLOR_ATTACHMENT1]),i.viewport(0,0,a[0],a[1]),i.scissor(0,0,a[0],a[1]),i.clearBufferfv(i.COLOR,0,[0,0,0,1]),i.clearBufferfv(i.COLOR,1,[0,0,0,0]),i.enable(i.DEPTH_TEST),i.enable(i.BLEND),i.blendFuncSeparate(i.ONE,i.ONE,i.ZERO,i.ONE_MINUS_SRC_ALPHA),e.setCurrentOperation(&quot;translucentPass&quot;),r.traverse(e),i.drawBuffers([i.NONE]),t.framebuffer.restorePreviousBindingsAndBuffers(),null===t.copyShader?e.createCopyShader(n):n.getShaderCache().readyShaderProgram(t.copyShader),t.copyVAO||(t.copyVAO=od.newInstance(),t.copyVAO.setOpenGLRenderWindow(n)),t.copyVAO.bind(),t.VBOBuildTime.getMTime()<e.getMTime()&&e.createVBO(n),i.blendFuncSeparate(i.SRC_ALPHA,i.ONE_MINUS_SRC_ALPHA,i.ONE,i.ONE_MINUS_SRC_ALPHA),i.depthMask(!1),i.depthFunc(i.ALWAYS),i.viewport(0,0,a[0],a[1]),i.scissor(0,0,a[0],a[1]),t.translucentRGBATexture.activate(),t.copyShader.setUniformi(&quot;translucentRGBATexture&quot;,t.translucentRGBATexture.getTextureUnit()),t.translucentRTexture.activate(),t.copyShader.setUniformi(&quot;translucentRTexture&quot;,t.translucentRTexture.getTextureUnit()),i.drawArrays(i.TRIANGLES,0,t.tris.getCABO().getElementCount()),i.depthMask(!0),i.depthFunc(i.LEQUAL),t.translucentRGBATexture.deactivate(),t.translucentRTexture.deactivate();const s=r.getTiledSizeAndOrigin();i.scissor(s.lowerLeftU,s.lowerLeftV,s.usize,s.vsize),i.viewport(s.lowerLeftU,s.lowerLeftV,s.usize,s.vsize)},e.getShaderReplacement=()=>t._supported?rv:null,e.releaseGraphicsResources=n=>{t.framebuffer&&(t.framebuffer.releaseGraphicsResources(n),t.framebuffer=null),t.translucentRGBATexture&&(t.translucentRGBATexture.releaseGraphicsResources(n),t.translucentRGBATexture=null),t.translucentRTexture&&(t.translucentRTexture.releaseGraphicsResources(n),t.translucentRTexture=null),t.translucentZTexture&&(t.translucentZTexture.releaseGraphicsResources(n),t.translucentZTexture=null),t.copyVAO&&(t.copyVAO.releaseGraphicsResources(n),t.copyVAO=null),t.copyShader&&(t.copyShader.releaseGraphicsResources(n),t.copyShader=null),t.tris&&(t.tris.releaseGraphicsResources(n),t.tris=null),e.modified()}}(e,t)}var iv={newInstance:Wt.newInstance(av,&quot;vtkOpenGLOrderIndependentTranslucentPass&quot;),extend:av};const sv={opaqueActorCount:0,translucentActorCount:0,volumeCount:0,overlayActorCount:0,framebuffer:null,depthRequested:!1};function lv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,sv,n),ev.extend(e,t,n),Wt.get(e,t,[&quot;framebuffer&quot;,&quot;opaqueActorCount&quot;,&quot;translucentActorCount&quot;,&quot;volumeCount&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkForwardPass&quot;),e.traverse=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(t.deleted)return;t._currentParent=r,e.setCurrentOperation(&quot;buildPass&quot;),n.traverse(e);const o=n.getRenderable().getNumberOfLayers(),a=n.getRenderable().getRenderersByReference();for(let r=0;r<o;r++)for(let o=0;o<a.length;o++){const i=a[o],s=n.getViewNodeFor(i);if(i.getDraw()&&i.getLayer()===r){if(t.opaqueActorCount=0,t.translucentActorCount=0,t.volumeCount=0,t.overlayActorCount=0,e.setCurrentOperation(&quot;queryPass&quot;),s.traverse(e),(t.opaqueActorCount>0||t.translucentActorCount>0)&&t.volumeCount>0||t.depthRequested){const r=n.getFramebufferSize();null===t.framebuffer&&(t.framebuffer=Sp.newInstance()),t.framebuffer.setOpenGLRenderWindow(n),t.framebuffer.saveCurrentBindingsAndBuffers();const o=t.framebuffer.getSize();null!==o&&o[0]===r[0]&&o[1]===r[1]||(t.framebuffer.create(r[0],r[1]),t.framebuffer.populateFramebuffer()),t.framebuffer.bind(),e.setCurrentOperation(&quot;zBufferPass&quot;),s.traverse(e),t.framebuffer.restorePreviousBindingsAndBuffers(),t.depthRequested=!1}e.setCurrentOperation(&quot;cameraPass&quot;),s.traverse(e),t.opaqueActorCount>0&&(e.setCurrentOperation(&quot;opaquePass&quot;),s.traverse(e)),t.translucentActorCount>0&&(t.translucentPass||(t.translucentPass=iv.newInstance()),t.translucentPass.traverse(n,s,e)),t.volumeCount>0&&(e.setCurrentOperation(&quot;volumePass&quot;),s.traverse(e)),t.overlayActorCount>0&&(e.setCurrentOperation(&quot;overlayPass&quot;),s.traverse(e))}}},e.getZBufferTexture=()=>t.framebuffer?t.framebuffer.getColorTexture():null,e.requestDepth=()=>{t.depthRequested=!0},e.incrementOpaqueActorCount=()=>t.opaqueActorCount++,e.incrementTranslucentActorCount=()=>t.translucentActorCount++,e.incrementVolumeCount=()=>t.volumeCount++,e.incrementOverlayActorCount=()=>t.overlayActorCount++}(e,t)}var cv={newInstance:Wt.newInstance(lv,&quot;vtkForwardPass&quot;),extend:lv},uv=n(292);const dv=[&quot;lastShaderProgramBound&quot;,&quot;context&quot;,&quot;_openGLRenderWindow&quot;],pv={lastShaderProgramBound:null,shaderPrograms:null,context:null};function fv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,pv,n),t.shaderPrograms={},Wt.obj(e,t),Wt.setGet(e,t,dv),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkShaderCache&quot;),e.replaceShaderValues=(e,n,r)=>{let o=n;r.length>0&&(o=td.substitute(o,&quot;VSOut&quot;,&quot;GSOut&quot;).result);const a=t._openGLRenderWindow.getWebgl2();let i=&quot;\\n&quot;,s=&quot;#version 100\\n&quot;;a?s=&quot;#version 300 es\\n#define attribute in\\n#define textureCube texture\\n#define texture2D texture\\n#define textureCubeLod textureLod\\n#define texture2DLod textureLod\\n&quot;:(t.context.getExtension(&quot;OES_standard_derivatives&quot;),t.context.getExtension(&quot;EXT_frag_depth&quot;)&&(i=&quot;#extension GL_EXT_frag_depth : enable\\n&quot;),t.context.getExtension(&quot;EXT_shader_texture_lod&quot;)&&(i+=&quot;#extension GL_EXT_shader_texture_lod : enable\\n#define textureCubeLod textureCubeLodEXT\\n#define texture2DLod texture2DLodEXT&quot;)),o=td.substitute(o,&quot;//VTK::System::Dec&quot;,[`${s}\\n`,a?&quot;&quot;:&quot;#extension GL_OES_standard_derivatives : enable\\n&quot;,i,&quot;#ifdef GL_FRAGMENT_PRECISION_HIGH&quot;,&quot;precision highp float;&quot;,&quot;precision highp int;&quot;,&quot;#else&quot;,&quot;precision mediump float;&quot;,&quot;precision mediump int;&quot;,&quot;#endif&quot;]).result;let l=td.substitute(e,&quot;//VTK::System::Dec&quot;,[`${s}\\n`,&quot;#ifdef GL_FRAGMENT_PRECISION_HIGH&quot;,&quot;precision highp float;&quot;,&quot;precision highp int;&quot;,&quot;#else&quot;,&quot;precision mediump float;&quot;,&quot;precision mediump int;&quot;,&quot;#endif&quot;]).result;if(a){l=td.substitute(l,&quot;varying&quot;,&quot;out&quot;).result,o=td.substitute(o,&quot;varying&quot;,&quot;in&quot;).result;let e=&quot;&quot;,t=0;for(;o.includes(`gl_FragData[${t}]`);)o=td.substitute(o,`gl_FragData\\\\[${t}\\\\]`,`fragOutput${t}`).result,e+=`layout(location = ${t}) out vec4 fragOutput${t};\\n`,t++;o=td.substitute(o,&quot;//VTK::Output::Dec&quot;,e).result}return{VSSource:l,FSSource:o,GSSource:td.substitute(r,&quot;//VTK::System::Dec&quot;,s).result}},e.readyShaderProgramArray=(t,n,r)=>{const o=e.replaceShaderValues(t,n,r),a=e.getShaderProgram(o.VSSource,o.FSSource,o.GSSource);return e.readyShaderProgram(a)},e.readyShaderProgram=t=>t&&(t.getCompiled()||t.compileShader())&&e.bindShaderProgram(t)?t:null,e.getShaderProgram=(e,n,r)=>{const o=`${e}${n}${r}`,a=uv.hash(o);if(!(a in t.shaderPrograms)){const o=td.newInstance();return o.setContext(t.context),o.getVertexShader().setSource(e),o.getFragmentShader().setSource(n),r&&o.getGeometryShader().setSource(r),o.setMd5Hash(a),t.shaderPrograms[a]=o,o}return t.shaderPrograms[a]},e.releaseGraphicsResources=n=>{e.releaseCurrentShaderProgram(),Object.keys(t.shaderPrograms).map((e=>t.shaderPrograms[e])).forEach((e=>e.cleanup())),t.shaderPrograms={}},e.releaseCurrentShaderProgram=()=>{t.lastShaderProgramBound&&(t.lastShaderProgramBound.cleanup(),t.lastShaderProgramBound=null)},e.bindShaderProgram=e=>(t.lastShaderProgramBound===e||(t.lastShaderProgramBound&&t.lastShaderProgramBound.release(),e.bind(),t.lastShaderProgramBound=e),1)}(e,t)}var gv={newInstance:Wt.newInstance(fv,&quot;vtkShaderCache&quot;),extend:fv};const{vtkErrorMacro:mv}=Wt,hv={context:null,numberOfTextureUnits:0,textureUnits:0};function vv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,hv,n),Wt.obj(e,t),t.textureUnits=[],Wt.get(e,t,[&quot;numberOfTextureUnits&quot;]),Wt.setGet(e,t,[&quot;context&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLTextureUnitManager&quot;),e.deleteTable=()=>{for(let e=0;e<t.numberOfTextureUnits;++e)!0===t.textureUnits[e]&&mv(&quot;some texture units  were not properly released&quot;);t.textureUnits=[],t.numberOfTextureUnits=0},e.setContext=n=>{if(t.context!==n){if(0!==t.context&&e.deleteTable(),t.context=n,t.context){t.numberOfTextureUnits=n.getParameter(n.MAX_TEXTURE_IMAGE_UNITS);for(let e=0;e<t.numberOfTextureUnits;++e)t.textureUnits[e]=!1}e.modified()}},e.allocate=()=>{for(let n=0;n<t.numberOfTextureUnits;n++)if(!e.isAllocated(n))return t.textureUnits[n]=!0,n;return-1},e.allocateUnit=n=>e.isAllocated(n)?-1:(t.textureUnits[n]=!0,n),e.isAllocated=e=>t.textureUnits[e],e.free=e=>{t.textureUnits[e]=!1},e.freeAll=()=>{for(let e=0;e<t.numberOfTextureUnits;++e)t.textureUnits[e]=!1}}(e,t)}var Tv={newInstance:Wt.newInstance(vv,&quot;vtkOpenGLTextureUnitManager&quot;),extend:vv};const yv={size:void 0,selector:void 0};function bv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,yv,n),t.size||(t.size=[300,300]),Wt.getArray(e,t,[&quot;size&quot;],2),Wt.get(e,t,[&quot;selector&quot;]),qt.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkRenderWindowViewNode&quot;),e.getViewNodeFactory=()=>null,e.getAspectRatio=()=>t.size[0]/t.size[1],e.getAspectRatioForRenderer=e=>{const n=e.getViewportByReference();return t.size[0]*(n[2]-n[0])/((n[3]-n[1])*t.size[1])},e.isInViewport=(t,n,r)=>{const o=r.getViewportByReference(),a=e.getFramebufferSize();return o[0]*a[0]<=t&&o[2]*a[0]>=t&&o[1]*a[1]<=n&&o[3]*a[1]>=n},e.getViewportSize=t=>{const n=t.getViewportByReference(),r=e.getFramebufferSize();return[(n[2]-n[0])*r[0],(n[3]-n[1])*r[1]]},e.getViewportCenter=t=>{const n=e.getViewportSize(t);return[.5*n[0],.5*n[1]]},e.displayToNormalizedDisplay=(t,n,r)=>{const o=e.getFramebufferSize();return[t/o[0],n/o[1],r]},e.normalizedDisplayToDisplay=(t,n,r)=>{const o=e.getFramebufferSize();return[t*o[0],n*o[1],r]},e.worldToView=(e,t,n,r)=>r.worldToView(e,t,n),e.viewToWorld=(e,t,n,r)=>r.viewToWorld(e,t,n),e.worldToDisplay=(t,n,r,o)=>{const a=o.worldToView(t,n,r),i=e.getViewportSize(o),s=o.viewToProjection(a[0],a[1],a[2],i[0]/i[1]),l=o.projectionToNormalizedDisplay(s[0],s[1],s[2]);return e.normalizedDisplayToDisplay(l[0],l[1],l[2])},e.displayToWorld=(t,n,r,o)=>{const a=e.displayToNormalizedDisplay(t,n,r),i=o.normalizedDisplayToProjection(a[0],a[1],a[2]),s=e.getViewportSize(o),l=o.projectionToView(i[0],i[1],i[2],s[0]/s[1]);return o.viewToWorld(l[0],l[1],l[2])},e.normalizedDisplayToViewport=(t,n,r,o)=>{let a=o.getViewportByReference();a=e.normalizedDisplayToDisplay(a[0],a[1],0);const i=e.normalizedDisplayToDisplay(t,n,r);return[i[0]-a[0]-.5,i[1]-a[1]-.5,r]},e.viewportToNormalizedViewport=(t,n,r,o)=>{const a=e.getViewportSize(o);return a&&0!==a[0]&&0!==a[1]?[t/(a[0]-1),n/(a[1]-1),r]:[t,n,r]},e.normalizedViewportToViewport=(t,n,r,o)=>{const a=e.getViewportSize(o);return[t*(a[0]-1),n*(a[1]-1),r]},e.displayToLocalDisplay=(t,n,r)=>[t,e.getFramebufferSize()[1]-n-1,r],e.viewportToNormalizedDisplay=(t,n,r,o)=>{let a=o.getViewportByReference();a=e.normalizedDisplayToDisplay(a[0],a[1],0);const i=t+a[0]+.5,s=n+a[1]+.5;return e.displayToNormalizedDisplay(i,s,r)},e.getComputedDevicePixelRatio=()=>t.size[0]/e.getContainerSize()[0],e.getContainerSize=()=>{Wt.vtkErrorMacro(&quot;not implemented&quot;)},e.getPixelData=(e,t,n,r)=>{Wt.vtkErrorMacro(&quot;not implemented&quot;)},e.createSelector=()=>{Wt.vtkErrorMacro(&quot;not implemented&quot;)}}(e,t)}var xv={newInstance:Wt.newInstance(bv,&quot;vtkRenderWindowViewNode&quot;),extend:bv};const{vtkDebugMacro:Cv,vtkErrorMacro:Sv}=Wt,Av={position:&quot;absolute&quot;,top:0,left:0,width:&quot;100%&quot;,height:&quot;100%&quot;},Iv=[&quot;activateTexture&quot;,&quot;deactivateTexture&quot;,&quot;disableCullFace&quot;,&quot;enableCullFace&quot;,&quot;get3DContext&quot;,&quot;getActiveFramebuffer&quot;,&quot;getContext&quot;,&quot;getDefaultTextureByteSize&quot;,&quot;getDefaultTextureInternalFormat&quot;,&quot;getDefaultToWebgl2&quot;,&quot;getGLInformations&quot;,&quot;getGraphicsMemoryInfo&quot;,&quot;getGraphicsResourceForObject&quot;,&quot;getHardwareMaximumLineWidth&quot;,&quot;getPixelData&quot;,&quot;getShaderCache&quot;,&quot;getTextureUnitForTexture&quot;,&quot;getTextureUnitManager&quot;,&quot;getWebgl2&quot;,&quot;makeCurrent&quot;,&quot;releaseGraphicsResources&quot;,&quot;registerGraphicsResourceUser&quot;,&quot;unregisterGraphicsResourceUser&quot;,&quot;restoreContext&quot;,&quot;setActiveFramebuffer&quot;,&quot;setContext&quot;,&quot;setDefaultToWebgl2&quot;,&quot;setGraphicsResourceForObject&quot;];function wv(e,t,n){const r=e.createFramebuffer(),o=e.createTexture();e.bindTexture(e.TEXTURE_2D,o),e.texImage2D(e.TEXTURE_2D,0,t,2,2,0,t,n,null),e.bindFramebuffer(e.FRAMEBUFFER,r),e.framebufferTexture2D(e.FRAMEBUFFER,e.COLOR_ATTACHMENT0,e.TEXTURE_2D,o,0);const a=e.checkFramebufferStatus(e.FRAMEBUFFER);return e.bindFramebuffer(e.FRAMEBUFFER,null),e.bindTexture(e.TEXTURE_2D,null),a===e.FRAMEBUFFER_COMPLETE}let Ov=0;const Pv=[];function Rv(e){e.preventDefault()}function Mv(e,t){let n;t.classHierarchy.push(&quot;vtkOpenGLRenderWindow&quot;),e.getViewNodeFactory=()=>t.myFactory,t.canvas.addEventListener(&quot;webglcontextlost&quot;,Rv,!1),t.canvas.addEventListener(&quot;webglcontextrestored&quot;,e.restoreContext,!1);const r=[0,0];let o;e.onModified((function(){t.renderable&&(t.size[0]===r[0]&&t.size[1]===r[1]||(r[0]=t.size[0],r[1]=t.size[1],t.canvas.setAttribute(&quot;width&quot;,t.size[0]),t.canvas.setAttribute(&quot;height&quot;,t.size[1]))),t.viewStream&&t.viewStream.setSize(t.size[0],t.size[1]),t.canvas.style.display=t.useOffScreen?&quot;none&quot;:&quot;block&quot;,t.el&&(t.el.style.cursor=t.cursorVisibility?t.cursor:&quot;none&quot;),t.containerSize=null})),e.buildPass=n=>{if(n){if(!t.renderable)return;e.prepareNodes(),e.addMissingNodes(t.renderable.getRenderersByReference()),e.addMissingNodes(t.renderable.getChildRenderWindowsByReference()),e.removeUnusedNodes(),e.initialize(),t.children.forEach((t=>{t.setOpenGLRenderWindow?.(e)}))}},e.initialize=()=>{if(!t.initialized){if(t.rootOpenGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t.rootOpenGLRenderWindow)t.context2D=e.get2DContext();else{t.context=e.get3DContext(),e.resizeFromChildRenderWindows(),t.context&&(Ov++,Pv.forEach((e=>e(Ov)))),t.textureUnitManager=Tv.newInstance(),t.textureUnitManager.setContext(t.context),t.shaderCache.setContext(t.context);const n=t.context;n.blendFuncSeparate(n.SRC_ALPHA,n.ONE_MINUS_SRC_ALPHA,n.ONE,n.ONE_MINUS_SRC_ALPHA),n.depthFunc(n.LEQUAL),n.enable(n.BLEND)}t.initialized=!0}},e.makeCurrent=()=>{t.context.makeCurrent()},e.setContainer=n=>{t.el&&t.el!==n&&(t.canvas.parentNode!==t.el&&Sv(&quot;Error: canvas parent node does not match container&quot;),t.el.removeChild(t.canvas),t.el.contains(t.bgImage)&&t.el.removeChild(t.bgImage)),t.el!==n&&(t.el=n,t.el&&(t.el.appendChild(t.canvas),t.useBackgroundImage&&t.el.appendChild(t.bgImage)),e.modified())},e.getContainer=()=>t.el,e.getContainerSize=()=>{if(!t.containerSize&&t.el){const{width:e,height:n}=t.el.getBoundingClientRect();t.containerSize=[e,n]}return t.containerSize||t.size},e.getFramebufferSize=()=>{const e=t.activeFramebuffer?.getSize();return e||t.size},e.getPixelData=(e,n,r,o)=>{const a=new Uint8Array((r-e+1)*(o-n+1)*4);return t.context.readPixels(e,n,r-e+1,o-n+1,t.context.RGBA,t.context.UNSIGNED_BYTE,a),a},e.get3DContext=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{preserveDrawingBuffer:!1,depth:!0,alpha:!0,powerPreference:&quot;high-performance&quot;},r=null;const o=&quot;undefined&quot;!=typeof WebGL2RenderingContext;return t.webgl2=!1,t.defaultToWebgl2&&o&&(r=t.canvas.getContext(&quot;webgl2&quot;,e),r&&(t.webgl2=!0,Cv(&quot;using webgl2&quot;))),r||(Cv(&quot;using webgl1&quot;),r=t.canvas.getContext(&quot;webgl&quot;,e)||t.canvas.getContext(&quot;experimental-webgl&quot;,e)),new Proxy(r,(n||(n=function(){const e=new Map,t={apply(t,n,r){return e.has(r[0])?e.get(r[0]):t.apply(n,r)}},n=Object.create(null);return n.getParameter=(e,n,r,o)=>new Proxy(o.bind(e),t),n.depthMask=(t,n,r,o)=>{return new Proxy(o.bind(t),(a=t.DEPTH_WRITEMASK,{apply(t,n,r){return e.set(a,r[0]),t.apply(n,r)}}));var a},{get(e,t,r){if(&quot;__getUnderlyingContext&quot;===t)return()=>e;let o=Reflect.get(e,t,e);o instanceof Function&&(o=o.bind(e));const a=n[t];return a?a(e,t,r,o):o}}}()),n))},e.get2DContext=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};return t.canvas.getContext(&quot;2d&quot;,e)},e.restoreContext=()=>{const t=ev.newInstance();t.setCurrentOperation(&quot;Release&quot;),t.traverse(e,null)},e.activateTexture=n=>{const r=t._textureResourceIds.get(n);if(void 0!==r)return void t.context.activeTexture(t.context.TEXTURE0+r);const o=e.getTextureUnitManager().allocate();o<0?Sv(&quot;Hardware does not support the number of textures defined.&quot;):(t._textureResourceIds.set(n,o),t.context.activeTexture(t.context.TEXTURE0+o))},e.deactivateTexture=n=>{const r=t._textureResourceIds.get(n);void 0!==r&&(e.getTextureUnitManager().free(r),t._textureResourceIds.delete(n))},e.getTextureUnitForTexture=e=>{const n=t._textureResourceIds.get(e);return void 0!==n?n:-1},e.getDefaultTextureByteSize=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,r=arguments.length>2&&void 0!==arguments[2]&&arguments[2];if(t.webgl2)switch(e){case cs.CHAR:case cs.SIGNED_CHAR:case cs.UNSIGNED_CHAR:return 1;case n:case r:case cs.UNSIGNED_SHORT:case cs.SHORT:case cs.VOID:return 2;default:return 4}return 1},e.getDefaultTextureInternalFormat=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null,o=arguments.length>3&&void 0!==arguments[3]&&arguments[3];if(t.webgl2)switch(e){case cs.UNSIGNED_CHAR:switch(n){case 1:return t.context.R8;case 2:return t.context.RG8;case 3:return t.context.RGB8;default:return t.context.RGBA8}case r&&!o&&cs.UNSIGNED_SHORT:switch(n){case 1:return r.R16_EXT;case 2:return r.RG16_EXT;case 3:return r.RGB16_EXT;default:return r.RGBA16_EXT}case r&&!o&&cs.SHORT:switch(n){case 1:return r.R16_SNORM_EXT;case 2:return r.RG16_SNORM_EXT;case 3:return r.RGB16_SNORM_EXT;default:return r.RGBA16_SNORM_EXT}default:switch(n){case 1:return o?t.context.R16F:t.context.R32F;case 2:return o?t.context.RG16F:t.context.RG32F;case 3:return o?t.context.RGB16F:t.context.RGB32F;default:return o?t.context.RGBA16F:t.context.RGBA32F}}switch(n){case 1:return t.context.LUMINANCE;case 2:return t.context.LUMINANCE_ALPHA;case 3:return t.context.RGB;default:return t.context.RGBA}},e.setBackgroundImage=e=>{t.bgImage.src=e.src},e.setUseBackgroundImage=e=>{t.useBackgroundImage=e,t.useBackgroundImage&&!t.el.contains(t.bgImage)?t.el.appendChild(t.bgImage):!t.useBackgroundImage&&t.el.contains(t.bgImage)&&t.el.removeChild(t.bgImage)},e.captureNextImage=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;image/png&quot;,{resetCamera:r=!1,size:o=null,scale:a=1}=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(t.deleted)return null;t.imageFormat=n;const i=t.notifyStartCaptureImage;return t.notifyStartCaptureImage=!0,t._screenshot={size:o||1!==a?o||t.size.map((e=>e*a)):null},new Promise(((n,o)=>{const a=e.onImageReady((o=>{if(null===t._screenshot.size)t.notifyStartCaptureImage=i,a.unsubscribe(),t._screenshot.placeHolder&&(t.size=t._screenshot.originalSize,e.modified(),t._screenshot.cameras&&t._screenshot.cameras.forEach((e=>{let{restoreParamsFn:t,arg:n}=e;return t(n)})),e.traverseAllPasses(),t.el.removeChild(t._screenshot.placeHolder),t._screenshot.placeHolder.remove(),t._screenshot=null),n(o);else{const n=document.createElement(&quot;img&quot;);if(n.style=Av,n.src=o,t._screenshot.placeHolder=t.el.appendChild(n),t.canvas.style.display=&quot;none&quot;,t._screenshot.originalSize=t.size,t.size=t._screenshot.size,t.rootOpenGLRenderWindow?.resizeFromChildRenderWindows(),t._screenshot.size=null,e.modified(),r){const e=!0!==r;t._screenshot.cameras=t.renderable.getRenderers().map((t=>{const n=t.getActiveCamera(),o=n.get(&quot;focalPoint&quot;,&quot;position&quot;,&quot;parallelScale&quot;);return{resetCameraArgs:e?{renderer:t}:void 0,resetCameraFn:e?r:t.resetCamera,restoreParamsFn:n.set,arg:JSON.parse(JSON.stringify(o))}})),t._screenshot.cameras.forEach((e=>{let{resetCameraFn:t,resetCameraArgs:n}=e;return t(n)}))}e.traverseAllPasses()}}))}))},e.getHardwareMaximumLineWidth=()=>{if(null!=o)return o;const t=e.get3DContext(),n=t.getParameter(t.ALIASED_LINE_WIDTH_RANGE);return o=n[1],n[1]},e.getGLInformations=()=>{if(t._glInformation)return t._glInformation;const n=e.get3DContext(),r=n.getExtension(&quot;OES_texture_float&quot;),o=n.getExtension(&quot;OES_texture_half_float&quot;),a=n.getExtension(&quot;WEBGL_debug_renderer_info&quot;),i=n.getExtension(&quot;WEBGL_draw_buffers&quot;),s=n.getExtension(&quot;EXT_texture_filter_anisotropic&quot;)||n.getExtension(&quot;WEBKIT_EXT_texture_filter_anisotropic&quot;),l=[[&quot;Max Vertex Attributes&quot;,&quot;MAX_VERTEX_ATTRIBS&quot;,n.getParameter(n.MAX_VERTEX_ATTRIBS)],[&quot;Max Varying Vectors&quot;,&quot;MAX_VARYING_VECTORS&quot;,n.getParameter(n.MAX_VARYING_VECTORS)],[&quot;Max Vertex Uniform Vectors&quot;,&quot;MAX_VERTEX_UNIFORM_VECTORS&quot;,n.getParameter(n.MAX_VERTEX_UNIFORM_VECTORS)],[&quot;Max Fragment Uniform Vectors&quot;,&quot;MAX_FRAGMENT_UNIFORM_VECTORS&quot;,n.getParameter(n.MAX_FRAGMENT_UNIFORM_VECTORS)],[&quot;Max Fragment Texture Image Units&quot;,&quot;MAX_TEXTURE_IMAGE_UNITS&quot;,n.getParameter(n.MAX_TEXTURE_IMAGE_UNITS)],[&quot;Max Vertex Texture Image Units&quot;,&quot;MAX_VERTEX_TEXTURE_IMAGE_UNITS&quot;,n.getParameter(n.MAX_VERTEX_TEXTURE_IMAGE_UNITS)],[&quot;Max Combined Texture Image Units&quot;,&quot;MAX_COMBINED_TEXTURE_IMAGE_UNITS&quot;,n.getParameter(n.MAX_COMBINED_TEXTURE_IMAGE_UNITS)],[&quot;Max 2D Texture Size&quot;,&quot;MAX_TEXTURE_SIZE&quot;,n.getParameter(n.MAX_TEXTURE_SIZE)],[&quot;Max Cube Texture Size&quot;,&quot;MAX_CUBE_MAP_TEXTURE_SIZE&quot;,n.getParameter(n.MAX_CUBE_MAP_TEXTURE_SIZE)],[&quot;Max Texture Anisotropy&quot;,&quot;MAX_TEXTURE_MAX_ANISOTROPY_EXT&quot;,s&&n.getParameter(s.MAX_TEXTURE_MAX_ANISOTROPY_EXT)],[&quot;Point Size Range&quot;,&quot;ALIASED_POINT_SIZE_RANGE&quot;,n.getParameter(n.ALIASED_POINT_SIZE_RANGE).join(&quot; - &quot;)],[&quot;Line Width Range&quot;,&quot;ALIASED_LINE_WIDTH_RANGE&quot;,n.getParameter(n.ALIASED_LINE_WIDTH_RANGE).join(&quot; - &quot;)],[&quot;Max Viewport Dimensions&quot;,&quot;MAX_VIEWPORT_DIMS&quot;,n.getParameter(n.MAX_VIEWPORT_DIMS).join(&quot; - &quot;)],[&quot;Max Renderbuffer Size&quot;,&quot;MAX_RENDERBUFFER_SIZE&quot;,n.getParameter(n.MAX_RENDERBUFFER_SIZE)],[&quot;Framebuffer Red Bits&quot;,&quot;RED_BITS&quot;,n.getParameter(n.RED_BITS)],[&quot;Framebuffer Green Bits&quot;,&quot;GREEN_BITS&quot;,n.getParameter(n.GREEN_BITS)],[&quot;Framebuffer Blue Bits&quot;,&quot;BLUE_BITS&quot;,n.getParameter(n.BLUE_BITS)],[&quot;Framebuffer Alpha Bits&quot;,&quot;ALPHA_BITS&quot;,n.getParameter(n.ALPHA_BITS)],[&quot;Framebuffer Depth Bits&quot;,&quot;DEPTH_BITS&quot;,n.getParameter(n.DEPTH_BITS)],[&quot;Framebuffer Stencil Bits&quot;,&quot;STENCIL_BITS&quot;,n.getParameter(n.STENCIL_BITS)],[&quot;Framebuffer Subpixel Bits&quot;,&quot;SUBPIXEL_BITS&quot;,n.getParameter(n.SUBPIXEL_BITS)],[&quot;MSAA Samples&quot;,&quot;SAMPLES&quot;,n.getParameter(n.SAMPLES)],[&quot;MSAA Sample Buffers&quot;,&quot;SAMPLE_BUFFERS&quot;,n.getParameter(n.SAMPLE_BUFFERS)],[&quot;Supported Formats for UByte Render Targets     &quot;,&quot;UNSIGNED_BYTE RENDER TARGET FORMATS&quot;,[r&&wv(n,n.RGBA,n.UNSIGNED_BYTE)?&quot;RGBA&quot;:&quot;&quot;,r&&wv(n,n.RGB,n.UNSIGNED_BYTE)?&quot;RGB&quot;:&quot;&quot;,r&&wv(n,n.LUMINANCE,n.UNSIGNED_BYTE)?&quot;LUMINANCE&quot;:&quot;&quot;,r&&wv(n,n.ALPHA,n.UNSIGNED_BYTE)?&quot;ALPHA&quot;:&quot;&quot;,r&&wv(n,n.LUMINANCE_ALPHA,n.UNSIGNED_BYTE)?&quot;LUMINANCE_ALPHA&quot;:&quot;&quot;].join(&quot; &quot;)],[&quot;Supported Formats for Half Float Render Targets&quot;,&quot;HALF FLOAT RENDER TARGET FORMATS&quot;,[o&&wv(n,n.RGBA,o.HALF_FLOAT_OES)?&quot;RGBA&quot;:&quot;&quot;,o&&wv(n,n.RGB,o.HALF_FLOAT_OES)?&quot;RGB&quot;:&quot;&quot;,o&&wv(n,n.LUMINANCE,o.HALF_FLOAT_OES)?&quot;LUMINANCE&quot;:&quot;&quot;,o&&wv(n,n.ALPHA,o.HALF_FLOAT_OES)?&quot;ALPHA&quot;:&quot;&quot;,o&&wv(n,n.LUMINANCE_ALPHA,o.HALF_FLOAT_OES)?&quot;LUMINANCE_ALPHA&quot;:&quot;&quot;].join(&quot; &quot;)],[&quot;Supported Formats for Full Float Render Targets&quot;,&quot;FLOAT RENDER TARGET FORMATS&quot;,[r&&wv(n,n.RGBA,n.FLOAT)?&quot;RGBA&quot;:&quot;&quot;,r&&wv(n,n.RGB,n.FLOAT)?&quot;RGB&quot;:&quot;&quot;,r&&wv(n,n.LUMINANCE,n.FLOAT)?&quot;LUMINANCE&quot;:&quot;&quot;,r&&wv(n,n.ALPHA,n.FLOAT)?&quot;ALPHA&quot;:&quot;&quot;,r&&wv(n,n.LUMINANCE_ALPHA,n.FLOAT)?&quot;LUMINANCE_ALPHA&quot;:&quot;&quot;].join(&quot; &quot;)],[&quot;Max Multiple Render Targets Buffers&quot;,&quot;MAX_DRAW_BUFFERS_WEBGL&quot;,i?n.getParameter(i.MAX_DRAW_BUFFERS_WEBGL):0],[&quot;High Float Precision in Vertex Shader&quot;,&quot;HIGH_FLOAT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Medium Float Precision in Vertex Shader&quot;,&quot;MEDIUM_FLOAT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Low Float Precision in Vertex Shader&quot;,&quot;LOW_FLOAT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;High Float Precision in Fragment Shader&quot;,&quot;HIGH_FLOAT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Medium Float Precision in Fragment Shader&quot;,&quot;MEDIUM_FLOAT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Low Float Precision in Fragment Shader&quot;,&quot;LOW_FLOAT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;High Int Precision in Vertex Shader&quot;,&quot;HIGH_INT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Medium Int Precision in Vertex Shader&quot;,&quot;MEDIUM_INT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Low Int Precision in Vertex Shader&quot;,&quot;LOW_INT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;High Int Precision in Fragment Shader&quot;,&quot;HIGH_INT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Medium Int Precision in Fragment Shader&quot;,&quot;MEDIUM_INT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Low Int Precision in Fragment Shader&quot;,&quot;LOW_INT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Supported Extensions&quot;,&quot;EXTENSIONS&quot;,n.getSupportedExtensions().join(&quot;<br/>\\t\\t\\t\\t\\t    &quot;)],[&quot;WebGL Renderer&quot;,&quot;RENDERER&quot;,n.getParameter(n.RENDERER)],[&quot;WebGL Vendor&quot;,&quot;VENDOR&quot;,n.getParameter(n.VENDOR)],[&quot;WebGL Version&quot;,&quot;VERSION&quot;,n.getParameter(n.VERSION)],[&quot;Shading Language Version&quot;,&quot;SHADING_LANGUAGE_VERSION&quot;,n.getParameter(n.SHADING_LANGUAGE_VERSION)],[&quot;Unmasked Renderer&quot;,&quot;UNMASKED_RENDERER&quot;,a&&n.getParameter(a.UNMASKED_RENDERER_WEBGL)],[&quot;Unmasked Vendor&quot;,&quot;UNMASKED_VENDOR&quot;,a&&n.getParameter(a.UNMASKED_VENDOR_WEBGL)],[&quot;WebGL Version&quot;,&quot;WEBGL_VERSION&quot;,t.webgl2?2:1]],c={};for(;l.length;){const[e,t,n]=l.pop();t&&(c[t]={label:e,value:n})}return t._glInformation=c,c},e.traverseAllPasses=()=>{if(t.renderPasses)for(let n=0;n<t.renderPasses.length;++n)t.renderPasses[n].traverse(e,null);e.copyParentContent(),t.notifyStartCaptureImage&&function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:t.imageFormat;const r=document.createElement(&quot;canvas&quot;),o=r.getContext(&quot;2d&quot;);r.width=t.canvas.width,r.height=t.canvas.height,o.drawImage(t.canvas,0,0);const a=t.canvas.getBoundingClientRect();t.renderable.getRenderers().forEach((e=>{e.getViewProps().forEach((e=>{if(e.getContainer){const t=e.getContainer().getElementsByTagName(&quot;canvas&quot;);for(let e=0;e<t.length;e++){const n=t[e],r=n.getBoundingClientRect(),i=r.x-a.x,s=r.y-a.y;o.drawImage(n,i,s)}}}))}));const i=r.toDataURL(n);r.remove(),e.invokeImageReady(i)}();const n=t.renderable.getChildRenderWindowsByReference();for(let t=0;t<n.length;++t)e.getViewNodeFor(n[t])?.traverseAllPasses()},e.copyParentContent=()=>{const e=t.rootOpenGLRenderWindow;if(!e||!t.context2D||t.children.some((e=>!!e.getSelector?.())))return;const n=e.getCanvas(),r=t.canvas;t.context2D.drawImage(n,0,n.height-r.height,r.width,r.height,0,0,r.width,r.height)},e.resizeFromChildRenderWindows=()=>{const n=t.renderable.getChildRenderWindowsByReference();if(n.length>0){const t=[0,0];for(let r=0;r<n.length;++r){const o=e.getViewNodeFor(n[r])?.getSize();o&&(t[0]=o[0]>t[0]?o[0]:t[0],t[1]=o[1]>t[1]?o[1]:t[1])}e.setSize(...t)}},e.disableCullFace=()=>{t.cullFaceEnabled&&(t.context.disable(t.context.CULL_FACE),t.cullFaceEnabled=!1)},e.enableCullFace=()=>{t.cullFaceEnabled||(t.context.enable(t.context.CULL_FACE),t.cullFaceEnabled=!0)},e.setViewStream=n=>t.viewStream!==n&&(t.subscription&&(t.subscription.unsubscribe(),t.subscription=null),t.viewStream=n,t.viewStream&&(t.renderable.getRenderers()[0].getBackgroundByReference()[3]=0,e.setUseBackgroundImage(!0),t.subscription=t.viewStream.onImageReady((t=>e.setBackgroundImage(t.image))),t.viewStream.setSize(t.size[0],t.size[1]),t.viewStream.invalidateCache(),t.viewStream.render(),e.modified()),!0),e.createSelector=()=>{const t=Gp.newInstance();return t.setOpenGLRenderWindow(e),t},e.delete=Wt.chain((()=>{t.context&&(Ov--,Pv.forEach((e=>e(Ov)))),e.setContainer(),e.setViewStream()}),(function(){t.canvas.removeEventListener(&quot;webglcontextlost&quot;,Rv),t.canvas.removeEventListener(&quot;webglcontextrestored&quot;,e.restoreContext)}),e.delete),e.setActiveFramebuffer=e=>{t.activeFramebuffer=e};const a=e.setSize;e.setSize=(t,n)=>{const r=a(t,n);return r&&e.invokeWindowResizeEvent({width:t,height:n}),r},e.registerGraphicsResourceUser=(n,r)=>{t._graphicsResources.has(n)||e.setGraphicsResourceForObject(n,null,null);const o=t._graphicsResources.get(n);o?.users.add(r)},e.unregisterGraphicsResourceUser=(n,r)=>{const o=t._graphicsResources.get(n);o&&(o.users.delete(r),o.users.size||(o.oglObject?.releaseGraphicsResources(e),t._graphicsResources.delete(n)))},e.getGraphicsResourceForObject=e=>t._graphicsResources.get(e),e.setGraphicsResourceForObject=(n,r,o)=>{if(!n)return;const a=t._graphicsResources.get(n);a?.oglObject?.releaseGraphicsResources(e),t._graphicsResources.set(n,{coreObject:n,oglObject:r,hash:o,users:a?.users??new Set})},e.getGraphicsMemoryInfo=()=>{let e=0;return t._graphicsResources.forEach((t=>{let{oglObject:n}=t;e+=n.getAllocatedGPUMemoryInBytes()})),e},e.releaseGraphicsResources=()=>{null!==t.shaderCache&&t.shaderCache.releaseGraphicsResources(e),t._graphicsResources.forEach((t=>{let{oglObject:n}=t;n.releaseGraphicsResources(e)})),t._graphicsResources.clear(),null!==t.textureUnitManager&&t.textureUnitManager.freeAll(),t.renderable.getRenderersByReference().forEach((t=>{const n=e.getViewNodeFor(t);n?.releaseGraphicsResources()}))};const i={...e};Iv.forEach((n=>{e[n]=function(){return t.rootOpenGLRenderWindow?t.rootOpenGLRenderWindow[n](...arguments):i[n](...arguments)}}))}const Ev={cullFaceEnabled:!1,shaderCache:null,initialized:!1,context:null,context2D:null,canvas:null,cursorVisibility:!0,cursor:&quot;pointer&quot;,textureUnitManager:null,textureResourceIds:null,containerSize:null,renderPasses:[],notifyStartCaptureImage:!1,webgl2:!1,defaultToWebgl2:!0,activeFramebuffer:null,imageFormat:&quot;image/png&quot;,useOffScreen:!1,useBackgroundImage:!1};const Vv=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ev,n),xv.extend(e,t,n),t.canvas||(t.canvas=document.createElement(&quot;canvas&quot;),t.canvas.style.width=&quot;100%&quot;),t.selector||(t.selector=Gp.newInstance(),t.selector.setOpenGLRenderWindow(e)),t.bgImage=new Image,t.bgImage.style.position=&quot;absolute&quot;,t.bgImage.style.left=&quot;0&quot;,t.bgImage.style.top=&quot;0&quot;,t.bgImage.style.width=&quot;100%&quot;,t.bgImage.style.height=&quot;100%&quot;,t.bgImage.style.zIndex=&quot;-1&quot;,t._textureResourceIds=new Map,t._graphicsResources=new Map,t._glInformation=null,t.myFactory=nn.newInstance(),t.shaderCache=gv.newInstance(),t.shaderCache.setOpenGLRenderWindow(e),t.renderPasses[0]=cv.newInstance(),Wt.get(e,t,[&quot;shaderCache&quot;,&quot;textureUnitManager&quot;,&quot;webgl2&quot;,&quot;useBackgroundImage&quot;,&quot;activeFramebuffer&quot;,&quot;rootOpenGLRenderWindow&quot;]),Wt.setGet(e,t,[&quot;initialized&quot;,&quot;context&quot;,&quot;context2D&quot;,&quot;canvas&quot;,&quot;renderPasses&quot;,&quot;notifyStartCaptureImage&quot;,&quot;defaultToWebgl2&quot;,&quot;cursor&quot;,&quot;useOffScreen&quot;]),Wt.setGetArray(e,t,[&quot;size&quot;],2),Wt.event(e,t,&quot;imageReady&quot;),Wt.event(e,t,&quot;windowResizeEvent&quot;),Mv(e,t)}),&quot;vtkOpenGLRenderWindow&quot;);ph(&quot;WebGL&quot;,Vv),Jt(&quot;vtkRenderWindow&quot;,Vv);const Dv={device:null,handle:null};function Lv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Dv,n),Wt.obj(e,t),Wt.get(e,t,[&quot;lastCameraMTime&quot;]),Wt.setGet(e,t,[&quot;device&quot;,&quot;handle&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUShaderModule&quot;),e.initialize=(e,n)=>{t.device=e,t.handle=t.device.getHandle().createShaderModule({code:n.getCode()})}}(e,t)}var Bv={newInstance:Wt.newInstance(Lv,&quot;vtkWebGPUShaderModule&quot;),extend:Lv};const Nv={shaderModules:null,device:null,window:null};function Fv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Nv,n),t._shaderModules=new Map,Wt.obj(e,t),Wt.setGet(e,t,[&quot;device&quot;,&quot;window&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUShaderCache&quot;),e.getShaderModule=e=>{const n=e.getType(),r=e.getHash(),o=t._shaderModules.keys();for(let e=0;e<o.length;e++){const a=o[e];if(a.getHash()===r&&a.getType()===n)return t._shaderModules.get(a)}const a=Bv.newInstance();return a.initialize(t.device,e),t._shaderModules.set(e,a),a}}(e,t)}var _v={newInstance:Wt.newInstance(Fv,&quot;vtkWebGPUShaderCache&quot;),extend:Fv,substitute:function(e,t,n){let r=!(arguments.length>3&&void 0!==arguments[3])||arguments[3];const o=Array.isArray(n)?n.join(&quot;\\n&quot;):n;let a=!1;-1!==e.search(t)&&(a=!0);let i=&quot;&quot;;r&&(i=&quot;g&quot;);const s=new RegExp(t,i);return{replace:a,result:e.replace(s,o)}}};const kv={device:null,handle:null,label:null};function Gv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,kv,n),Wt.obj(e,t),t.bindables=[],t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),Wt.get(e,t,[&quot;bindGroupTime&quot;,&quot;handle&quot;,&quot;sizeInBytes&quot;,&quot;usage&quot;]),Wt.setGet(e,t,[&quot;label&quot;,&quot;device&quot;,&quot;arrayInformation&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUBindGroup&quot;),e.setBindables=n=>{if(t.bindables.length===n.length){let e=!0;for(let r=0;r<t.bindables.length;r++)t.bindables[r]!==n[r]&&(e=!1);if(e)return}t.bindables=n,e.modified()},e.getBindGroupLayout=e=>{const n=[];for(let e=0;e<t.bindables.length;e++){const r=t.bindables[e].getBindGroupLayoutEntry();r.binding=e,n.push(r)}return e.getBindGroupLayout({entries:n})},e.getBindGroup=n=>{let r=e.getMTime();for(let e=0;e<t.bindables.length;e++){const n=t.bindables[e].getBindGroupTime().getMTime();r=n>r?n:r}if(r<t.bindGroupTime.getMTime())return t.bindGroup;const o=[];for(let e=0;e<t.bindables.length;e++){const n=t.bindables[e].getBindGroupEntry();n.binding=e,o.push(n)}return t.bindGroup=n.getHandle().createBindGroup({layout:e.getBindGroupLayout(n),entries:o,label:t.label}),t.bindGroupTime.modified(),t.bindGroup},e.getShaderCode=e=>{const n=[],r=e.getBindGroupLayoutCount(t.label);for(let e=0;e<t.bindables.length;e++)n.push(t.bindables[e].getShaderCode(e,r));return n.join(&quot;\\n&quot;)}}(e,t)}var Uv={newInstance:Wt.newInstance(Gv),extend:Gv};const zv={handle:null,layouts:null,renderEncoder:null,shaderDescriptions:null,vertexState:null,topology:null,pipelineDescription:null};function Wv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,zv,n),ht(e,t),t.layouts=[],t.shaderDescriptions=[],Tt(e,t,[&quot;handle&quot;,&quot;pipelineDescription&quot;]),Ct(e,t,[&quot;device&quot;,&quot;renderEncoder&quot;,&quot;topology&quot;,&quot;vertexState&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUPipeline&quot;),e.getShaderDescriptions=()=>t.shaderDescriptions,e.initialize=(e,n)=>{t.pipelineDescription=t.renderEncoder.getPipelineSettings(),t.pipelineDescription.primitive.topology=t.topology,t.pipelineDescription.vertex=t.vertexState,t.pipelineDescription.label=n;const r=[];for(let e=0;e<t.layouts.length;e++)r.push(t.layouts[e].layout);t.pipelineLayout=e.getHandle().createPipelineLayout({bindGroupLayouts:r}),t.pipelineDescription.layout=t.pipelineLayout;for(let n=0;n<t.shaderDescriptions.length;n++){const r=t.shaderDescriptions[n],o=e.getShaderModule(r);&quot;vertex&quot;===r.getType()&&(t.pipelineDescription.vertex.module=o.getHandle(),t.pipelineDescription.vertex.entryPoint=&quot;main&quot;),&quot;fragment&quot;===r.getType()&&(t.pipelineDescription.fragment.module=o.getHandle(),t.pipelineDescription.fragment.entryPoint=&quot;main&quot;)}t.handle=e.getHandle().createRenderPipeline(t.pipelineDescription)},e.getShaderDescription=e=>{for(let n=0;n<t.shaderDescriptions.length;n++)if(t.shaderDescriptions[n].getType()===e)return t.shaderDescriptions[n];return null},e.addBindGroupLayout=e=>{e&&t.layouts.push({layout:e.getBindGroupLayout(t.device),label:e.getLabel()})},e.getBindGroupLayout=e=>t.layouts[e].layout,e.getBindGroupLayoutCount=e=>{for(let n=0;n<t.layouts.length;n++)if(t.layouts[n].label===e)return n;return 0},e.bindVertexInput=(e,t)=>{t.bindBuffers(e)}}(e,t)}var Hv={newInstance:Mt(Wv,&quot;vtkWebGPUPipeline&quot;),extend:Wv};const jv={type:null,hash:null,code:null,outputNames:null,outputTypes:null};function Kv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,jv,n),t.outputNames=[],t.outputTypes=[],t.outputInterpolations=[],t.builtinOutputNames=[],t.builtinOutputTypes=[],t.builtinInputNames=[],t.builtinInputTypes=[],Wt.obj(e,t),Wt.setGet(e,t,[&quot;type&quot;,&quot;hash&quot;,&quot;code&quot;]),Wt.getArray(e,t,[&quot;outputTypes&quot;,&quot;outputNames&quot;,&quot;outputInterpolations&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUShaderDescription&quot;),e.hasOutput=e=>t.outputNames.includes(e),e.addOutput=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:void 0;t.outputTypes.push(e),t.outputNames.push(n),t.outputInterpolations.push(r)},e.addBuiltinOutput=(e,n)=>{t.builtinOutputTypes.push(e),t.builtinOutputNames.push(n)},e.addBuiltinInput=(e,n)=>{t.builtinInputTypes.push(e),t.builtinInputNames.push(n)},e.replaceShaderCode=(e,n)=>{const r=[];let o=[];if(n&&r.push(n.getShaderCode()),e||t.builtinInputNames.length){const n=[];if(n.push(`struct ${t.type}Input\\n{`),e){const t=e.getOutputNamesByReference(),r=e.getOutputTypesByReference(),o=e.getOutputInterpolationsByReference();for(let e=0;e<t.length;e++)void 0!==o[e]?n.push(`  @location(${e}) @interpolate(${o[e]}) ${t[e]} : ${r[e]},`):n.push(`  @location(${e}) ${t[e]} : ${r[e]},`)}for(let e=0;e<t.builtinInputNames.length;e++)n.push(`  ${t.builtinInputNames[e]} : ${t.builtinInputTypes[e]},`);n.length>1&&(n.push(&quot;};&quot;),o=n,r[r.length-1]+=&quot;,&quot;,r.push(`input: ${t.type}Input`))}if(r.length&&(t.code=_v.substitute(t.code,&quot;//VTK::IOStructs::Input&quot;,r).result),t.outputNames.length+t.builtinOutputNames.length){const e=[`struct ${t.type}Output\\n{`];for(let n=0;n<t.outputNames.length;n++)void 0!==t.outputInterpolations[n]?e.push(`  @location(${n}) @interpolate(${t.outputInterpolations[n]}) ${t.outputNames[n]} : ${t.outputTypes[n]},`):e.push(`  @location(${n}) ${t.outputNames[n]} : ${t.outputTypes[n]},`);for(let n=0;n<t.builtinOutputNames.length;n++)e.push(`  ${t.builtinOutputNames[n]} : ${t.builtinOutputTypes[n]},`);e.push(&quot;};&quot;),o=o.concat(e),t.code=_v.substitute(t.code,&quot;//VTK::IOStructs::Output&quot;,[`-> ${t.type}Output`]).result}t.code=_v.substitute(t.code,&quot;//VTK::IOStructs::Dec&quot;,o).result}}(e,t)}var $v={newInstance:Wt.newInstance(Kv,&quot;vtkWebGPUShaderDescription&quot;),extend:Kv};const qv={r8unorm:{numComponents:1,nativeType:Uint8Array,stride:1,elementSize:1,sampleType:&quot;float&quot;},r8snorm:{numComponents:1,nativeType:Int8Array,stride:1,elementSize:1,sampleType:&quot;float&quot;},r8uint:{numComponents:1,nativeType:Uint8Array,stride:1,elementSize:1,sampleType:&quot;uint&quot;},r8sint:{numComponents:1,nativeType:Int8Array,stride:1,elementSize:1,sampleType:&quot;sint&quot;},r16uint:{numComponents:1,nativeType:Uint16Array,stride:2,elementSize:2,sampleType:&quot;uint&quot;},r16sint:{numComponents:1,nativeType:Int16Array,stride:2,elementSize:2,sampleType:&quot;sint&quot;},r16float:{numComponents:1,nativeType:Float32Array,stride:2,elementSize:2,sampleType:&quot;float&quot;},rg8unorm:{numComponents:2,nativeType:Uint8Array,stride:2,elementSize:1,sampleType:&quot;float&quot;},rg8snorm:{numComponents:2,nativeType:Int8Array,stride:2,elementSize:1,sampleType:&quot;float&quot;},rg8uint:{numComponents:2,nativeType:Uint8Array,stride:2,elementSize:1,sampleType:&quot;uint&quot;},rg8sint:{numComponents:2,nativeType:Int8Array,stride:2,elementSize:1,sampleType:&quot;sint&quot;},r32uint:{numComponents:1,nativeType:Uint32Array,stride:4,elementSize:4,sampleType:&quot;uint&quot;},r32sint:{numComponents:1,nativeType:Int32Array,stride:4,elementSize:4,sampleType:&quot;sint&quot;},r32float:{numComponents:1,nativeType:Float32Array,stride:4,elementSize:4,sampleType:&quot;unfilterable-float&quot;},rg16uint:{numComponents:2,nativeType:Uint16Array,stride:4,elementSize:2,sampleType:&quot;uint&quot;},rg16sint:{numComponents:2,nativeType:Int16Array,stride:4,elementSize:2,sampleType:&quot;sint&quot;},rg16float:{numComponents:2,nativeType:Float32Array,stride:4,elementSize:2,sampleType:&quot;float&quot;},rgba8unorm:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},&quot;rgba8unorm-srgb&quot;:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},rgba8snorm:{numComponents:4,nativeType:Int8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},rgba8uint:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;uint&quot;},rgba8sint:{numComponents:4,nativeType:Int8Array,stride:4,elementSize:1,sampleType:&quot;sint&quot;},bgra8unorm:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},&quot;bgra8unorm-srgb&quot;:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},rgb9e5ufloat:{numComponents:4,nativeType:Uint32Array,stride:4,sampleType:&quot;float&quot;},rgb10a2unorm:{numComponents:4,nativeType:Uint32Array,stride:4,sampleType:&quot;float&quot;},rg11b10ufloat:{numComponents:4,nativeType:Float32Array,stride:4,sampleType:&quot;float&quot;},rg32uint:{numComponents:2,nativeType:Uint32Array,stride:8,elementSize:4,sampleType:&quot;uint&quot;},rg32sint:{numComponents:2,nativeType:Int32Array,stride:8,elementSize:4,sampleType:&quot;sint&quot;},rg32float:{numComponents:2,nativeType:Float32Array,stride:8,elementSize:4,sampleType:&quot;unfilterable-float&quot;},rgba16uint:{numComponents:4,nativeType:Uint16Array,stride:8,elementSize:2,sampleType:&quot;uint&quot;},rgba16sint:{numComponents:4,nativeType:Int16Array,stride:8,elementSize:2,sampleType:&quot;sint&quot;},rgba16float:{numComponents:4,nativeType:Float32Array,stride:8,elementSize:2,sampleType:&quot;float&quot;},rgba32uint:{numComponents:4,nativeType:Uint32Array,stride:16,elementSize:4,sampleType:&quot;uint&quot;},rgba32sint:{numComponents:4,nativeType:Int32Array,stride:16,elementSize:4,sampleType:&quot;sint&quot;},rgba32float:{numComponents:4,nativeType:Float32Array,stride:16,elementSize:4,sampleType:&quot;unfilterable-float&quot;},stencil8:{numComponents:1,nativeType:Uint8Array,stride:1,elementSize:1,sampleType:&quot;uint&quot;},depth16unorm:{numComponents:1,nativeType:Uint16Array,stride:2,elementSize:2,sampleType:&quot;depth&quot;},depth24plus:{numComponents:1,nativeType:Uint32Array,stride:4,elementSize:3,sampleType:&quot;depth&quot;},&quot;depth24plus-stencil8&quot;:{numComponents:2,nativeType:Uint32Array,stride:4,sampleType:&quot;mixed&quot;},depth32float:{numComponents:1,nativeType:Float32Array,stride:4,elementSize:4,sampleType:&quot;depth&quot;}};var Xv=function(e){return!e||e.length<6?0:e in qv==1?qv[e]:(et(`unknown format ${e}`),null)},Yv=function(e){if(!e||e.length<5)return 0;let t=1;&quot;x&quot;===e[e.length-2]&&(t=Number(e[e.length-1]));const n=1===t?e.length-1:e.length-3,r=Number(e[n]);return Number.isNaN(r)?(et(`unknown format ${e}`),0):t*(5-r/2)},Zv=function(e){if(!e||e.length<5)return 0;let t;if(&quot;f&quot;===e[0])t=&quot;Float&quot;;else if(&quot;s&quot;===e[0])t=&quot;Int&quot;;else{if(&quot;u&quot;!==e[0])return void et(`unknown format ${e}`);t=&quot;Uint&quot;}const n=e.split(&quot;x&quot;)[0],r=Number(n[n.length-1]);if(!Number.isNaN(r))return t+=8*(5-r/2),t+=&quot;Array&quot;,t;et(`unknown format ${e}`)},Qv=function(e){let t;if(&quot;f&quot;===e[0]||&quot;n&quot;===e[1])t=&quot;f32&quot;;else if(&quot;s&quot;===e[0]&&&quot;i&quot;===e[1])t=&quot;i32&quot;;else{if(&quot;u&quot;!==e[0]||&quot;i&quot;!==e[1])return void et(`unknown format ${e}`);t=&quot;u32&quot;}let n=1;return&quot;x&quot;===e[e.length-2]&&(n=Number(e[e.length-1])),4===n?`vec4<${t}>`:3===n?`vec3<${t}>`:2===n?`vec2<${t}>`:t},Jv=function(e){if(!e)return 0;let t=1;return&quot;vec&quot;===e.substring(0,3)?t=Number(e[3]):&quot;mat&quot;===e.substring(0,3)&&(t=e[3]*e[5]),4*t},eT=function(e){if(e)return e.includes(&quot;f32&quot;)?&quot;Float32Array&quot;:e.includes(&quot;i32&quot;)?&quot;Int32Array&quot;:e.includes(&quot;u32&quot;)?&quot;Uint32Array&quot;:void et(`unknown format ${e}`)};function tT(e,t){if(e===t)return!0;if(null==e||null==t)return!1;if(e.length!==t.length)return!1;for(let n=0;n<e.length;++n)if(!t.includes(e[n]))return!1;return!0}const nT={inputs:null,bindingDescriptions:!1,attributeDescriptions:null,indexBuffer:null};function rT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,nT,n),ht(e,t),t.bindingDescriptions=[],t.attributeDescriptions=[],t.inputs=[],Ct(e,t,[&quot;created&quot;,&quot;device&quot;,&quot;handle&quot;,&quot;indexBuffer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUVertexInput&quot;),e.addBuffer=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:&quot;vertex&quot;,o=n;Array.isArray(o)||(o=[o]);for(let n=0;n<t.inputs.length;n++)if(tT(t.inputs[n].names,o)){if(t.inputs[n].buffer===e)return;return void(t.inputs[n].buffer=e)}t.inputs.push({buffer:e,stepMode:r,names:o}),t.inputs=t.inputs.sort(((e,t)=>e.names[0]<t.names[0]?-1:e.names[0]>t.names[0]?1:0))},e.removeBufferIfPresent=e=>{for(let n=0;n<t.inputs.length;n++)t.inputs[n].names.includes(e)&&t.inputs.splice(n,1)},e.getBuffer=e=>{for(let n=0;n<t.inputs.length;n++)if(t.inputs[n].names.includes(e))return t.inputs[n].buffer;return null},e.hasAttribute=e=>{for(let n=0;n<t.inputs.length;n++)if(t.inputs[n].names.includes(e))return!0;return!1},e.getAttributeTime=e=>{for(let n=0;n<t.inputs.length;n++)if(t.inputs[n].names.includes(e))return t.inputs[n].buffer.getSourceTime();return 0},e.getShaderCode=()=>{let e=&quot;&quot;,n=0;for(let r=0;r<t.inputs.length;r++)for(let o=0;o<t.inputs[r].names.length;o++){const a=t.inputs[r].buffer.getArrayInformation()[o],i=Qv(a.format);n>0&&(e+=&quot;,\\n&quot;),e=`${e}  @location(${n}) ${t.inputs[r].names[o]} : ${i}`,n++}return e},e.getVertexInputInformation=()=>{const e={};if(t.inputs.length){const n=[];let r=0;for(let e=0;e<t.inputs.length;e++){const o=t.inputs[e].buffer,a={arrayStride:o.getStrideInBytes(),stepMode:t.inputs[e].stepMode,attributes:[]},i=o.getArrayInformation();for(let n=0;n<t.inputs[e].names.length;n++)a.attributes.push({shaderLocation:r,offset:i[n].offset,format:i[n].format}),r++;n.push(a)}e.buffers=n}return e},e.bindBuffers=e=>{for(let n=0;n<t.inputs.length;n++)e.setVertexBuffer(n,t.inputs[n].buffer.getHandle());t.indexBuffer&&e.setIndexBuffer(t.indexBuffer.getHandle(),t.indexBuffer.getArrayInformation()[0].format)},e.getReady=()=>{},e.releaseGraphicsResources=()=>{t.created&&(t.inputs=[],t.bindingDescriptions=[],t.attributeDescriptions=[])}}(e,t)}var oT={newInstance:Mt(rT,&quot;vtkWebGPUVertexInput&quot;),extend:rT};const aT={additionalBindables:void 0,bindGroup:null,device:null,fragmentShaderTemplate:null,numberOfInstances:1,numberOfVertices:0,pipelineHash:null,shaderReplacements:null,SSBO:null,textureViews:null,topology:&quot;triangle-list&quot;,UBO:null,vertexShaderTemplate:null,WebGPURenderer:null};function iT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,aT,n),qt.extend(e,t,n),t.textureViews=[],t.vertexInput=oT.newInstance(),t.bindGroup=Uv.newInstance({label:&quot;mapperBG&quot;}),t.additionalBindables=[],t.fragmentShaderTemplate=t.fragmentShaderTemplate||&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Color::Dec\\n\\n//VTK::Normal::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::Select::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output : fragmentOutput;\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::Light::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Select::Impl\\n\\n  // var computedColor:vec4<f32> = vec4<f32>(1.0,0.5,0.5,1.0);\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;,t.vertexShaderTemplate=t.vertexShaderTemplate||&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Color::Dec\\n\\n//VTK::Normal::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::Select::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@vertex\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output : vertexOutput;\\n\\n  // var vertex: vec4<f32> = vertexBC;\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Select::Impl\\n\\n  //VTK::Position::Impl\\n\\n  return output;\\n}\\n&quot;,t.shaderReplacements=new Map,Wt.get(e,t,[&quot;pipeline&quot;,&quot;vertexInput&quot;]),Wt.setGet(e,t,[&quot;additionalBindables&quot;,&quot;device&quot;,&quot;fragmentShaderTemplate&quot;,&quot;interpolate&quot;,&quot;numberOfInstances&quot;,&quot;numberOfVertices&quot;,&quot;pipelineHash&quot;,&quot;shaderReplacements&quot;,&quot;SSBO&quot;,&quot;textureViews&quot;,&quot;topology&quot;,&quot;UBO&quot;,&quot;vertexShaderTemplate&quot;,&quot;WebGPURenderer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUSimpleMapper&quot;),e.generateShaderDescriptions=(n,r,o)=>{const a=$v.newInstance({type:&quot;vertex&quot;,hash:n,code:t.vertexShaderTemplate}),i=$v.newInstance({type:&quot;fragment&quot;,hash:n,code:t.fragmentShaderTemplate}),s=r.getShaderDescriptions();s.push(a),s.push(i);const l=t.vertexShaderTemplate+t.fragmentShaderTemplate,c=new RegExp(&quot;//VTK::[^:]*::&quot;,&quot;g&quot;),u=l.match(c).filter(((e,t,n)=>n.indexOf(e)===t)),d=u.map((e=>`replaceShader${e.substring(7,e.length-2)}`));for(let e=0;e<d.length;e++){const a=d[e];&quot;replaceShaderIOStructs&quot;!==a&&t.shaderReplacements.has(a)&&t.shaderReplacements.get(a)(n,r,o)}e.replaceShaderIOStructs(n,r,o)},e.replaceShaderIOStructs=(e,t,n)=>{const r=t.getShaderDescription(&quot;vertex&quot;);r.replaceShaderCode(null,n),t.getShaderDescription(&quot;fragment&quot;).replaceShaderCode(r)},e.replaceShaderRenderEncoder=(e,n,r)=>{t.renderEncoder.replaceShaderCode(n)},t.shaderReplacements.set(&quot;replaceShaderRenderEncoder&quot;,e.replaceShaderRenderEncoder),e.replaceShaderRenderer=(e,n,r)=>{if(!t.WebGPURenderer)return;const o=t.WebGPURenderer.getBindGroup().getShaderCode(n),a=n.getShaderDescription(&quot;vertex&quot;);let i=a.getCode();i=_v.substitute(i,&quot;//VTK::Renderer::Dec&quot;,[o]).result,a.setCode(i);const s=n.getShaderDescription(&quot;fragment&quot;);i=s.getCode(),i=_v.substitute(i,&quot;//VTK::Renderer::Dec&quot;,[o]).result,s.setCode(i)},t.shaderReplacements.set(&quot;replaceShaderRenderer&quot;,e.replaceShaderRenderer),e.replaceShaderMapper=(e,n,r)=>{const o=t.bindGroup.getShaderCode(n),a=n.getShaderDescription(&quot;vertex&quot;);let i=a.getCode();i=_v.substitute(i,&quot;//VTK::Mapper::Dec&quot;,[o]).result,a.setCode(i);const s=n.getShaderDescription(&quot;fragment&quot;);s.addBuiltinInput(&quot;bool&quot;,&quot;@builtin(front_facing) frontFacing&quot;),i=s.getCode(),i=_v.substitute(i,&quot;//VTK::Mapper::Dec&quot;,[o]).result,s.setCode(i)},t.shaderReplacements.set(&quot;replaceShaderMapper&quot;,e.replaceShaderMapper),e.replaceShaderPosition=(e,t,n)=>{const r=t.getShaderDescription(&quot;vertex&quot;);r.addBuiltinOutput(&quot;vec4<f32>&quot;,&quot;@builtin(position) Position&quot;);let o=r.getCode();o=_v.substitute(o,&quot;//VTK::Position::Impl&quot;,[&quot;    output.Position = rendererUBO.SCPCMatrix*vertexBC;&quot;]).result,r.setCode(o)},t.shaderReplacements.set(&quot;replaceShaderPosition&quot;,e.replaceShaderPosition),e.replaceShaderTCoord=(e,t,n)=>{t.getShaderDescription(&quot;vertex&quot;).addOutput(&quot;vec2<f32>&quot;,&quot;tcoordVS&quot;)},t.shaderReplacements.set(&quot;replaceShaderTCoord&quot;,e.replaceShaderTCoord),e.addTextureView=e=>{t.textureViews.includes(e)||t.textureViews.push(e)},e.prepareToDraw=n=>{t.renderEncoder=n,e.updateInput(),e.updateBuffers(),e.updateBindings(),e.updatePipeline()},e.updateInput=()=>{},e.updateBuffers=()=>{},e.updateBindings=()=>{t.bindGroup.setBindables(e.getBindables())},e.computePipelineHash=()=>{},e.registerDrawCallback=n=>{n.registerDrawCallback(t.pipeline,e.draw)},e.prepareAndDraw=n=>{e.prepareToDraw(n),n.setPipeline(t.pipeline),e.draw(n)},e.draw=e=>{const n=e.getBoundPipeline();e.activateBindGroup(t.bindGroup),t.WebGPURenderer&&t.WebGPURenderer.bindUBO(e),n.bindVertexInput(e,t.vertexInput);const r=t.vertexInput.getIndexBuffer();r?e.drawIndexed(r.getIndexCount(),t.numberOfInstances,0,0,0):e.draw(t.numberOfVertices,t.numberOfInstances,0,0)},e.getBindables=()=>{const e=[...t.additionalBindables];t.UBO&&e.push(t.UBO),t.SSBO&&e.push(t.SSBO);for(let n=0;n<t.textureViews.length;n++){e.push(t.textureViews[n]);const r=t.textureViews[n].getSampler();r&&e.push(r)}return e},e.updatePipeline=()=>{e.computePipelineHash(),t.pipeline=t.device.getPipeline(t.pipelineHash),t.pipeline||(t.pipeline=Hv.newInstance(),t.pipeline.setDevice(t.device),t.WebGPURenderer&&t.pipeline.addBindGroupLayout(t.WebGPURenderer.getBindGroup()),t.pipeline.addBindGroupLayout(t.bindGroup),e.generateShaderDescriptions(t.pipelineHash,t.pipeline,t.vertexInput),t.pipeline.setTopology(t.topology),t.pipeline.setRenderEncoder(t.renderEncoder),t.pipeline.setVertexState(t.vertexInput.getVertexInputInformation()),t.device.createPipeline(t.pipelineHash,t.pipeline))}}(e,t)}var sT={newInstance:Wt.newInstance(iT,&quot;vtkWebGPUSimpleMapper&quot;),extend:iT};const lT={};function cT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,lT,n),sT.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUFullScreenQuad&quot;),e.replaceShaderPosition=(e,t,n)=>{const r=t.getShaderDescription(&quot;vertex&quot;);r.addBuiltinOutput(&quot;vec4<f32>&quot;,&quot;@builtin(position) Position&quot;),r.addOutput(&quot;vec4<f32>&quot;,&quot;vertexVC&quot;);let o=r.getCode();o=_v.substitute(o,&quot;//VTK::Position::Impl&quot;,[&quot;output.tcoordVS = vec2<f32>(vertexBC.x * 0.5 + 0.5, 1.0 - vertexBC.y * 0.5 - 0.5);&quot;,&quot;output.Position = vec4<f32>(vertexBC, 1.0);&quot;,&quot;output.vertexVC = vec4<f32>(vertexBC, 1);&quot;]).result,r.setCode(o)},t.shaderReplacements.set(&quot;replaceShaderPosition&quot;,e.replaceShaderPosition),e.updateBuffers=()=>{const e=t.device.getBufferManager().getFullScreenQuadBuffer();t.vertexInput.addBuffer(e,[&quot;vertexBC&quot;]),t.numberOfVertices=6}}(e,t)}var uT={newInstance:Wt.newInstance(cT,&quot;vtkWebGPUFullScreenQuad&quot;),extend:cT};const dT=[&quot;setBindGroup&quot;,&quot;setIndexBuffer&quot;,&quot;setVertexBuffer&quot;,&quot;draw&quot;,&quot;drawIndexed&quot;],pT={description:null,handle:null,boundPipeline:null,pipelineHash:null,pipelineSettings:null,replaceShaderCodeFunction:null,depthTextureView:null,label:null};function fT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,pT,n),ht(e,t),t.description={colorAttachments:[{view:void 0,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}],depthStencilAttachment:{view:void 0,depthLoadOp:&quot;clear&quot;,depthClearValue:0,depthStoreOp:&quot;store&quot;}},t.replaceShaderCodeFunction=e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor = computedColor;&quot;]).result,t.setCode(n)},t.pipelineSettings={primitive:{cullMode:&quot;none&quot;},depthStencil:{depthWriteEnabled:!0,depthCompare:&quot;greater-equal&quot;,format:&quot;depth32float&quot;},fragment:{targets:[{format:&quot;rgba16float&quot;,blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}},t.colorTextureViews=[],Tt(e,t,[&quot;boundPipeline&quot;,&quot;colorTextureViews&quot;]),Ct(e,t,[&quot;depthTextureView&quot;,&quot;description&quot;,&quot;handle&quot;,&quot;label&quot;,&quot;pipelineHash&quot;,&quot;pipelineSettings&quot;,&quot;replaceShaderCodeFunction&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPURenderEncoder&quot;),e.begin=e=>{t.drawCallbacks=[],t.handle=e.beginRenderPass(t.description),t.label&&t.handle.pushDebugGroup(t.label)},e.end=()=>{for(let n=0;n<t.drawCallbacks.length;n++){const r=t.drawCallbacks[n],o=r.pipeline;e.setPipeline(o);for(let t=0;t<r.callbacks.length;t++)r.callbacks[t](e)}t.label&&t.handle.popDebugGroup(),t.handle.end(),t.boundPipeline=null},e.setPipeline=e=>{if(t.boundPipeline===e)return;t.handle.setPipeline(e.getHandle());const n=e.getPipelineDescription();if(t.colorTextureViews.length!==n.fragment.targets.length)console.log(`mismatched attachment counts on pipeline ${n.fragment.targets.length} while encoder has ${t.colorTextureViews.length}`),console.trace();else for(let e=0;e<t.colorTextureViews.length;e++){const r=t.colorTextureViews[e].getTexture()?.getFormat();r&&r!==n.fragment.targets[e].format&&(console.log(`mismatched attachments for attachment ${e} on pipeline ${n.fragment.targets[e].format} while encoder has ${r}`),console.trace())}if(!t.depthTextureView!=!(&quot;depthStencil&quot;in n))console.log(&quot;mismatched depth attachments&quot;),console.trace();else if(t.depthTextureView){const e=t.depthTextureView.getTexture()?.getFormat();e&&e!==n.depthStencil.format&&(console.log(`mismatched depth attachments on pipeline ${n.depthStencil.format} while encoder has ${e}`),console.trace())}t.boundPipeline=e},e.replaceShaderCode=e=>{t.replaceShaderCodeFunction(e)},e.setColorTextureView=(e,n)=>{t.colorTextureViews[e]!==n&&(t.colorTextureViews[e]=n)},e.activateBindGroup=e=>{const n=t.boundPipeline.getDevice(),r=t.boundPipeline.getBindGroupLayoutCount(e.getLabel());t.handle.setBindGroup(r,e.getBindGroup(n));const o=n.getBindGroupLayoutDescription(e.getBindGroupLayout(n)),a=n.getBindGroupLayoutDescription(t.boundPipeline.getBindGroupLayout(r));o!==a&&(console.log(`renderEncoder ${t.pipelineHash} mismatched bind group layouts bind group has\\n${o}\\n versus pipeline\\n${a}\\n`),console.trace())},e.attachTextureViews=()=>{for(let e=0;e<t.colorTextureViews.length;e++)t.description.colorAttachments[e]?t.description.colorAttachments[e].view=t.colorTextureViews[e].getHandle():t.description.colorAttachments[e]={view:t.colorTextureViews[e].getHandle()};t.depthTextureView&&(t.description.depthStencilAttachment.view=t.depthTextureView.getHandle())},e.registerDrawCallback=(e,n)=>{for(let r=0;r<t.drawCallbacks.length;r++)if(t.drawCallbacks[r].pipeline===e)return void t.drawCallbacks[r].callbacks.push(n);t.drawCallbacks.push({pipeline:e,callbacks:[n]})};for(let n=0;n<dT.length;n++)e[dT[n]]=function(){return t.handle[dT[n]](...arguments)}}(e,t)}var gT={newInstance:Mt(fT,&quot;vtkWebGPURenderEncoder&quot;),extend:fT};const mT={device:null,handle:null,label:null,options:null};function hT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,mT,n),Wt.obj(e,t),t.options={},t.bindGroupLayoutEntry={visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,sampler:{}},t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),Wt.get(e,t,[&quot;bindGroupTime&quot;,&quot;handle&quot;,&quot;options&quot;]),Wt.setGet(e,t,[&quot;bindGroupLayoutEntry&quot;,&quot;device&quot;,&quot;label&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUSampler&quot;),e.create=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};t.device=e,t.options.addressModeU=n.addressModeU?n.addressModeU:&quot;clamp-to-edge&quot;,t.options.addressModeV=n.addressModeV?n.addressModeV:&quot;clamp-to-edge&quot;,t.options.addressModeW=n.addressModeW?n.addressModeW:&quot;clamp-to-edge&quot;,t.options.magFilter=n.magFilter?n.magFilter:&quot;nearest&quot;,t.options.minFilter=n.minFilter?n.minFilter:&quot;nearest&quot;,t.options.mipmapFilter=n.mipmapFilter?n.mipmapFilter:&quot;nearest&quot;,t.options.label=t.label,t.handle=t.device.getHandle().createSampler(t.options),t.bindGroupTime.modified()},e.getShaderCode=(e,n)=>`@binding(${e}) @group(${n}) var ${t.label}: sampler;`,e.getBindGroupEntry=()=>({resource:t.handle})}(e,t)}var vT={newInstance:Wt.newInstance(hT),extend:hT};const TT={texture:null,handle:null,sampler:null,label:null};function yT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,TT,n),Wt.obj(e,t),t.bindGroupLayoutEntry={visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,texture:{sampleType:&quot;float&quot;,viewDimension:&quot;2d&quot;}},t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),Wt.get(e,t,[&quot;bindGroupTime&quot;,&quot;texture&quot;]),Wt.setGet(e,t,[&quot;bindGroupLayoutEntry&quot;,&quot;label&quot;,&quot;sampler&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUTextureView&quot;),e.create=(e,n)=>{t.texture=e,t.options=n,t.options.dimension=t.options.dimension||&quot;2d&quot;,t.options.label=t.label,t.textureHandle=e.getHandle(),t.handle=t.textureHandle.createView(t.options),t.bindGroupLayoutEntry.texture.viewDimension=t.options.dimension;const r=Xv(t.texture.getFormat());t.bindGroupLayoutEntry.texture.sampleType=r.sampleType},e.createFromTextureHandle=(e,n)=>{t.texture=null,t.options=n,t.options.dimension=t.options.dimension||&quot;2d&quot;,t.options.label=t.label,t.textureHandle=e,t.handle=t.textureHandle.createView(t.options),t.bindGroupLayoutEntry.texture.viewDimension=t.options.dimension;const r=Xv(n.format);t.bindGroupLayoutEntry.texture.sampleType=r.sampleType,t.bindGroupTime.modified()},e.getBindGroupEntry=()=>({resource:e.getHandle()}),e.getShaderCode=(e,n)=>{let r=&quot;f32&quot;;&quot;sint&quot;===t.bindGroupLayoutEntry.texture.sampleType?r=&quot;i32&quot;:&quot;uint&quot;===t.bindGroupLayoutEntry.texture.sampleType&&(r=&quot;u32&quot;);let o=`@binding(${e}) @group(${n}) var ${t.label}: texture_${t.options.dimension}<${r}>;`;return&quot;depth&quot;===t.bindGroupLayoutEntry.texture.sampleType&&(o=`@binding(${e}) @group(${n}) var ${t.label}: texture_depth_${t.options.dimension};`),o},e.addSampler=(n,r)=>{const o=vT.newInstance({label:`${t.label}Sampler`});o.create(n,r),e.setSampler(o)},e.getBindGroupTime=()=>(t.texture&&t.texture.getHandle()!==t.textureHandle&&(t.textureHandle=t.texture.getHandle(),t.handle=t.textureHandle.createView(t.options),t.bindGroupTime.modified()),t.bindGroupTime),e.getHandle=()=>(t.texture&&t.texture.getHandle()!==t.textureHandle&&(t.textureHandle=t.texture.getHandle(),t.handle=t.textureHandle.createView(t.options),t.bindGroupTime.modified()),t.handle)}(e,t)}var bT={newInstance:Wt.newInstance(yT),extend:yT};const xT={device:null,handle:null,buffer:null,ready:!1,label:null};function CT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,xT,n),Wt.obj(e,t),Wt.get(e,t,[&quot;handle&quot;,&quot;ready&quot;,&quot;width&quot;,&quot;height&quot;,&quot;depth&quot;,&quot;format&quot;,&quot;usage&quot;]),Wt.setGet(e,t,[&quot;device&quot;,&quot;label&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUTexture&quot;),e.create=(e,n)=>{t.device=e,t.width=n.width,t.height=n.height,t.depth=n.depth?n.depth:1;const r=1===t.depth?&quot;2d&quot;:&quot;3d&quot;;t.format=n.format?n.format:&quot;rgba8unorm&quot;,t.mipLevel=n.mipLevel?n.mipLevel:0,t.usage=n.usage?n.usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST,t.handle=t.device.getHandle().createTexture({size:[t.width,t.height,t.depth],format:t.format,usage:t.usage,label:t.label,dimension:r,mipLevelCount:t.mipLevel+1})},e.assignFromHandle=(e,n,r)=>{t.device=e,t.handle=n,t.width=r.width,t.height=r.height,t.depth=r.depth?r.depth:1,t.format=r.format?r.format:&quot;rgba8unorm&quot;,t.usage=r.usage?r.usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST},e.writeImageData=n=>{let r=[];const o=r=>{t.device.getHandle().queue.copyExternalImageToTexture({source:r,flipY:n.flip},{texture:t.handle,premultipliedAlpha:!0,mipLevel:0,origin:{x:0,y:0,z:0}},[r.width,r.height,t.depth]),3!==e.getDimensionality()&&t.mipLevel>0&&vu.generateMipmaps(t.device.getHandle(),t.handle,t.mipLevel+1),t.ready=!0};if(n.canvas)return void o(n.canvas);if(n.imageBitmap)return n.width=n.imageBitmap.width,n.height=n.imageBitmap.height,n.depth=1,n.format=&quot;rgba8unorm&quot;,n.flip=!0,void o(n.imageBitmap);if(n.jsImageData)return n.width=n.jsImageData.width,n.height=n.jsImageData.height,n.depth=1,n.format=&quot;rgba8unorm&quot;,n.flip=!0,void o(n.jsImageData);if(n.image)return n.width=n.image.width,n.height=n.image.height,n.depth=1,n.format=&quot;rgba8unorm&quot;,n.flip=!0,void o(n.image);const a=Xv(t.format);let i=t.width*a.stride;n.nativeArray&&(r=n.nativeArray);const s=3===e.getDimensionality(),l=((e,t,n)=>{const r=2===a.elementSize&&&quot;float&quot;===a.sampleType,o=e.BYTES_PER_ELEMENT,i=e.length/(t*n)*o;if(!r&&i%256==0)return[e,i];const s=i/o,l=a.elementSize,c=256*Math.floor((s*l+255)/256),u=c/l,d=Wt.newTypedArray(r?&quot;Uint16Array&quot;:e.constructor.name,u*t*n),p=t*n;if(r)for(let t=0;t<p;t++){const n=t*s,r=t*u;for(let t=0;t<s;t++)d[r+t]=gd.toHalf(e[n+t])}else if(u===s)d.set(e);else for(let t=0;t<p;t++)d.set(e.subarray(t*s,(t+1)*s),t*u);return[d,c]})(r,t.height,s?t.depth:1);i=l[1];const c=l[0];t.device.getHandle().queue.writeTexture({texture:t.handle,mipLevel:0,origin:{x:0,y:0,z:0}},c,{offset:0,bytesPerRow:i,rowsPerImage:t.height},{width:t.width,height:t.height,depthOrArrayLayers:s?t.depth:1}),!s&&t.mipLevel>0&&vu.generateMipmaps(t.device.getHandle(),t.handle,t.mipLevel+1),t.ready=!0},e.getScale=()=>{const e=Xv(t.format);return 2===e.elementSize&&&quot;float&quot;===e.sampleType?1:255},e.getNumberOfComponents=()=>Xv(t.format).numComponents,e.getDimensionality=()=>{let e=0;return t.width>1&&e++,t.height>1&&e++,t.depth>1&&e++,e},e.resizeToMatch=e=>{e.getWidth()===t.width&&e.getHeight()===t.height&&e.getDepth()===t.depth||(t.width=e.getWidth(),t.height=e.getHeight(),t.depth=e.getDepth(),t.handle=t.device.getHandle().createTexture({size:[t.width,t.height,t.depth],format:t.format,usage:t.usage,label:t.label}))},e.resize=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1;e===t.width&&n===t.height&&r===t.depth||(t.width=e,t.height=n,t.depth=r,t.handle=t.device.getHandle().createTexture({size:[t.width,t.height,t.depth],format:t.format,usage:t.usage,label:t.label}))},e.createView=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};r.dimension||(r.dimension=1===t.depth?&quot;2d&quot;:&quot;3d&quot;);const o=bT.newInstance({label:n});return o.create(e,r),o}}(e,t)}var ST={newInstance:Wt.newInstance(CT),extend:CT};const AT={renderEncoder:null,colorTexture:null,depthTexture:null};function IT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,AT,n),ev.extend(e,t,n),Wt.get(e,t,[&quot;colorTexture&quot;,&quot;depthTexture&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUOpaquePass&quot;),e.traverse=(n,r)=>{if(t.deleted)return;t._currentParent=r;const o=r.getDevice();if(t.renderEncoder)t.colorTexture.resize(r.getCanvas().width,r.getCanvas().height),t.depthTexture.resize(r.getCanvas().width,r.getCanvas().height);else{e.createRenderEncoder(),t.colorTexture=ST.newInstance({label:&quot;opaquePassColor&quot;}),t.colorTexture.create(o,{width:r.getCanvas().width,height:r.getCanvas().height,format:&quot;rgba16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC});const n=t.colorTexture.createView(&quot;opaquePassColorTexture&quot;);t.renderEncoder.setColorTextureView(0,n),t.depthFormat=&quot;depth32float&quot;,t.depthTexture=ST.newInstance({label:&quot;opaquePassDepth&quot;}),t.depthTexture.create(o,{width:r.getCanvas().width,height:r.getCanvas().height,format:t.depthFormat,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC});const a=t.depthTexture.createView(&quot;opaquePassDepthTexture&quot;);t.renderEncoder.setDepthTextureView(a)}t.renderEncoder.attachTextureViews(),e.setCurrentOperation(&quot;opaquePass&quot;),n.setRenderEncoder(t.renderEncoder),n.traverse(e)},e.getColorTextureView=()=>t.renderEncoder.getColorTextureViews()[0],e.getDepthTextureView=()=>t.renderEncoder.getDepthTextureView(),e.createRenderEncoder=()=>{t.renderEncoder=gT.newInstance({label:&quot;OpaquePass&quot;}),t.renderEncoder.setPipelineHash(&quot;op&quot;)}}(e,t)}var wT={newInstance:Wt.newInstance(IT,&quot;vtkWebGPUOpaquePass&quot;),extend:IT};const OT={colorTextureView:null,depthTextureView:null};function PT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,OT,n),ev.extend(e,t,n),Wt.setGet(e,t,[&quot;colorTextureView&quot;,&quot;depthTextureView&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUOrderIndependentTranslucentPass&quot;),e.traverse=(n,r)=>{if(t.deleted)return;t._currentParent=r;const o=r.getDevice();if(t.translucentRenderEncoder)t.translucentColorTexture.resizeToMatch(t.colorTextureView.getTexture()),t.translucentAccumulateTexture.resizeToMatch(t.colorTextureView.getTexture());else{e.createRenderEncoder(),e.createFinalEncoder(),t.translucentColorTexture=ST.newInstance({label:&quot;translucentPassColor&quot;}),t.translucentColorTexture.create(o,{width:r.getCanvas().width,height:r.getCanvas().height,format:&quot;rgba16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING});const n=t.translucentColorTexture.createView(&quot;oitpColorTexture&quot;);t.translucentRenderEncoder.setColorTextureView(0,n),t.translucentAccumulateTexture=ST.newInstance({label:&quot;translucentPassAccumulate&quot;}),t.translucentAccumulateTexture.create(o,{width:r.getCanvas().width,height:r.getCanvas().height,format:&quot;r16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING});const a=t.translucentAccumulateTexture.createView(&quot;oitpAccumTexture&quot;);t.translucentRenderEncoder.setColorTextureView(1,a),t.fullScreenQuad=uT.newInstance(),t.fullScreenQuad.setDevice(r.getDevice()),t.fullScreenQuad.setPipelineHash(&quot;oitpfsq&quot;),t.fullScreenQuad.setTextureViews(t.translucentRenderEncoder.getColorTextureViews()),t.fullScreenQuad.setFragmentShaderTemplate(&quot;\\n//VTK::Mapper::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output: fragmentOutput;\\n\\n  var tcoord: vec2<i32> = vec2<i32>(i32(input.fragPos.x), i32(input.fragPos.y));\\n  var reveal: f32 = textureLoad(oitpAccumTexture, tcoord, 0).r;\\n  if (reveal == 1.0) { discard; }\\n  var tcolor: vec4<f32> = textureLoad(oitpColorTexture, tcoord, 0);\\n  var total: f32 = max(tcolor.a, 0.01);\\n  var computedColor: vec4<f32> = vec4<f32>(tcolor.r/total, tcolor.g/total, tcolor.b/total, 1.0 - reveal);\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;)}t.translucentRenderEncoder.setDepthTextureView(t.depthTextureView),t.translucentRenderEncoder.attachTextureViews(),e.setCurrentOperation(&quot;translucentPass&quot;),n.setRenderEncoder(t.translucentRenderEncoder),n.traverse(e),e.finalPass(r,n)},e.finalPass=(e,n)=>{t.translucentFinalEncoder.setColorTextureView(0,t.colorTextureView),t.translucentFinalEncoder.attachTextureViews(),t.translucentFinalEncoder.begin(e.getCommandEncoder()),n.scissorAndViewport(t.translucentFinalEncoder),t.fullScreenQuad.prepareAndDraw(t.translucentFinalEncoder),t.translucentFinalEncoder.end()},e.getTextures=()=>[t.translucentColorTexture,t.translucentAccumulateTexture],e.createRenderEncoder=()=>{t.translucentRenderEncoder=gT.newInstance({label:&quot;translucentRender&quot;});const e=t.translucentRenderEncoder.getDescription();e.colorAttachments=[{view:void 0,clearValue:[0,0,0,0],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;},{view:void 0,clearValue:[1,0,0,0],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;}],e.depthStencilAttachment={view:void 0,depthLoadOp:&quot;load&quot;,depthStoreOp:&quot;store&quot;},t.translucentRenderEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor&quot;),t.addOutput(&quot;f32&quot;,&quot;outAccum&quot;),t.addBuiltinInput(&quot;vec4<f32>&quot;,&quot;@builtin(position) fragPos&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;var w: f32 = computedColor.a * pow(0.1 + input.fragPos.z, 2.0);&quot;,&quot;output.outColor = vec4<f32>(computedColor.rgb*w, w);&quot;,&quot;output.outAccum = computedColor.a;&quot;]).result,t.setCode(n)})),t.translucentRenderEncoder.setPipelineHash(&quot;oitpr&quot;),t.translucentRenderEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},depthStencil:{depthWriteEnabled:!1,depthCompare:&quot;greater&quot;,format:&quot;depth32float&quot;},fragment:{targets:[{format:&quot;rgba16float&quot;,blend:{color:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;}}},{format:&quot;r16float&quot;,blend:{color:{srcFactor:&quot;zero&quot;,dstFactor:&quot;one-minus-src&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})},e.createFinalEncoder=()=>{t.translucentFinalEncoder=gT.newInstance({label:&quot;translucentFinal&quot;}),t.translucentFinalEncoder.setDescription({colorAttachments:[{view:null,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}]}),t.translucentFinalEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor&quot;),t.addBuiltinInput(&quot;vec4<f32>&quot;,&quot;@builtin(position) fragPos&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor = vec4<f32>(computedColor.rgb, computedColor.a);&quot;]).result,t.setCode(n)})),t.translucentFinalEncoder.setPipelineHash(&quot;oitpf&quot;),t.translucentFinalEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;rgba16float&quot;,blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})}}(e,t)}var RT={newInstance:Wt.newInstance(PT,&quot;vtkWebGPUOrderIndependentTranslucentPass&quot;),extend:PT},MT={BufferUsage:{Verts:0,Lines:1,Triangles:2,Strips:3,LinesFromStrips:4,LinesFromTriangles:5,Points:6,UniformArray:7,PointArray:8,NormalsFromPoints:9,Texture:10,RawVertex:11,Storage:12,Index:13},PrimitiveTypes:{Start:0,Points:0,Lines:1,Triangles:2,TriangleStrips:3,TriangleEdges:4,TriangleStripEdges:5,End:6}};const ET=[&quot;getMappedRange&quot;,&quot;mapAsync&quot;,&quot;unmap&quot;];const VT={device:null,handle:null,sizeInBytes:0,strideInBytes:0,arrayInformation:null,usage:null,label:null,sourceTime:null};function DT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,VT,n),Wt.obj(e,t),Wt.get(e,t,[&quot;handle&quot;,&quot;sizeInBytes&quot;,&quot;usage&quot;]),Wt.setGet(e,t,[&quot;strideInBytes&quot;,&quot;device&quot;,&quot;arrayInformation&quot;,&quot;label&quot;,&quot;sourceTime&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUBuffer&quot;),e.create=(e,n)=>{t.handle=t.device.getHandle().createBuffer({size:e,usage:n,label:t.label}),t.sizeInBytes=e,t.usage=n},e.write=e=>{!function(e,t,n,r){const o=r.byteLength,a=e.createBuffer({size:o,usage:GPUBufferUsage.COPY_SRC,mappedAtCreation:!0}),i=a.getMappedRange(0,o);new Uint8Array(i).set(new Uint8Array(r)),a.unmap();const s=e.createCommandEncoder();s.copyBufferToBuffer(a,0,t,0,o);const l=s.finish();e.queue.submit([l]),a.destroy()}(t.device.getHandle(),t.handle,0,e.buffer)},e.createAndWrite=(e,n)=>{const r=4*Math.ceil(e.byteLength/4);t.handle=t.device.getHandle().createBuffer({size:r,usage:n,mappedAtCreation:!0,label:t.label}),t.sizeInBytes=r,t.usage=n,new Uint8Array(t.handle.getMappedRange()).set(new Uint8Array(e.buffer)),t.handle.unmap()};for(let n=0;n<ET.length;n++)e[ET[n]]=function(){return t.handle[ET[n]](...arguments)}}(e,t)}var LT={newInstance:Wt.newInstance(DT),extend:DT,...MT};const{Representation:BT}=os,{PrimitiveTypes:NT}=MT;class FT{constructor(){this.keys=new Uint32Array(10),this.values=new Uint32Array(10),this.count=0}clear(){this.count=0}has(e){for(let t=0;t<this.count;t++)if(this.keys[t]===e)return!0}get(e){for(let t=0;t<this.count;t++)if(this.keys[t]===e)return this.values[t]}set(e,t){this.count<9&&(this.keys[this.count]=e,this.values[this.count++]=t)}}function _T(e,t,n){let r=e.pointIdToFlatId[t];return r<0&&(r=e.flatId,e.pointIdToFlatId[t]=r,e.flatIdToPointId[e.flatId]=t,e.flatIdToCellId[e.flatId]=n,e.flatId++),r}function kT(e,t,n){const r=e.length;for(let o=0;o<r;o++){let a=e[o];if(n.cellProvokedMap.has(a)){n.ibo[n.iboId++]=n.cellProvokedMap.get(a);for(let i=o+1;i<o+r;i++){a=e[i%r];const o=_T(n,a,t);n.ibo[n.iboId++]=o}return}}for(let o=0;o<r;o++){let a=e[o];if(!n.provokedPointIds[a]){let i=_T(n,a,t);n.provokedPointIds[a]=1,n.cellProvokedMap.set(a,i),n.flatIdToCellId[i]=t,n.ibo[n.iboId++]=i;for(let s=o+1;s<o+r;s++)a=e[s%r],i=_T(n,a,t),n.ibo[n.iboId++]=i;return}}let o=e[0],a=n.flatId;n.cellProvokedMap.set(o,a),n.flatIdToPointId[n.flatId]=o,n.flatIdToCellId[n.flatId]=t,n.flatId++,n.ibo[n.iboId++]=a;for(let i=1;i<r;i++)o=e[i],a=_T(n,o,t),n.ibo[n.iboId++]=a}function GT(e,t,n){const r=e.length;n.iboSize+=r;for(let t=0;t<r;t++){const r=e[t];if(n.cellProvokedMap.has(r))return}for(let t=0;t<r;t++){const r=e[t];if(!n.provokedPointIds[r])return n.provokedPointIds[r]=1,void n.cellProvokedMap.set(r,1)}n.cellProvokedMap.set(e[0],1),n.extraPoints++}let UT;const zT=new Uint32Array(1),WT=new Uint32Array(2),HT=new Uint32Array(3),jT={anythingToPoints(e,t,n,r,o){for(let a=0;a<e;++a)zT[0]=t[n+a],UT(zT,r,o)},linesToWireframe(e,t,n,r,o){for(let a=0;a<e-1;++a)WT[0]=t[n+a],WT[1]=t[n+a+1],UT(WT,r,o)},polysToWireframe(e,t,n,r,o){if(e>2)for(let a=0;a<e;++a)WT[0]=t[n+a],WT[1]=t[n+(a+1)%e],UT(WT,r,o)},stripsToWireframe(e,t,n,r,o){if(e>2){for(let a=0;a<e-1;++a)WT[0]=t[n+a],WT[1]=t[n+a+1],UT(WT,r,o);for(let a=0;a<e-2;a++)WT[0]=t[n+a],WT[1]=t[n+a+2],UT(WT,r,o)}},polysToSurface(e,t,n,r,o){for(let a=0;a<e-2;a++)HT[0]=t[n],HT[1]=t[n+a+1],HT[2]=t[n+a+2],UT(HT,r,o)},stripsToSurface(e,t,n,r,o){for(let a=0;a<e-2;a++)HT[0]=t[n+a],HT[1]=t[n+a+1+a%2],HT[2]=t[n+a+1+(a+1)%2],UT(HT,r,o)}};const KT={flatIdToPointId:null,flatIdToCellId:null,flatSize:0,indexCount:0};function $T(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,KT,n),LT.extend(e,t,n),Wt.setGet(e,t,[&quot;flatIdToPointId&quot;,&quot;flatIdToCellId&quot;,&quot;flatSize&quot;,&quot;indexCount&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUIndexBuffer&quot;),e.buildIndexBuffer=e=>{const n=e.cells,r=e.primitiveType,o=e.representation,a=e.cellOffset,i=n.getData(),s=i.length,l=function(e){switch(e){case NT.Points:return&quot;points&quot;;case NT.Lines:return&quot;lines&quot;;case NT.Triangles:case NT.TriangleEdges:return&quot;polys&quot;;case NT.TriangleStripEdges:case NT.TriangleStrips:return&quot;strips&quot;;default:return&quot;&quot;}}(r),c=e.numberOfPoints,u={provokedPointIds:new Uint8Array(c),extraPoints:0,iboSize:0,flatId:0,iboId:0,cellProvokedMap:new FT};let d=null;d=o===BT.POINTS||r===NT.Points?jT.anythingToPoints:o===BT.WIREFRAME||r===NT.Lines?jT[`${l}ToWireframe`]:jT[`${l}ToSurface`],UT=GT;let p=a||0;for(let e=0;e<s;)u.cellProvokedMap.clear(),d(i[e],i,e+1,p,u),e+=i[e]+1,p++;u.flatIdToPointId=c<=65535?new Uint16Array(c+u.extraPoints):new Uint32Array(c+u.extraPoints),c+u.extraPoints<36863?u.pointIdToFlatId=new Int16Array(c):u.pointIdToFlatId=new Int32Array(c),c+u.extraPoints<=65535?(u.ibo=new Uint16Array(u.iboSize),e.format=&quot;uint16&quot;):(u.ibo=new Uint32Array(u.iboSize),e.format=&quot;uint32&quot;),u.flatIdToCellId=p<=65535?new Uint16Array(c+u.extraPoints):new Uint32Array(c+u.extraPoints),u.pointIdToFlatId.fill(-1),u.provokedPointIds.fill(0),UT=kT,p=a||0;for(let e=0;e<s;)u.cellProvokedMap.clear(),d(i[e],i,e+1,p,u),e+=i[e]+1,p++;delete u.provokedPointIds,delete u.pointIdToFlatId,e.nativeArray=u.ibo,t.flatIdToPointId=u.flatIdToPointId,t.flatIdToCellId=u.flatIdToCellId,t.flatSize=u.flatId,t.indexCount=u.iboId}}(e,t)}var qT={newInstance:Wt.newInstance($T),extend:$T,...MT};const{BufferUsage:XT}=MT,{vtkErrorMacro:YT}=Ht,{VtkDataTypes:ZT}=xs;function QT(e,t,n,r,o){const a={},i=e.getFlatSize();if(!i)return a;let s=[0,0,0,0];o.shift&&(o.shift.length?s=o.shift:s.fill(o.shift));let l=[1,1,1,1];o.scale&&(o.scale.length?l=o.scale:l.fill(o.scale));const c=!!Object.prototype.hasOwnProperty.call(o,&quot;packExtra&quot;)&&o.packExtra;let u,d=0;const p=at(r,i*(n+(c?1:0)));let f=e.getFlatIdToPointId();o.cellData&&(f=e.getFlatIdToCellId()),1===n?u=function(e){p[d++]=l[0]*t[e]+s[0]}:2===n?u=function(e){p[d++]=l[0]*t[e]+s[0],p[d++]=l[1]*t[e+1]+s[1]}:3!==n||c?3===n&&c?u=function(e){p[d++]=l[0]*t[e]+s[0],p[d++]=l[1]*t[e+1]+s[1],p[d++]=l[2]*t[e+2]+s[2],p[d++]=1*l[3]+s[3]}:4===n&&(u=function(e){p[d++]=l[0]*t[e]+s[0],p[d++]=l[1]*t[e+1]+s[1],p[d++]=l[2]*t[e+2]+s[2],p[d++]=l[3]*t[e+3]+s[3]}):u=function(e){p[d++]=l[0]*t[e]+s[0],p[d++]=l[1]*t[e+1]+s[1],p[d++]=l[2]*t[e+2]+s[2]};for(let e=0;e<i;e++)u(n*f[e]);return a.nativeArray=p,a}function JT(e,t,n,r){const o=[];return Bo([e[3*r]-e[3*n],e[3*r+1]-e[3*n+1],e[3*r+2]-e[3*n+2]],[e[3*t]-e[3*n],e[3*t+1]-e[3*n+1],e[3*t+2]-e[3*n+2]],o),Fo(o),o}const ey={device:null,fullScreenQuadBuffer:null};function ty(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ey,n),ht(e,t),Ct(e,t,[&quot;device&quot;]),function(e,t){function n(e){let n,r;if(e.dataArray&&!e.nativeArray&&(e.nativeArray=e.dataArray.getData()),e.usage===XT.Index&&(n=qT.newInstance({label:e.label}),n.setDevice(t.device),r=GPUBufferUsage.INDEX|GPUBufferUsage.COPY_DST,n.buildIndexBuffer(e),n.createAndWrite(e.nativeArray,r),n.setArrayInformation([{format:e.format}])),n||(n=LT.newInstance({label:e.label}),n.setDevice(t.device)),e.usage===XT.UniformArray&&(r=GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST,n.createAndWrite(e.nativeArray,r)),e.usage===XT.Storage&&(r=GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST,n.createAndWrite(e.nativeArray,r)),e.usage===XT.Texture&&(r=GPUBufferUsage.COPY_SRC,n.createAndWrite(e.nativeArray,r)),e.usage===XT.PointArray){r=GPUBufferUsage.VERTEX;const t=Zv(e.format),o=QT(e.indexBuffer,e.dataArray.getData(),e.dataArray.getNumberOfComponents(),t,{packExtra:e.packExtra,shift:e.shift,scale:e.scale,cellData:e.cellData,cellOffset:e.cellOffset});n.createAndWrite(o.nativeArray,r),n.setStrideInBytes(Yv(e.format)),n.setArrayInformation([{offset:0,format:e.format,interpolation:e.cellData?&quot;flat&quot;:&quot;perspective&quot;}])}if(e.usage===XT.NormalsFromPoints){r=GPUBufferUsage.VERTEX;const t=Zv(e.format),o=function(e,t){const n=t.getData(),r=e.getData();if(!r||!n)return null;const o=new Int8Array(4*e.getNumberOfCells()),a=r.length;let i=0;for(let e=0;e<a;){const t=JT(n,r[e+1],r[e+2],r[e+3]);o[i++]=127*t[0],o[i++]=127*t[1],o[i++]=127*t[2],o[i++]=127,e+=r[e]+1}return o}(e.cells,e.dataArray),a=QT(e.indexBuffer,o,4,t,{cellData:!0});n.createAndWrite(a.nativeArray,r),n.setStrideInBytes(Yv(e.format)),n.setArrayInformation([{offset:0,format:e.format,interpolation:&quot;flat&quot;}])}return e.usage===XT.RawVertex&&(r=GPUBufferUsage.VERTEX,n.createAndWrite(e.nativeArray,r),n.setStrideInBytes(Yv(e.format)),n.setArrayInformation([{offset:0,format:e.format}])),n.setSourceTime(e.time),n}t.classHierarchy.push(&quot;vtkWebGPUBufferManager&quot;),e.hasBuffer=e=>t.device.hasCachedObject(e),e.getBuffer=e=>e.hash?t.device.getCachedObject(e.hash,n,e):n(e),e.getBufferForPointArray=(t,n)=>{const r=function(e){let t;switch(e.getDataType()){case ZT.UNSIGNED_CHAR:t=&quot;uint8&quot;;break;case ZT.FLOAT:t=&quot;float32&quot;;break;case ZT.UNSIGNED_INT:t=&quot;uint32&quot;;break;case ZT.INT:t=&quot;sint32&quot;;break;case ZT.DOUBLE:t=&quot;float32&quot;;break;case ZT.UNSIGNED_SHORT:t=&quot;uint16&quot;;break;case ZT.SHORT:t=&quot;sin16&quot;;break;default:t=&quot;float32&quot;}switch(e.getNumberOfComponents()){case 2:t+=&quot;x2&quot;;break;case 3:t.includes(&quot;32&quot;)||YT(`unsupported x3 type for ${t}`),t+=&quot;x3&quot;;break;case 4:t+=&quot;x4&quot;}return t}(t),o={hash:`${t.getMTime()}I${n.getMTime()}${r}`,usage:XT.PointArray,format:r,dataArray:t,indexBuffer:n};return e.getBuffer(o)},e.getFullScreenQuadBuffer=()=>{if(t.fullScreenQuadBuffer)return t.fullScreenQuadBuffer;t.fullScreenQuadBuffer=LT.newInstance(),t.fullScreenQuadBuffer.setDevice(t.device);const e=new Float32Array([-1,-1,0,1,-1,0,1,1,0,-1,-1,0,1,1,0,-1,1,0]);return t.fullScreenQuadBuffer.createAndWrite(e,GPUBufferUsage.VERTEX),t.fullScreenQuadBuffer.setStrideInBytes(12),t.fullScreenQuadBuffer.setArrayInformation([{offset:0,format:&quot;float32x3&quot;}]),t.fullScreenQuadBuffer}}(e,t)}var ny={newInstance:Mt(ty),extend:ty,...MT};const{BufferUsage:ry}=ny,{vtkErrorMacro:oy}=Wt,ay={bufferEntries:null,bufferEntryNames:null,sizeInBytes:0,label:null,bindGroupLayoutEntry:null,bindGroupEntry:null};function iy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ay,n),Wt.obj(e,t),t._bufferEntryNames=new Map,t.bufferEntries=[],t.bindGroupLayoutEntry=t.bindGroupLayoutEntry||{buffer:{type:&quot;uniform&quot;}},t.sendTime={},Wt.obj(t.sendTime,{mtime:0}),t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),t.sendDirty=!0,t.sortDirty=!0,Wt.get(e,t,[&quot;binding&quot;,&quot;bindGroupTime&quot;]),Wt.setGet(e,t,[&quot;bindGroupLayoutEntry&quot;,&quot;device&quot;,&quot;label&quot;,&quot;sizeInBytes&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUUniformBuffer&quot;),e.addEntry=(e,n)=>{t._bufferEntryNames.has(e)?oy(`entry named ${e} already exists`):(t.sortDirty=!0,t._bufferEntryNames.set(e,t.bufferEntries.length),t.bufferEntries.push({name:e,type:n,sizeInBytes:Jv(n),offset:-1,nativeType:eT(n),packed:!1}))},e.sortBufferEntries=()=>{if(!t.sortDirty)return;let e=0;const n=[];let r=4;for(let e=0;e<t.bufferEntries.length;e++){const n=t.bufferEntries[e];n.sizeInBytes%16==0&&(r=Math.max(16,r)),n.sizeInBytes%8==0&&(r=Math.max(8,r))}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];!1===o.packed&&o.sizeInBytes%16==0&&(o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes)}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];if(!1===o.packed&&12===o.sizeInBytes)for(let r=0;r<t.bufferEntries.length;r++){const a=t.bufferEntries[r];if(!1===a.packed&&4===a.sizeInBytes){o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes,a.packed=!0,a.offset=e,n.push(a),e+=a.sizeInBytes;break}}}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];if(!o.packed&&o.sizeInBytes%8==0)for(let a=r+1;a<t.bufferEntries.length;a++){const r=t.bufferEntries[a];if(!r.packed&&r.sizeInBytes%8==0){o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes,r.packed=!0,r.offset=e,n.push(r),e+=r.sizeInBytes;break}}}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];if(!o.packed&&o.sizeInBytes%8==0){let r=!1;for(let a=0;!r&&a<t.bufferEntries.length;a++){const i=t.bufferEntries[a];if(!i.packed&&4===i.sizeInBytes)for(let s=a+1;s<t.bufferEntries.length;s++){const a=t.bufferEntries[s];if(!a.packed&&4===a.sizeInBytes){o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes,i.packed=!0,i.offset=e,n.push(i),e+=i.sizeInBytes,a.packed=!0,a.offset=e,n.push(a),e+=a.sizeInBytes,r=!0;break}}}}}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];!o.packed&&o.sizeInBytes>4&&(o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes)}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];o.packed||(o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes)}t.bufferEntries=n,t._bufferEntryNames.clear();for(let e=0;e<t.bufferEntries.length;e++)t._bufferEntryNames.set(t.bufferEntries[e].name,e);t.sizeInBytes=e,t.sizeInBytes=r*Math.ceil(t.sizeInBytes/r),t.sortDirty=!1},e.sendIfNeeded=e=>{if(!t.UBO){const n={nativeArray:t.Float32Array,usage:ry.UniformArray,label:t.label};t.UBO=e.getBufferManager().getBuffer(n),t.bindGroupTime.modified(),t.sendDirty=!1}t.sendDirty&&(e.getHandle().queue.writeBuffer(t.UBO.getHandle(),0,t.arrayBuffer,0,t.sizeInBytes),t.sendDirty=!1),t.sendTime.modified()},e.createView=e=>{e in t==0&&(t.arrayBuffer||(t.arrayBuffer=new ArrayBuffer(t.sizeInBytes)),t[e]=Wt.newTypedArray(e,t.arrayBuffer))},e.setValue=(n,r)=>{e.sortBufferEntries();const o=t._bufferEntryNames.get(n);if(void 0===o)return void oy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType];a.lastValue!==r&&(i[a.offset/i.BYTES_PER_ELEMENT]=r,t.sendDirty=!0),a.lastValue=r},e.setArray=(n,r)=>{e.sortBufferEntries();const o=t._bufferEntryNames.get(n);if(void 0===o)return void oy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType];let s=!1;for(let e=0;e<r.length;e++)a.lastValue&&a.lastValue[e]===r[e]||(i[a.offset/i.BYTES_PER_ELEMENT+e]=r[e],s=!0);s&&(t.sendDirty=!0,a.lastValue=[...r])},e.getBindGroupEntry=()=>({resource:{buffer:t.UBO.getHandle()}}),e.getSendTime=()=>t.sendTime.getMTime(),e.getShaderCode=(n,r)=>{e.sortBufferEntries();const o=[`struct ${t.label}Struct\\n{`];for(let e=0;e<t.bufferEntries.length;e++){const n=t.bufferEntries[e];o.push(`  ${n.name}: ${n.type},`)}return o.push(`};\\n@binding(${n}) @group(${r}) var<uniform> ${t.label}: ${t.label}Struct;`),o.join(&quot;\\n&quot;)}}(e,t)}var sy={newInstance:Wt.newInstance(iy,&quot;vtkWebGPUUniformBuffer&quot;),extend:iy};const{BufferUsage:ly}=ny,{vtkErrorMacro:cy}=Wt,uy={bufferEntries:null,bufferEntryNames:null,sizeInBytes:0,label:null,numberOfInstances:1};function dy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,uy,n),Wt.obj(e,t),t._bufferEntryNames=new Map,t.bufferEntries=[],t._sendTime={},Wt.obj(t._sendTime,{mtime:0}),t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),t.bindGroupLayoutEntry=t.bindGroupLayoutEntry||{buffer:{type:&quot;read-only-storage&quot;}},Wt.get(e,t,[&quot;bindGroupTime&quot;]),Wt.setGet(e,t,[&quot;device&quot;,&quot;bindGroupLayoutEntry&quot;,&quot;label&quot;,&quot;numberOfInstances&quot;,&quot;sizeInBytes&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUStorageBuffer&quot;),e.addEntry=(e,n)=>{if(t._bufferEntryNames.has(e))return void cy(`entry named ${e} already exists`);t._bufferEntryNames.set(e,t.bufferEntries.length);const r=Jv(n);t.bufferEntries.push({name:e,type:n,sizeInBytes:r,offset:t.sizeInBytes,nativeType:eT(n)}),t.sizeInBytes+=r},e.send=e=>{if(!t._buffer){const n={nativeArray:t.Float32Array,usage:ly.Storage,label:t.label};return t._buffer=e.getBufferManager().getBuffer(n),t.bindGroupTime.modified(),void t._sendTime.modified()}e.getHandle().queue.writeBuffer(t._buffer.getHandle(),0,t.arrayBuffer,0,t.sizeInBytes*t.numberOfInstances),t._sendTime.modified()},e.createView=e=>{e in t==0&&(t.arrayBuffer||(t.arrayBuffer=new ArrayBuffer(t.sizeInBytes*t.numberOfInstances)),t[e]=Wt.newTypedArray(e,t.arrayBuffer))},e.setValue=(n,r,o)=>{const a=t._bufferEntryNames.get(n);if(void 0===a)return void cy(`entry named ${n} not found in UBO`);const i=t.bufferEntries[a];e.createView(i.nativeType);const s=t[i.nativeType];s[(i.offset+r*t.sizeInBytes)/s.BYTES_PER_ELEMENT]=o},e.setArray=(n,r,o)=>{const a=t._bufferEntryNames.get(n);if(void 0===a)return void cy(`entry named ${n} not found in UBO`);const i=t.bufferEntries[a];e.createView(i.nativeType);const s=t[i.nativeType],l=(i.offset+r*t.sizeInBytes)/s.BYTES_PER_ELEMENT;for(let e=0;e<o.length;e++)s[l+e]=o[e]},e.setAllInstancesFromArray=(n,r)=>{const o=t._bufferEntryNames.get(n);if(void 0===o)return void cy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType],s=r.length/t.numberOfInstances;for(let e=0;e<t.numberOfInstances;e++){const n=(a.offset+e*t.sizeInBytes)/i.BYTES_PER_ELEMENT;for(let t=0;t<s;t++)i[n+t]=r[e*s+t]}},e.setAllInstancesFromArrayColorToFloat=(n,r)=>{const o=t._bufferEntryNames.get(n);if(void 0===o)return void cy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType],s=r.length/t.numberOfInstances;for(let e=0;e<t.numberOfInstances;e++){const n=(a.offset+e*t.sizeInBytes)/i.BYTES_PER_ELEMENT;for(let t=0;t<s;t++)i[n+t]=r[e*s+t]/255}},e.setAllInstancesFromArray3x3To4x4=(n,r)=>{const o=t._bufferEntryNames.get(n);if(void 0===o)return void cy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType];for(let e=0;e<t.numberOfInstances;e++){const n=(a.offset+e*t.sizeInBytes)/i.BYTES_PER_ELEMENT;for(let t=0;t<3;t++)for(let o=0;o<3;o++)i[n+4*t+o]=r[9*e+3*t+o]}},e.getSendTime=()=>t._sendTime.getMTime(),e.getShaderCode=(e,n)=>{const r=[`struct ${t.label}StructEntry\\n{`];for(let e=0;e<t.bufferEntries.length;e++){const n=t.bufferEntries[e];r.push(`  ${n.name}: ${n.type},`)}return r.push(`\\n};\\nstruct ${t.label}Struct\\n{\\n  values: array<${t.label}StructEntry>,\\n};\\n@binding(${e}) @group(${n}) var<storage, read> ${t.label}: ${t.label}Struct;\\n`),r.join(&quot;\\n&quot;)},e.getBindGroupEntry=()=>({resource:{buffer:t._buffer.getHandle()}}),e.clearData=()=>{t.numberOfInstances=0,t.sizeInBytes=0,t.bufferEntries=[],t._bufferEntryNames=new Map,t._buffer=null,delete t.arrayBuffer,delete t.Float32Array}}(e,t)}var py={newInstance:Wt.newInstance(dy,&quot;vtkWebGPUStorageBuffer&quot;),extend:dy};const fy=new Float64Array(16),gy=new Float64Array(16),my={volumes:null,rowLength:1024,lastVolumeLength:0};function hy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,my,n),uT.extend(e,t,n),t.fragmentShaderTemplate=&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::Volume::TraverseDec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::IOStructs::Dec\\n\\nfn getTextureValue(vTex: texture_3d<f32>, tpos: vec4<f32>) -> f32\\n{\\n  // todo multicomponent support\\n  return textureSampleLevel(vTex, clampSampler, tpos.xyz, 0.0).r;\\n}\\n\\nfn getGradient(vTex: texture_3d<f32>, tpos: vec4<f32>, vNum: i32, scalar: f32) -> vec4<f32>\\n{\\n  var result: vec4<f32>;\\n\\n  var tstep: vec4<f32> = volumeSSBO.values[vNum].tstep;\\n  result.x = getTextureValue(vTex, tpos + vec4<f32>(tstep.x, 0.0, 0.0, 1.0)) - scalar;\\n  result.y = getTextureValue(vTex, tpos + vec4<f32>(0.0, tstep.y, 0.0, 1.0)) - scalar;\\n  result.z = getTextureValue(vTex, tpos + vec4<f32>(0.0, 0.0, tstep.z, 1.0)) - scalar;\\n  result.w = 0.0;\\n\\n  // divide by spacing as that is our delta\\n  result = result / volumeSSBO.values[vNum].spacing;\\n  // now we have a gradient in unit tcoords\\n\\n  var grad: f32 = length(result.xyz);\\n  if (grad > 0.0)\\n  {\\n    // rotate to View Coords, needed for lighting and shading\\n    var nMat: mat4x4<f32> = rendererUBO.SCVCMatrix * volumeSSBO.values[vNum].planeNormals;\\n    result = nMat * result;\\n    result = result / length(result);\\n  }\\n\\n  // store gradient magnitude in .w\\n  result.w = grad;\\n\\n  return result;\\n}\\n\\nfn processVolume(vTex: texture_3d<f32>, vNum: i32, cNum: i32, posSC: vec4<f32>, tfunRows: f32) -> vec4<f32>\\n{\\n  var outColor: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);\\n\\n  // convert to tcoords and reject if outside the volume\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*posSC;\\n  if (tpos.x < 0.0 || tpos.y < 0.0 || tpos.z < 0.0 ||\\n      tpos.x > 1.0 || tpos.y > 1.0 || tpos.z > 1.0) { return outColor; }\\n\\n  var scalar: f32 = getTextureValue(vTex, tpos);\\n\\n  var coord: vec2<f32> =\\n    vec2<f32>(scalar * componentSSBO.values[cNum].cScale + componentSSBO.values[cNum].cShift,\\n      (0.5 + 2.0 * f32(vNum)) / tfunRows);\\n  var color: vec4<f32> = textureSampleLevel(tfunTexture, clampSampler, coord, 0.0);\\n\\n  var gofactor: f32 = 1.0;\\n  var normal: vec4<f32> = vec4<f32>(0.0,0.0,0.0,0.0);\\n  if (componentSSBO.values[cNum].gomin <  1.0 || volumeSSBO.values[vNum].shade[0] > 0.0)\\n  {\\n    normal = getGradient(vTex, tpos, vNum, scalar);\\n    if (componentSSBO.values[cNum].gomin <  1.0)\\n    {\\n      gofactor = clamp(normal.a*componentSSBO.values[cNum].goScale + componentSSBO.values[cNum].goShift,\\n      componentSSBO.values[cNum].gomin, componentSSBO.values[cNum].gomax);\\n    }\\n  }\\n\\n  coord.x = (scalar * componentSSBO.values[cNum].oScale + componentSSBO.values[cNum].oShift);\\n  var opacity: f32 = textureSampleLevel(ofunTexture, clampSampler, coord, 0.0).r;\\n\\n  if (volumeSSBO.values[vNum].shade[0] > 0.0)\\n  {\\n    color = color*abs(normal.z);\\n  }\\n\\n  outColor = vec4<f32>(color.rgb, gofactor * opacity);\\n\\n  return outColor;\\n}\\n\\n// adjust the start and end point of a raycast such that it intersects the unit cube.\\n// This function is used to take a raycast starting point and step vector\\n// and numSteps and return the startijng and ending steps for intersecting the\\n// unit cube. Recall for a 3D texture, the unit cube is the range of texture coordsinates\\n// that have valid values. So this funtion can be used to take a ray in texture coordinates\\n// and bound it to intersecting the texture.\\n//\\nfn adjustBounds(tpos: vec4<f32>, tstep: vec4<f32>, numSteps: f32) -> vec2<f32>\\n{\\n  var result: vec2<f32> = vec2<f32>(0.0, numSteps);\\n  var tpos2: vec4<f32> = tpos + tstep*numSteps;\\n\\n  // move tpos to the start of the volume\\n  var adjust: f32 =\\n    min(\\n      max(tpos.x/tstep.x, (tpos.x - 1.0)/tstep.x),\\n      min(\\n        max((tpos.y - 1.0)/tstep.y, tpos.y/tstep.y),\\n        max((tpos.z - 1.0)/tstep.z, tpos.z/tstep.z)));\\n  if (adjust < 0.0)\\n  {\\n    result.x = result.x - adjust;\\n  }\\n\\n  // adjust length to the end\\n  adjust =\\n    max(\\n      min(tpos2.x/tstep.x, (tpos2.x - 1.0)/tstep.x),\\n      max(\\n        min((tpos2.y - 1.0)/tstep.y, tpos2.y/tstep.y),\\n        min((tpos2.z - 1.0)/tstep.z, tpos2.z/tstep.z)));\\n  if (adjust > 0.0)\\n  {\\n    result.y = result.y - adjust;\\n  }\\n\\n  return result;\\n}\\n\\nfn getSimpleColor(scalar: f32, vNum: i32, cNum: i32) -> vec4<f32>\\n{\\n  // how many rows (tfuns) do we have in our tfunTexture\\n  var tfunRows: f32 = f32(textureDimensions(tfunTexture).y);\\n\\n  var coord: vec2<f32> =\\n    vec2<f32>(scalar * componentSSBO.values[cNum].cScale + componentSSBO.values[cNum].cShift,\\n      (0.5 + 2.0 * f32(vNum)) / tfunRows);\\n  var color: vec4<f32> = textureSampleLevel(tfunTexture, clampSampler, coord, 0.0);\\n  coord.x = (scalar * componentSSBO.values[cNum].oScale + componentSSBO.values[cNum].oShift);\\n  var opacity: f32 = textureSampleLevel(ofunTexture, clampSampler, coord, 0.0).r;\\n  return vec4<f32>(color.rgb, opacity);\\n}\\n\\nfn traverseMax(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\\n{\\n  // convert to tcoords and reject if outside the volume\\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\\n  var tstep: vec4<f32> = tpos2 - tpos;\\n\\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\\n\\n  // did we hit anything\\n  if (rayBounds.x >= rayBounds.y)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n    return;\\n  }\\n\\n  tpos = tpos + tstep*rayBounds.x;\\n  var curDist: f32 = rayBounds.x;\\n  var maxVal: f32 = -1.0e37;\\n  loop\\n  {\\n    var scalar: f32 = getTextureValue(vTex, tpos);\\n    if (scalar > maxVal)\\n    {\\n      maxVal = scalar;\\n    }\\n\\n    // increment position\\n    curDist = curDist + 1.0;\\n    tpos = tpos + tstep;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayBounds.y) { break; }\\n  }\\n\\n  // process to get the color and opacity\\n  traverseVals[vNum] = getSimpleColor(maxVal, vNum, cNum);\\n}\\n\\nfn traverseMin(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\\n{\\n  // convert to tcoords and reject if outside the volume\\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\\n  var tstep: vec4<f32> = tpos2 - tpos;\\n\\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\\n\\n  // did we hit anything\\n  if (rayBounds.x >= rayBounds.y)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n    return;\\n  }\\n\\n  tpos = tpos + tstep*rayBounds.x;\\n  var curDist: f32 = rayBounds.x;\\n  var minVal: f32 = 1.0e37;\\n  loop\\n  {\\n    var scalar: f32 = getTextureValue(vTex, tpos);\\n    if (scalar < minVal)\\n    {\\n      minVal = scalar;\\n    }\\n\\n    // increment position\\n    curDist = curDist + 1.0;\\n    tpos = tpos + tstep;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayBounds.y) { break; }\\n  }\\n\\n  // process to get the color and opacity\\n  traverseVals[vNum] = getSimpleColor(minVal, vNum, cNum);\\n}\\n\\nfn traverseAverage(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\\n{\\n  // convert to tcoords and reject if outside the volume\\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\\n  var tstep: vec4<f32> = tpos2 - tpos;\\n\\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\\n\\n  // did we hit anything\\n  if (rayBounds.x >= rayBounds.y)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n    return;\\n  }\\n\\n  let ipRange: vec4<f32> = volumeSSBO.values[vNum].ipScalarRange;\\n  tpos = tpos + tstep*rayBounds.x;\\n  var curDist: f32 = rayBounds.x;\\n  var avgVal: f32 = 0.0;\\n  var sampleCount: f32 = 0.0;\\n  loop\\n  {\\n    var sample: f32 = getTextureValue(vTex, tpos);\\n    // right now leave filtering off until WebGL changes get merged\\n    // if (ipRange.z == 0.0 || sample >= ipRange.x && sample <= ipRange.y)\\n    // {\\n      avgVal = avgVal + sample;\\n      sampleCount = sampleCount + 1.0;\\n    // }\\n\\n    // increment position\\n    curDist = curDist + 1.0;\\n    tpos = tpos + tstep;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayBounds.y) { break; }\\n  }\\n\\n  if (sampleCount <= 0.0)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n  }\\n\\n  // process to get the color and opacity\\n  traverseVals[vNum] = getSimpleColor(avgVal/sampleCount, vNum, cNum);\\n}\\n\\nfn traverseAdditive(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\\n{\\n  // convert to tcoords and reject if outside the volume\\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\\n  var tstep: vec4<f32> = tpos2 - tpos;\\n\\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\\n\\n  // did we hit anything\\n  if (rayBounds.x >= rayBounds.y)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n    return;\\n  }\\n\\n  let ipRange: vec4<f32> = volumeSSBO.values[vNum].ipScalarRange;\\n  tpos = tpos + tstep*rayBounds.x;\\n  var curDist: f32 = rayBounds.x;\\n  var sumVal: f32 = 0.0;\\n  loop\\n  {\\n    var sample: f32 = getTextureValue(vTex, tpos);\\n    // right now leave filtering off until WebGL changes get merged\\n    // if (ipRange.z == 0.0 || sample >= ipRange.x && sample <= ipRange.y)\\n    // {\\n      sumVal = sumVal + sample;\\n    // }\\n\\n    // increment position\\n    curDist = curDist + 1.0;\\n    tpos = tpos + tstep;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayBounds.y) { break; }\\n  }\\n\\n  // process to get the color and opacity\\n  traverseVals[vNum] = getSimpleColor(sumVal, vNum, cNum);\\n}\\n\\nfn composite(rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>) -> vec4<f32>\\n{\\n  // initial ray position is at the beginning\\n  var rayPosSC: vec4<f32> = minPosSC;\\n\\n  // how many rows (tfuns) do we have in our tfunTexture\\n  var tfunRows: f32 = f32(textureDimensions(tfunTexture).y);\\n\\n  var curDist: f32 = 0.0;\\n  var computedColor: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);\\n  var sampleColor: vec4<f32>;\\n//VTK::Volume::TraverseCalls\\n\\n  loop\\n  {\\n    // for each volume, sample and accumulate color\\n//VTK::Volume::CompositeCalls\\n\\n    // increment position\\n    curDist = curDist + mapperUBO.SampleDistance;\\n    rayPosSC = rayPosSC + rayStepSC;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayLengthSC) { break; }\\n    if (computedColor.a > 0.98) { break; }\\n  }\\n  return computedColor;\\n}\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output: fragmentOutput;\\n\\n  var rayMax: f32 = textureSampleLevel(maxTexture, clampSampler, input.tcoordVS, 0.0).r;\\n  var rayMin: f32 = textureSampleLevel(minTexture, clampSampler, input.tcoordVS, 0.0).r;\\n\\n  // discard empty rays\\n  if (rayMax <= rayMin) { discard; }\\n  else\\n  {\\n    // compute start and end ray positions in view coordinates\\n    var minPosSC: vec4<f32> = rendererUBO.PCSCMatrix*vec4<f32>(2.0 * input.tcoordVS.x - 1.0, 1.0 - 2.0 * input.tcoordVS.y, rayMax, 1.0);\\n    minPosSC = minPosSC * (1.0 / minPosSC.w);\\n    var maxPosSC: vec4<f32> = rendererUBO.PCSCMatrix*vec4<f32>(2.0 * input.tcoordVS.x - 1.0, 1.0 - 2.0 * input.tcoordVS.y, rayMin, 1.0);\\n    maxPosSC = maxPosSC * (1.0 / maxPosSC.w);\\n\\n    var rayLengthSC: f32 = distance(minPosSC.xyz, maxPosSC.xyz);\\n    var rayStepSC: vec4<f32> = (maxPosSC - minPosSC)*(mapperUBO.SampleDistance/rayLengthSC);\\n    rayStepSC.w = 0.0;\\n\\n    var computedColor: vec4<f32>;\\n\\n//VTK::Volume::Loop\\n\\n//VTK::RenderEncoder::Impl\\n  }\\n\\n  return output;\\n}\\n&quot;,t.UBO=sy.newInstance({label:&quot;mapperUBO&quot;}),t.UBO.addEntry(&quot;SampleDistance&quot;,&quot;f32&quot;),t.SSBO=py.newInstance({label:&quot;volumeSSBO&quot;}),t.componentSSBO=py.newInstance({label:&quot;componentSSBO&quot;}),t.lutBuildTime={},Wt.obj(t.lutBuildTime,{mtime:0}),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUVolumePassFSQ&quot;),e.replaceShaderPosition=(e,t,n)=>{const r=t.getShaderDescription(&quot;vertex&quot;);r.addBuiltinOutput(&quot;vec4<f32>&quot;,&quot;@builtin(position) Position&quot;);let o=r.getCode();o=_v.substitute(o,&quot;//VTK::Position::Impl&quot;,[&quot;output.tcoordVS = vec2<f32>(vertexBC.x * 0.5 + 0.5, 1.0 - vertexBC.y * 0.5 - 0.5);&quot;,&quot;output.Position = vec4<f32>(vertexBC, 1.0);&quot;]).result,r.setCode(o),t.getShaderDescription(&quot;fragment&quot;).addBuiltinInput(&quot;vec4<f32>&quot;,&quot;@builtin(position) fragPos&quot;)},t.shaderReplacements.set(&quot;replaceShaderPosition&quot;,e.replaceShaderPosition),e.replaceShaderVolume=(e,n,r)=>{const o=n.getShaderDescription(&quot;fragment&quot;);let a=o.getCode();const i=[],s=[];for(let e=0;e<t.volumes.length;e++)t.volumes[e].getRenderable().getMapper().getBlendMode()===eg.COMPOSITE_BLEND?(i.push(`    sampleColor = processVolume(volTexture${e}, ${e}, ${t.rowStarts[e]}, rayPosSC, tfunRows);`),i.push(&quot;    computedColor = vec4<f32>(\\n          sampleColor.a * sampleColor.rgb * (1.0 - computedColor.a) + computedColor.rgb,\\n          (1.0 - computedColor.a)*sampleColor.a + computedColor.a);&quot;)):(s.push(`  sampleColor = traverseVals[${e}];`),s.push(&quot;  computedColor = vec4<f32>(\\n          sampleColor.a * sampleColor.rgb * (1.0 - computedColor.a) + computedColor.rgb,\\n          (1.0 - computedColor.a)*sampleColor.a + computedColor.a);&quot;));a=_v.substitute(a,&quot;//VTK::Volume::CompositeCalls&quot;,i).result,a=_v.substitute(a,&quot;//VTK::Volume::TraverseCalls&quot;,s).result,a=_v.substitute(a,&quot;//VTK::Volume::TraverseDec&quot;,[`var<private> traverseVals: array<vec4<f32>,${t.volumes.length}>;`]).result;let l=!1;for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getMapper().getBlendMode();n===eg.COMPOSITE_BLEND?l=!0:n===eg.MAXIMUM_INTENSITY_BLEND?a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[`    traverseMax(volTexture${e}, ${e}, ${e}, rayLengthSC, minPosSC, rayStepSC);`,`    computedColor = traverseVals[${e}];`,&quot;//VTK::Volume::Loop&quot;]).result:n===eg.MINIMUM_INTENSITY_BLEND?a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[`    traverseMin(volTexture${e}, ${e}, ${e}, rayLengthSC, minPosSC, rayStepSC);`,`    computedColor = traverseVals[${e}];`,&quot;//VTK::Volume::Loop&quot;]).result:n===eg.AVERAGE_INTENSITY_BLEND?a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[`    traverseAverage(volTexture${e}, ${e}, ${e}, rayLengthSC, minPosSC, rayStepSC);`,`    computedColor = traverseVals[${e}];`,&quot;//VTK::Volume::Loop&quot;]).result:n===eg.ADDITIVE_INTENSITY_BLEND&&(a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[`    traverseAdditive(volTexture${e}, ${e}, ${e}, rayLengthSC, minPosSC, rayStepSC);`,`    computedColor = traverseVals[${e}];`,&quot;//VTK::Volume::Loop&quot;]).result)}l&&(a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[&quot;    computedColor = composite(rayLengthSC, minPosSC, rayStepSC);&quot;]).result),o.setCode(a)},t.shaderReplacements.set(&quot;replaceShaderVolume&quot;,e.replaceShaderVolume),e.updateLUTImage=n=>{let r=e.getMTime();for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),o=n.getMapper().getInputData();r=Math.max(r,n.getMTime(),o.getMTime())}if(r<t.lutBuildTime.getMTime())return;t.numRows=0,t.rowStarts=[];for(let e=0;e<t.volumes.length;e++){t.rowStarts.push(t.numRows);const n=t.volumes[e].getRenderable(),r=n.getMapper(),o=n.getProperty(),a=r.getInputData(),i=(a.getPointData()&&a.getPointData().getScalars()).getNumberOfComponents(),s=o.getIndependentComponents()?i:1;t.numRows+=s}const o=new Uint8ClampedArray(2*t.numRows*t.rowLength*4),a=new Float32Array(2*t.numRows*t.rowLength);let i=0;const s=new Float32Array(3*t.rowLength),l=t.rowLength;for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),r=n.getMapper(),c=n.getProperty(),u=r.getInputData(),d=(u.getPointData()&&u.getPointData().getScalars()).getNumberOfComponents(),p=c.getIndependentComponents()?d:1;for(let e=0;e<p;++e){const n=c.getRGBTransferFunction(e),r=n.getRange();n.getTable(r[0],r[1],l,s,1);let u=i*l*4;for(let e=0;e<l;++e){o[u+4*e]=255*s[3*e],o[u+4*e+1]=255*s[3*e+1],o[u+4*e+2]=255*s[3*e+2],o[u+4*e+3]=255;for(let t=0;t<4;t++)o[u+4*(l+e)+t]=o[u+4*e+t]}const d=c.getScalarOpacity(e),p=t.sampleDist/c.getScalarOpacityUnitDistance(e),f=d.getRange();d.getTable(f[0],f[1],l,s,1),u=i*l;for(let e=0;e<l;++e)a[u+e]=1-(1-s[e])**p,a[u+e+l]=a[u+e];i+=2}}{const e={nativeArray:o,width:t.rowLength,height:2*t.numRows,depth:1,format:&quot;rgba8unorm&quot;},r=n.getTextureManager().getTexture(e).createView(&quot;tfunTexture&quot;);t.textureViews[2]=r}{const e={nativeArray:a,width:t.rowLength,height:2*t.numRows,depth:1,format:&quot;r16float&quot;},r=n.getTextureManager().getTexture(e).createView(&quot;ofunTexture&quot;);t.textureViews[3]=r}t.lutBuildTime.modified()},e.updateSSBO=n=>{let r=Math.max(e.getMTime(),t.WebGPURenderer.getStabilizedTime());for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),o=n.getMapper(),a=o.getInputData();r=Math.max(r,n.getMTime(),a.getMTime(),o.getMTime())}if(r<t.SSBO.getSendTime())return;const o=t.WebGPURenderer.getStabilizedCenterByReference();t.SSBO.clearData(),t.SSBO.setNumberOfInstances(t.volumes.length);const a=new Float64Array(16*t.volumes.length),i=new Float64Array(16*t.volumes.length),s=new Float64Array(4*t.volumes.length),l=new Float64Array(4*t.volumes.length),c=new Float64Array(4*t.volumes.length),u=new Float64Array(4*t.volumes.length);for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),r=n.getMapper().getInputData();m(fy),x(fy,fy,o);const d=n.getMatrix();h(gy,d),v(gy,gy),b(fy,gy,fy);const p=r.getWorldToIndex();b(fy,p,fy);const f=r.getDimensions();m(gy),C(gy,gy,[1/f[0],1/f[1],1/f[2]]),b(fy,gy,fy);for(let t=0;t<16;t++)a[16*e+t]=fy[t];v(fy,fy);for(let t=0;t<4;t++)i[16*e+4*t]=fy[4*t],i[16*e+4*t+1]=fy[4*t+1],i[16*e+4*t+2]=fy[4*t+2],i[16*e+4*t+3]=0;s[4*e]=1/f[0],s[4*e+1]=1/f[1],s[4*e+2]=1/f[2],s[4*e+3]=1,l[4*e]=n.getProperty().getShade()?1:0;const g=r.getSpacing();c[4*e]=g[0],c[4*e+1]=g[1],c[4*e+2]=g[2],c[4*e+3]=1;const T=t.textureViews[e+4].getTexture().getScale(),y=n.getProperty().getIpScalarRange();u[4*e]=y[0]/T,u[4*e+1]=y[1]/T,u[4*e+2]=n.getProperty().getFilterMode()}t.SSBO.addEntry(&quot;SCTCMatrix&quot;,&quot;mat4x4<f32>&quot;),t.SSBO.addEntry(&quot;planeNormals&quot;,&quot;mat4x4<f32>&quot;),t.SSBO.addEntry(&quot;shade&quot;,&quot;vec4<f32>&quot;),t.SSBO.addEntry(&quot;tstep&quot;,&quot;vec4<f32>&quot;),t.SSBO.addEntry(&quot;spacing&quot;,&quot;vec4<f32>&quot;),t.SSBO.addEntry(&quot;ipScalarRange&quot;,&quot;vec4<f32>&quot;),t.SSBO.setAllInstancesFromArray(&quot;SCTCMatrix&quot;,a),t.SSBO.setAllInstancesFromArray(&quot;planeNormals&quot;,i),t.SSBO.setAllInstancesFromArray(&quot;shade&quot;,l),t.SSBO.setAllInstancesFromArray(&quot;tstep&quot;,s),t.SSBO.setAllInstancesFromArray(&quot;spacing&quot;,c),t.SSBO.setAllInstancesFromArray(&quot;ipScalarRange&quot;,u),t.SSBO.send(n),t.componentSSBO.clearData(),t.componentSSBO.setNumberOfInstances(t.numRows);const d=new Float64Array(t.numRows),p=new Float64Array(t.numRows),f=new Float64Array(t.numRows),g=new Float64Array(t.numRows),T=new Float64Array(t.numRows),y=new Float64Array(t.numRows),S=new Float64Array(t.numRows),A=new Float64Array(t.numRows);let I=0;for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),r=n.getMapper(),o=n.getProperty(),a=r.getInputData(),i=(a.getPointData()&&a.getPointData().getScalars()).getNumberOfComponents(),s=o.getIndependentComponents(),l=t.textureViews[e+4].getTexture().getFormat(),c=Xv(l),u={scale:[255],offset:[0]};2===c.elementSize&&&quot;float&quot;===c.sampleType&&(u.scale[0]=1);for(let e=0;e<i;e++){const t=s?e:0,n=u.scale[e],r=o.getScalarOpacity(t).getRange(),a=n/(r[1]-r[0]),i=(u.offset[e]-r[0])/(r[1]-r[0]);g[I]=i,f[I]=a;const l=o.getRGBTransferFunction(t).getRange();if(p[I]=(u.offset[e]-l[0])/(l[1]-l[0]),d[I]=n/(l[1]-l[0]),o.getUseGradientOpacity(t)){const e=o.getGradientOpacityMinimumOpacity(t),r=o.getGradientOpacityMaximumOpacity(t);T[I]=e,y[I]=r;const a=[o.getGradientOpacityMinimumValue(t),o.getGradientOpacityMaximumValue(t)];A[I]=n*(r-e)/(a[1]-a[0]),S[I]=-a[0]*(r-e)/(a[1]-a[0])+e}else T[I]=1,y[I]=1,A[I]=0,S[I]=1;I++}}t.componentSSBO.addEntry(&quot;cScale&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;cShift&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;oScale&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;oShift&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;goShift&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;goScale&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;gomin&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;gomax&quot;,&quot;f32&quot;),t.componentSSBO.setAllInstancesFromArray(&quot;cScale&quot;,d),t.componentSSBO.setAllInstancesFromArray(&quot;cShift&quot;,p),t.componentSSBO.setAllInstancesFromArray(&quot;oScale&quot;,f),t.componentSSBO.setAllInstancesFromArray(&quot;oShift&quot;,g),t.componentSSBO.setAllInstancesFromArray(&quot;goScale&quot;,A),t.componentSSBO.setAllInstancesFromArray(&quot;goShift&quot;,S),t.componentSSBO.setAllInstancesFromArray(&quot;gomin&quot;,T),t.componentSSBO.setAllInstancesFromArray(&quot;gomax&quot;,y),t.componentSSBO.send(n)};const n=e.updateBuffers;e.updateBuffers=()=>{n();let r=t.volumes[0].getRenderable().getMapper().getSampleDistance();for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getMapper().getSampleDistance();n<r&&(r=n)}t.sampleDist!==r&&(t.sampleDist=r,t.UBO.setValue(&quot;SampleDistance&quot;,r),t.UBO.sendIfNeeded(t.device));for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getMapper().getInputData(),r=t.device.getTextureManager().getTextureForImageData(n);if(!t.textureViews[e+4]||t.textureViews[e+4].getTexture()!==r){const n=r.createView(`volTexture${e}`);t.textureViews[e+4]=n}}if(t.volumes.length<t.lastVolumeLength)for(let e=t.volumes.length;e<t.lastVolumeLength;e++)t.textureViews.pop();t.lastVolumeLength=t.volumes.length,e.updateLUTImage(t.device),e.updateSSBO(t.device),t.clampSampler||(t.clampSampler=vT.newInstance({label:&quot;clampSampler&quot;}),t.clampSampler.create(t.device,{minFilter:&quot;linear&quot;,magFilter:&quot;linear&quot;}))},e.computePipelineHash=()=>{t.pipelineHash=&quot;volfsq&quot;;for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getMapper().getBlendMode();t.pipelineHash+=`${n}`}},e.setVolumes=n=>{if(!t.volumes||t.volumes.length!==n.length)return t.volumes=[...n],void e.modified();for(let r=0;r<n.length;r++)if(n[r]!==t.volumes[r])return t.volumes=[...n],void e.modified()};const r=e.getBindables;e.getBindables=()=>{const e=r();return e.push(t.componentSSBO),e.push(t.clampSampler),e}}(e,t)}var vy={newInstance:Wt.newInstance(hy,&quot;vtkWebGPUVolumePassFSQ&quot;),extend:hy};const{Representation:Ty}=os,{BufferUsage:yy,PrimitiveTypes:by}=ny,xy=[[0,4,6],[0,6,2],[1,3,7],[1,7,5],[0,5,4],[0,1,5],[2,6,7],[2,7,3],[0,3,1],[0,2,3],[4,5,7],[4,7,6]],Cy={colorTextureView:null,depthTextureView:null,volumes:null};function Sy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Cy,n),ev.extend(e,t,n),t._mapper=sT.newInstance(),t._mapper.setFragmentShaderTemplate(&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Select::Dec\\n\\n//VTK::VolumePass::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output : fragmentOutput;\\n\\n  //VTK::Select::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::VolumePass::Impl\\n\\n  // use the maximum (closest) of the current value and the zbuffer\\n  // the blend func will then take the min to find the farthest stop value\\n  var stopval: f32 = max(input.fragPos.z, textureLoad(opaquePassDepthTexture, vec2<i32>(i32(input.fragPos.x), i32(input.fragPos.y)), 0));\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;),t._mapper.getShaderReplacements().set(&quot;replaceShaderVolumePass&quot;,((e,t,n)=>{t.getShaderDescription(&quot;fragment&quot;).addBuiltinInput(&quot;vec4<f32>&quot;,&quot;@builtin(position) fragPos&quot;)})),t._boundsPoly=gu.newInstance(),t._lastMTimes=[],Wt.setGet(e,t,[&quot;colorTextureView&quot;,&quot;depthTextureView&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUVolumePass&quot;),e.initialize=n=>{t._clearEncoder||e.createClearEncoder(n),t._mergeEncoder||e.createMergeEncoder(n),t._copyEncoder||e.createCopyEncoder(n),t._depthRangeEncoder||e.createDepthRangeEncoder(n),t.fullScreenQuad||(t.fullScreenQuad=vy.newInstance(),t.fullScreenQuad.setDevice(n.getDevice()),t.fullScreenQuad.setTextureViews([...t._depthRangeEncoder.getColorTextureViews()])),t._volumeCopyQuad||(t._volumeCopyQuad=uT.newInstance(),t._volumeCopyQuad.setPipelineHash(&quot;volpassfsq&quot;),t._volumeCopyQuad.setDevice(n.getDevice()),t._volumeCopyQuad.setFragmentShaderTemplate(&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output: fragmentOutput;\\n\\n  var computedColor: vec4<f32> = textureSample(volumePassColorTexture,\\n    volumePassColorTextureSampler, mapperUBO.tscale*input.tcoordVS);\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;),t._copyUBO=sy.newInstance({label:&quot;mapperUBO&quot;}),t._copyUBO.addEntry(&quot;tscale&quot;,&quot;vec2<f32>&quot;),t._volumeCopyQuad.setUBO(t._copyUBO),t._volumeCopyQuad.setTextureViews([t._colorTextureView]))},e.traverse=(n,r)=>{if(t.deleted)return;t._currentParent=r,e.initialize(r),e.computeTiming(r),e.renderDepthBounds(n,r),t._firstGroup=!0;const o=r.getDevice(),a=o.getHandle().limits.maxSampledTexturesPerShaderStage-4;if(t.volumes.length>a){const o=n.getRenderable().getActiveCamera().getPosition(),i=[];for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getBounds(),r=[.5*(n[1]+n[0]),.5*(n[3]+n[2]),.5*(n[5]+n[4])];i[e]=Go(r,o)}const s=[...Array(t.volumes.length).keys()];s.sort(((e,t)=>i[t]-i[e]));let l=[],c=s.length%a;for(let o=0;o<s.length;o++)l.push(t.volumes[s[o]]),l.length>=c&&(e.rayCastPass(r,n,l),l=[],c=a,t._firstGroup=!1)}else e.rayCastPass(r,n,t.volumes);if(t._volumeCopyQuad.setWebGPURenderer(n),t._useSmallViewport){const e=t._colorTextureView.getTexture().getWidth(),n=t._colorTextureView.getTexture().getHeight();t._copyUBO.setArray(&quot;tscale&quot;,[t._smallViewportWidth/e,t._smallViewportHeight/n])}else t._copyUBO.setArray(&quot;tscale&quot;,[1,1]);t._copyUBO.sendIfNeeded(o),t._copyEncoder.setColorTextureView(0,t.colorTextureView),t._copyEncoder.attachTextureViews(),t._copyEncoder.begin(r.getCommandEncoder()),n.scissorAndViewport(t._copyEncoder),t._volumeCopyQuad.prepareAndDraw(t._copyEncoder),t._copyEncoder.end()},e.delete=Wt.chain((()=>{t._animationRateSubscription&&(t._animationRateSubscription.unsubscribe(),t._animationRateSubscription=null)}),e.delete),e.computeTiming=e=>{const n=e.getRenderable().getInteractor();if(null==t._lastScale){const e=t.volumes[0].getRenderable().getMapper();t._lastScale=e.getInitialInteractionScale()||1}t._useSmallViewport=!1,n.isAnimating()&&t._lastScale>1.5&&(t._useSmallViewport=!0),t._colorTexture.resize(e.getCanvas().width,e.getCanvas().height),t._animationRateSubscription||(t._animationRateSubscription=n.onAnimationFrameRateUpdate((()=>{const e=t.volumes[0].getRenderable().getMapper();if(e.getAutoAdjustSampleDistances()){const e=n.getRecentAnimationFrameRate(),r=t._lastScale*n.getDesiredUpdateRate()/e;t._lastScale=r,t._lastScale>400&&(t._lastScale=400)}else t._lastScale=e.getImageSampleDistance()*e.getImageSampleDistance();t._lastScale<1.5&&(t._lastScale=1.5)})))},e.rayCastPass=(e,n,r)=>{const o=t._firstGroup?t._clearEncoder:t._mergeEncoder;o.attachTextureViews(),o.begin(e.getCommandEncoder());let a=t._colorTextureView.getTexture().getWidth(),i=t._colorTextureView.getTexture().getHeight();if(t._useSmallViewport){const n=e.getCanvas(),r=1/Math.sqrt(t._lastScale);t._smallViewportWidth=Math.ceil(r*n.width),t._smallViewportHeight=Math.ceil(r*n.height),a=t._smallViewportWidth,i=t._smallViewportHeight}o.getHandle().setViewport(0,0,a,i,0,1),o.getHandle().setScissorRect(0,0,a,i),t.fullScreenQuad.setWebGPURenderer(n),t.fullScreenQuad.setVolumes(r),t.fullScreenQuad.prepareAndDraw(o),o.end()},e.renderDepthBounds=(n,r)=>{e.updateDepthPolyData(n);const o=t._boundsPoly,a=o.getPoints(),i=o.getPolys();let s={hash:`vp${i.getMTime()}`,usage:yy.Index,cells:i,numberOfPoints:a.getNumberOfPoints(),primitiveType:by.Triangles,representation:Ty.SURFACE};const l=r.getDevice().getBufferManager().getBuffer(s);t._mapper.getVertexInput().setIndexBuffer(l),s={usage:yy.PointArray,format:&quot;float32x4&quot;,hash:`vp${a.getMTime()}${i.getMTime()}`,dataArray:a,indexBuffer:l,packExtra:!0};const c=r.getDevice().getBufferManager().getBuffer(s);t._mapper.getVertexInput().addBuffer(c,[&quot;vertexBC&quot;]),t._mapper.setNumberOfVertices(c.getSizeInBytes()/c.getStrideInBytes()),e.drawDepthRange(n,r)},e.updateDepthPolyData=e=>{let n=!1;for(let e=0;e<t.volumes.length;e++){const r=t.volumes[e].getMTime();t._lastMTimes[e]&&r===t._lastMTimes[e]||(n=!0,t._lastMTimes[e]=r)}const r=e.getStabilizedTime();if((t._lastMTimes.length<=t.volumes.length||r!==t._lastMTimes[t.volumes.length])&&(n=!0,t._lastMTimes[t.volumes.length]=r),!n)return;const o=e.getStabilizedCenterByReference(),a=8*t.volumes.length,i=new Float64Array(3*a),s=12*t.volumes.length,l=new Uint16Array(4*s);for(let e=0;e<t.volumes.length;e++){t.volumes[e].getBoundingCubePoints(i,24*e);let n=12*e*4;const r=8*e;for(let e=0;e<12;e++)l[n++]=3,l[n++]=r+xy[e][0],l[n++]=r+xy[e][1],l[n++]=r+xy[e][2]}for(let e=0;e<i.length;e+=3)i[e]-=o[0],i[e+1]-=o[1],i[e+2]-=o[2];t._boundsPoly.getPoints().setData(i,3),t._boundsPoly.getPoints().modified(),t._boundsPoly.getPolys().setData(l,1),t._boundsPoly.getPolys().modified(),t._boundsPoly.modified()},e.drawDepthRange=(n,r)=>{t._depthRangeTexture.resizeToMatch(t.colorTextureView.getTexture()),t._depthRangeTexture2.resizeToMatch(t.colorTextureView.getTexture()),t._depthRangeEncoder.attachTextureViews(),e.setCurrentOperation(&quot;volumeDepthRangePass&quot;),n.setRenderEncoder(t._depthRangeEncoder),n.volumeDepthRangePass(!0),t._mapper.setWebGPURenderer(n),t._mapper.prepareToDraw(t._depthRangeEncoder),t._mapper.registerDrawCallback(t._depthRangeEncoder),n.volumeDepthRangePass(!1)},e.createDepthRangeEncoder=e=>{const n=e.getDevice();t._depthRangeEncoder=gT.newInstance({label:&quot;VolumePass DepthRange&quot;}),t._depthRangeEncoder.setPipelineHash(&quot;volr&quot;),t._depthRangeEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor1&quot;),t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor2&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor1 = vec4<f32>(input.fragPos.z, 0.0, 0.0, 0.0);&quot;,&quot;output.outColor2 = vec4<f32>(stopval, 0.0, 0.0, 0.0);&quot;]).result,t.setCode(n)})),t._depthRangeEncoder.setDescription({colorAttachments:[{view:null,clearValue:[0,0,0,0],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;},{view:null,clearValue:[1,1,1,1],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;}]}),t._depthRangeEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;r16float&quot;,blend:{color:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;,operation:&quot;max&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;,operation:&quot;max&quot;}}},{format:&quot;r16float&quot;,blend:{color:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;,operation:&quot;min&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;,operation:&quot;min&quot;}}}]}}),t._depthRangeTexture=ST.newInstance({label:&quot;volumePassMaxDepth&quot;}),t._depthRangeTexture.create(n,{width:e.getCanvas().width,height:e.getCanvas().height,format:&quot;r16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING});const r=t._depthRangeTexture.createView(&quot;maxTexture&quot;);t._depthRangeEncoder.setColorTextureView(0,r),t._depthRangeTexture2=ST.newInstance({label:&quot;volumePassDepthMin&quot;}),t._depthRangeTexture2.create(n,{width:e.getCanvas().width,height:e.getCanvas().height,format:&quot;r16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING});const o=t._depthRangeTexture2.createView(&quot;minTexture&quot;);t._depthRangeEncoder.setColorTextureView(1,o),t._mapper.setDevice(e.getDevice()),t._mapper.setTextureViews([t.depthTextureView])},e.createClearEncoder=e=>{t._colorTexture=ST.newInstance({label:&quot;volumePassColor&quot;}),t._colorTexture.create(e.getDevice(),{width:e.getCanvas().width,height:e.getCanvas().height,format:&quot;bgra8unorm&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC}),t._colorTextureView=t._colorTexture.createView(&quot;volumePassColorTexture&quot;),t._colorTextureView.addSampler(e.getDevice(),{minFilter:&quot;linear&quot;,magFilter:&quot;linear&quot;}),t._clearEncoder=gT.newInstance({label:&quot;VolumePass Clear&quot;}),t._clearEncoder.setColorTextureView(0,t._colorTextureView),t._clearEncoder.setDescription({colorAttachments:[{view:null,clearValue:[0,0,0,0],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;}]}),t._clearEncoder.setPipelineHash(&quot;volpf&quot;),t._clearEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;bgra8unorm&quot;,blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})},e.createCopyEncoder=e=>{t._copyEncoder=gT.newInstance({label:&quot;volumePassCopy&quot;}),t._copyEncoder.setDescription({colorAttachments:[{view:null,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}]}),t._copyEncoder.setPipelineHash(&quot;volcopypf&quot;),t._copyEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;rgba16float&quot;,blend:{color:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})},e.createMergeEncoder=e=>{t._mergeEncoder=gT.newInstance({label:&quot;volumePassMerge&quot;}),t._mergeEncoder.setColorTextureView(0,t._colorTextureView),t._mergeEncoder.setDescription({colorAttachments:[{view:null,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}]}),t._mergeEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor = vec4<f32>(computedColor.rgb, computedColor.a);&quot;]).result,t.setCode(n)})),t._mergeEncoder.setPipelineHash(&quot;volpf&quot;),t._mergeEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;bgra8unorm&quot;,blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})},e.setVolumes=n=>{if(!t.volumes||t.volumes.length!==n.length)return t.volumes=[...n],void e.modified();for(let r=0;r<n.length;r++)if(n[r]!==t.volumes[r])return t.volumes=[...n],void e.modified()}}(e,t)}var Ay={newInstance:Wt.newInstance(Sy,&quot;vtkWebGPUVolumePass&quot;),extend:Sy};const Iy={opaqueActorCount:0,translucentActorCount:0,volumes:null,opaqueRenderEncoder:null,translucentPass:null,volumePass:null};function wy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Iy,n),ev.extend(e,t,n),Wt.setGet(e,t,[&quot;opaquePass&quot;,&quot;translucentPass&quot;,&quot;volumePass&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkForwardPass&quot;),e.traverse=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(t.deleted)return;t._currentParent=r,e.setCurrentOperation(&quot;buildPass&quot;),n.traverse(e),t.opaquePass||(t.opaquePass=wT.newInstance());const o=n.getRenderable().getNumberOfLayers(),a=n.getChildren();for(let r=0;r<o;r++)for(let o=0;o<a.length;o++){const i=a[o],s=n.getRenderable().getRenderers()[o];s.getDraw()&&s.getLayer()===r&&(t.opaqueActorCount=0,t.translucentActorCount=0,t.volumes=[],e.setCurrentOperation(&quot;queryPass&quot;),i.traverse(e),e.setCurrentOperation(&quot;cameraPass&quot;),i.traverse(e),t.opaquePass.traverse(i,n),t.translucentActorCount>0&&(t.translucentPass||(t.translucentPass=RT.newInstance()),t.translucentPass.setColorTextureView(t.opaquePass.getColorTextureView()),t.translucentPass.setDepthTextureView(t.opaquePass.getDepthTextureView()),t.translucentPass.traverse(i,n)),t.volumes.length>0&&(t.volumePass||(t.volumePass=Ay.newInstance()),t.volumePass.setColorTextureView(t.opaquePass.getColorTextureView()),t.volumePass.setDepthTextureView(t.opaquePass.getDepthTextureView()),t.volumePass.setVolumes(t.volumes),t.volumePass.traverse(i,n)),e.finalPass(n,i))}},e.finalPass=(n,r)=>{t._finalBlitEncoder||e.createFinalBlitEncoder(n),t._finalBlitOutputTextureView.createFromTextureHandle(n.getCurrentTexture(),{depth:1,format:n.getPresentationFormat()}),t._finalBlitEncoder.attachTextureViews(),t._finalBlitEncoder.begin(n.getCommandEncoder()),r.scissorAndViewport(t._finalBlitEncoder),t._fullScreenQuad.prepareAndDraw(t._finalBlitEncoder),t._finalBlitEncoder.end()},e.createFinalBlitEncoder=e=>{t._finalBlitEncoder=gT.newInstance({label:&quot;forwardPassBlit&quot;}),t._finalBlitEncoder.setDescription({colorAttachments:[{view:null,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}]}),t._finalBlitEncoder.setPipelineHash(&quot;fpf&quot;),t._finalBlitEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:e.getPresentationFormat(),blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}}),t._fsqSampler=vT.newInstance({label:&quot;finalPassSampler&quot;}),t._fsqSampler.create(e.getDevice(),{minFilter:&quot;linear&quot;,magFilter:&quot;linear&quot;}),t._fullScreenQuad=uT.newInstance(),t._fullScreenQuad.setDevice(e.getDevice()),t._fullScreenQuad.setPipelineHash(&quot;fpfsq&quot;),t._fullScreenQuad.setTextureViews([t.opaquePass.getColorTextureView()]),t._fullScreenQuad.setAdditionalBindables([t._fsqSampler]),t._fullScreenQuad.setFragmentShaderTemplate(&quot;\\n//VTK::Mapper::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output: fragmentOutput;\\n\\n  var computedColor: vec4<f32> = clamp(textureSampleLevel(opaquePassColorTexture, finalPassSampler, input.tcoordVS, 0.0),vec4<f32>(0.0),vec4<f32>(1.0));\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;),t._finalBlitOutputTextureView=bT.newInstance(),t._finalBlitEncoder.setColorTextureView(0,t._finalBlitOutputTextureView)},e.incrementOpaqueActorCount=()=>t.opaqueActorCount++,e.incrementTranslucentActorCount=()=>t.translucentActorCount++,e.addVolume=e=>{t.volumes.push(e)}}(e,t)}var Oy={newInstance:Wt.newInstance(wy,&quot;vtkForwardPass&quot;),extend:wy};const{VtkDataTypes:Py}=xs,Ry={handle:null,device:null};function My(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ry,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;device&quot;]),function(e,t){function n(e){if(e.imageData){e.dataArray=e.imageData.getPointData().getScalars(),e.time=e.dataArray.getMTime(),e.nativeArray=e.dataArray.getData();const t=e.imageData.getDimensions();switch(e.width=t[0],e.height=t[1],e.depth=t[2],e.dataArray.getNumberOfComponents()){case 1:e.format=&quot;r&quot;;break;case 2:e.format=&quot;rg&quot;;break;default:e.format=&quot;rgba&quot;}switch(e.dataArray.getDataType()){case Py.UNSIGNED_CHAR:e.format+=&quot;8unorm&quot;;break;case Py.FLOAT:case Py.UNSIGNED_INT:case Py.INT:case Py.DOUBLE:case Py.UNSIGNED_SHORT:case Py.SHORT:default:e.format+=&quot;16float&quot;}}e.image&&(e.width=e.image.width,e.height=e.image.height,e.depth=1,e.format=&quot;rgba8unorm&quot;,e.flip=!0,e.usage=GPUTextureUsage.STORAGE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.RENDER_ATTACHMENT),e.jsImageData&&(e.width=e.jsImageData.width,e.height=e.jsImageData.height,e.depth=1,e.format=&quot;rgba8unorm&quot;,e.flip=!0,e.nativeArray=e.jsImageData.data,e.usage=GPUTextureUsage.STORAGE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.RENDER_ATTACHMENT),e.imageBitmap&&(e.width=e.imageBitmap.width,e.height=e.imageBitmap.height,e.depth=1,e.format=&quot;rgba8unorm&quot;,e.flip=!0,e.usage=GPUTextureUsage.STORAGE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.RENDER_ATTACHMENT),e.canvas&&(e.width=e.canvas.width,e.height=e.canvas.height,e.depth=1,e.format=&quot;rgba8unorm&quot;,e.flip=!0,e.usage=GPUTextureUsage.STORAGE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.RENDER_ATTACHMENT)}function r(e){const n=ST.newInstance({label:e.label});return n.create(t.device,{width:e.width,height:e.height,depth:e.depth,format:e.format,usage:e.usage,mipLevel:e.mipLevel}),(e.nativeArray||e.image||e.canvas||e.imageBitmap)&&n.writeImageData(e),n}t.classHierarchy.push(&quot;vtkWebGPUTextureManager&quot;),e.getTexture=e=>e.hash?t.device.getCachedObject(e.hash,r,e):r(e),e.getTextureForImageData=e=>{const r={time:e.getMTime()};return r.imageData=e,n(r),r.hash=r.time+r.format+r.mipLevel,t.device.getTextureManager().getTexture(r)},e.getTextureForVTKTexture=function(e){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:void 0;const o={time:e.getMTime(),label:r};return e.getInputData()?o.imageData=e.getInputData():e.getImage()?o.image=e.getImage():e.getJsImageData()?o.jsImageData=e.getJsImageData():e.getImageBitmap()?o.imageBitmap=e.getImageBitmap():e.getCanvas()&&(o.canvas=e.getCanvas()),n(o),o.mipLevel=e.getMipLevel(),o.hash=o.time+o.format+o.mipLevel,t.device.getTextureManager().getTexture(o)}}(e,t)}var Ey={newInstance:Wt.newInstance(My),extend:My};class Vy extends Map{constructor(){super(),this.registry=new FinalizationRegistry((e=>{const t=super.get(e);t&&t.deref&&void 0===t.deref()&&super.delete(e)}))}getValue(e){const t=super.get(e);if(t){const n=t.deref();if(void 0!==n)return n;super.delete(e)}}setValue(e,t){let n;return t&&&quot;object&quot;==typeof t&&(n=new WeakRef(t),this.registry.register(t,e),super.set(e,n)),n}}const Dy={handle:null,pipelines:null,shaderCache:null,bindGroupLayouts:null,bufferManager:null,textureManager:null};function Ly(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Dy,n),ht(e,t),Ct(e,t,[&quot;handle&quot;]),Tt(e,t,[&quot;bufferManager&quot;,&quot;shaderCache&quot;,&quot;textureManager&quot;]),t.objectCache=new Vy,t.shaderCache=_v.newInstance(),t.shaderCache.setDevice(e),t.bindGroupLayouts=[],t.bufferManager=ny.newInstance(),t.bufferManager.setDevice(e),t.textureManager=Ey.newInstance(),t.textureManager.setDevice(e),t.pipelines={},function(e,t){t.classHierarchy.push(&quot;vtkWebGPUDevice&quot;),e.initialize=e=>{t.handle=e},e.createCommandEncoder=()=>t.handle.createCommandEncoder(),e.submitCommandEncoder=e=>{t.handle.queue.submit([e.finish()])},e.getShaderModule=e=>t.shaderCache.getShaderModule(e),e.getBindGroupLayout=e=>{if(!e.entries)return null;for(let t=0;t<e.entries.length;t++){const n=e.entries[t];n.binding=n.binding||0,n.visibility=n.visibility||GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT}const n=JSON.stringify(e);for(let e=0;e<t.bindGroupLayouts.length;e++)if(t.bindGroupLayouts[e].sval===n)return t.bindGroupLayouts[e].layout;const r=t.handle.createBindGroupLayout(e);return t.bindGroupLayouts.push({sval:n,layout:r}),r},e.getBindGroupLayoutDescription=e=>{for(let n=0;n<t.bindGroupLayouts.length;n++)if(t.bindGroupLayouts[n].layout===e)return t.bindGroupLayouts[n].sval;return vtkErrorMacro(&quot;layout not found&quot;),console.trace(),null},e.getPipeline=e=>e in t.pipelines?t.pipelines[e]:null,e.createPipeline=(n,r)=>{r.initialize(e,n),t.pipelines[n]=r},e.onSubmittedWorkDone=()=>t.handle.queue.onSubmittedWorkDone(),e.hasCachedObject=e=>t.objectCache.getValue(e),e.getCachedObject=function(e,n){if(!e)return vtkErrorMacro(&quot;attempt to cache an object without a hash&quot;),null;const r=t.objectCache.getValue(e);if(r)return r;for(var o=arguments.length,a=new Array(o>2?o-2:0),i=2;i<o;i++)a[i-2]=arguments[i];const s=n(...a);return t.objectCache.setValue(e,s),s}}(e,t)}var By={newInstance:Mt(Ly,&quot;vtkWebGPUDevice&quot;),extend:Ly};const Ny={selectionRenderEncoder:null,colorTexture:null,depthTexture:null};function Fy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ny,n),ev.extend(e,t,n),Wt.get(e,t,[&quot;colorTexture&quot;,&quot;depthTexture&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUHardwareSelectionPass&quot;),e.traverse=(n,r)=>{if(t.deleted)return;t._currentParent=null,e.setCurrentOperation(&quot;buildPass&quot;),n.traverse(e);const o=n.getDevice();if(t.selectionRenderEncoder)t.colorTexture.resize(n.getCanvas().width,n.getCanvas().height),t.depthTexture.resizeToMatch(t.colorTexture);else{e.createRenderEncoder(),t.colorTexture=ST.newInstance({label:&quot;hardwareSelectorColor&quot;}),t.colorTexture.create(o,{width:n.getCanvas().width,height:n.getCanvas().height,format:&quot;rgba32uint&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.COPY_SRC});const r=t.colorTexture.createView(&quot;hardwareSelectColorTexture&quot;);t.selectionRenderEncoder.setColorTextureView(0,r),t.depthTexture=ST.newInstance({label:&quot;hardwareSelectorDepth&quot;}),t.depthTexture.create(o,{width:n.getCanvas().width,height:n.getCanvas().height,format:&quot;depth32float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.COPY_SRC});const a=t.depthTexture.createView(&quot;hardwareSelectDepthTexture&quot;);t.selectionRenderEncoder.setDepthTextureView(a)}t.selectionRenderEncoder.attachTextureViews(),r.setRenderEncoder(t.selectionRenderEncoder),e.setCurrentOperation(&quot;cameraPass&quot;),r.traverse(e),e.setCurrentOperation(&quot;opaquePass&quot;),r.traverse(e)},e.createRenderEncoder=()=>{t.selectionRenderEncoder=gT.newInstance({label:&quot;HardwareSelectionPass&quot;}),t.selectionRenderEncoder.setPipelineHash(&quot;sel&quot;),t.selectionRenderEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<u32>&quot;,&quot;outColor&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor = vec4<u32>(mapperUBO.PropID, compositeID, 0u, 0u);&quot;]).result,t.setCode(n)})),t.selectionRenderEncoder.getDescription().colorAttachments[0].clearValue=[0,0,0,0],t.selectionRenderEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},depthStencil:{depthWriteEnabled:!0,depthCompare:&quot;greater&quot;,format:&quot;depth32float&quot;},fragment:{targets:[{format:&quot;rgba32uint&quot;,blend:void 0}]}})}}(e,t)}var _y={newInstance:Wt.newInstance(Fy,&quot;vtkWebGPUHardwareSelectionPass&quot;),extend:Fy};const{SelectionContent:ky,SelectionField:Gy}=wp,{FieldAssociations:Uy}=Us,{vtkErrorMacro:zy}=Wt;function Wy(e){return`${e.propID} ${e.compositeID}`}function Hy(e,t,n,r){const o=4*((n.height-t-1)*n.colorBufferWidth+e)+r;return n.colorValues[o]}function jy(e,t,n,r){const o=n<0?0:n;if(0===o){if(r[0]=t[0],r[1]=t[1],t[0]<0||t[0]>=e.width||t[1]<0||t[1]>=e.height)return null;const n=Hy(t[0],t[1],e,0);if(n<=0)return null;const o={};o.propID=n;let a=Hy(t[0],t[1],e,1);if((a<0||a>16777215)&&(a=0),o.compositeID=a,e.captureZValues){const n=(e.height-t[1]-1)*e.zbufferBufferWidth+t[0];o.zValue=e.depthValues[n],o.zValue=e.webGPURenderer.convertToOpenGLDepth(o.zValue),o.displayPosition=t}return o}const a=[t[0],t[1]],i=[0,0];let s=jy(e,t,0,r);if(s)return s;for(let t=1;t<o;++t){for(let n=a[1]>t?a[1]-t:0;n<=a[1]+t;++n){if(i[1]=n,a[0]>=t&&(i[0]=a[0]-t,s=jy(e,i,0,r),s))return s;if(i[0]=a[0]+t,s=jy(e,i,0,r),s)return s}for(let n=a[0]>=t?a[0]-(t-1):0;n<=a[0]+(t-1);++n){if(i[0]=n,a[1]>=t&&(i[1]=a[1]-t,s=jy(e,i,0,r),s))return s;if(i[1]=a[1]+t,s=jy(e,i,0,r),s)return s}}return r[0]=t[0],r[1]=t[1],null}const Ky={};function $y(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ky,n),bp.extend(e,t,n),t._selectionPass=_y.newInstance(),Wt.setGet(e,t,[&quot;_WebGPURenderWindow&quot;]),Wt.moveToProtected(e,t,[&quot;WebGPURenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUHardwareSelector&quot;),e.endSelection=()=>{t.WebGPURenderer.setSelector(null)},e.getSourceDataAsync=async e=>{if(!e||!t._WebGPURenderWindow)return zy(&quot;Renderer and view must be set before calling Select.&quot;),!1;t._WebGPURenderWindow.getRenderable().preRender(),t._WebGPURenderWindow.getInitialized()||(t._WebGPURenderWindow.initialize(),await new Promise((e=>{t._WebGPURenderWindow.onInitialized(e)})));const n=t._WebGPURenderWindow.getViewNodeFor(e);if(!n)return!1;const r=n.getSuppressClear();n.setSuppressClear(!0),t._selectionPass.traverse(t._WebGPURenderWindow,n),n.setSuppressClear(r);const o=t._WebGPURenderWindow.getDevice(),a=t._selectionPass.getColorTexture(),i=t._selectionPass.getDepthTexture(),s={area:[0,0,a.getWidth()-1,a.getHeight()-1],captureZValues:t.captureZValues,fieldAssociation:t.fieldAssociation,renderer:e,webGPURenderer:n,webGPURenderWindow:t._WebGPURenderWindow,width:a.getWidth(),height:a.getHeight()};s.colorBufferWidth=16*Math.floor((s.width+15)/16),s.colorBufferSizeInBytes=s.colorBufferWidth*s.height*4*4;const l=LT.newInstance({label:&quot;hardwareSelectColorBuffer&quot;});l.setDevice(o),l.create(s.colorBufferSizeInBytes,GPUBufferUsage.MAP_READ|GPUBufferUsage.COPY_DST);const c=t._WebGPURenderWindow.getCommandEncoder();let u;c.copyTextureToBuffer({texture:a.getHandle()},{buffer:l.getHandle(),bytesPerRow:16*s.colorBufferWidth,rowsPerImage:s.height},{width:s.width,height:s.height,depthOrArrayLayers:1}),t.captureZValues&&(s.zbufferBufferWidth=64*Math.floor((s.width+63)/64),u=LT.newInstance({label:&quot;hardwareSelectDepthBuffer&quot;}),u.setDevice(o),s.zbufferSizeInBytes=s.height*s.zbufferBufferWidth*4,u.create(s.zbufferSizeInBytes,GPUBufferUsage.MAP_READ|GPUBufferUsage.COPY_DST),c.copyTextureToBuffer({texture:i.getHandle(),aspect:&quot;depth-only&quot;},{buffer:u.getHandle(),bytesPerRow:4*s.zbufferBufferWidth,rowsPerImage:s.height},{width:s.width,height:s.height,depthOrArrayLayers:1})),o.submitCommandEncoder(c);const d=l.mapAsync(GPUMapMode.READ);if(t.captureZValues){const e=u.mapAsync(GPUMapMode.READ);await Promise.all([d,e]),s.depthValues=new Float32Array(u.getMappedRange().slice()),u.unmap()}else await d;return s.colorValues=new Uint32Array(l.getMappedRange().slice()),l.unmap(),s.generateSelection=(e,t,n,r)=>function(e,t,n,r,o){const a=Math.floor(t),i=Math.floor(n),s=Math.floor(r),l=Math.floor(o),c=new Map,u=[0,0];for(let t=i;t<=l;t++)for(let n=a;n<=s;n++){const r=jy(e,[n,t],0,u);if(r){const t=Wy(r);if(c.has(t)){const n=c.get(t);n.pixelCount++,e.captureZValues&&r.zValue<n.info.zValue&&(n.info=r),-1===n.attributeIDs.indexOf(r.attributeID)&&n.attributeIDs.push(r.attributeID)}else c.set(t,{info:r,pixelCount:1,attributeIDs:[r.attributeID]})}}return function(e,t,n){const r=[];let o=0;return t.forEach(((t,a)=>{const i=wp.newInstance();switch(i.setContentType(ky.INDICES),e){case Uy.FIELD_ASSOCIATION_CELLS:i.setFieldType(Gy.CELL);break;case Uy.FIELD_ASSOCIATION_POINTS:i.setFieldType(Gy.POINT);break;default:zy(&quot;Unknown field association&quot;)}i.getProperties().propID=t.info.propID;const s=n.webGPURenderer.getPropFromID(t.info.propID);i.getProperties().prop=s.getRenderable(),i.getProperties().compositeID=t.info.compositeID,i.getProperties().pixelCount=t.pixelCount,n.captureZValues&&(i.getProperties().displayPosition=[t.info.displayPosition[0],t.info.displayPosition[1],t.info.zValue],i.getProperties().worldPosition=n.webGPURenderWindow.displayToWorld(t.info.displayPosition[0],t.info.displayPosition[1],t.info.zValue,n.renderer)),i.setSelectionList(t.attributeIDs),r[o]=i,o++})),r}(e.fieldAssociation,c,e)}(s,e,t,n,r),s}}(e,t)}var qy={newInstance:Wt.newInstance($y,&quot;vtkWebGPUHardwareSelector&quot;),extend:$y};const Xy=Object.create(null),Yy={};function Zy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Yy,n),t.overrides=Xy,Zt.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUViewNodeFactory&quot;)}(0,t)}var Qy={newInstance:Wt.newInstance(Zy,&quot;vtkWebGPUViewNodeFactory&quot;),extend:Zy};const{vtkErrorMacro:Jy}=Wt,eb={position:&quot;absolute&quot;,top:0,left:0,width:&quot;100%&quot;,height:&quot;100%&quot;};const tb={initialized:!1,context:null,adapter:null,device:null,canvas:null,cursorVisibility:!0,cursor:&quot;pointer&quot;,containerSize:null,renderPasses:[],notifyStartCaptureImage:!1,imageFormat:&quot;image/png&quot;,useOffScreen:!1,useBackgroundImage:!1,nextPropID:1,xrSupported:!1,presentationFormat:null};const nb=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,tb,n),t.canvas=document.createElement(&quot;canvas&quot;),t.canvas.style.width=&quot;100%&quot;,t.bgImage=new Image,t.bgImage.style.position=&quot;absolute&quot;,t.bgImage.style.left=&quot;0&quot;,t.bgImage.style.top=&quot;0&quot;,t.bgImage.style.width=&quot;100%&quot;,t.bgImage.style.height=&quot;100%&quot;,t.bgImage.style.zIndex=&quot;-1&quot;,xv.extend(e,t,n),t.myFactory=Qy.newInstance(),t.renderPasses[0]=Oy.newInstance(),t.selector||(t.selector=qy.newInstance(),t.selector.setWebGPURenderWindow(e)),Wt.event(e,t,&quot;imageReady&quot;),Wt.event(e,t,&quot;initialized&quot;),Wt.get(e,t,[&quot;commandEncoder&quot;,&quot;device&quot;,&quot;presentationFormat&quot;,&quot;useBackgroundImage&quot;,&quot;xrSupported&quot;]),Wt.setGet(e,t,[&quot;initialized&quot;,&quot;context&quot;,&quot;canvas&quot;,&quot;device&quot;,&quot;renderPasses&quot;,&quot;notifyStartCaptureImage&quot;,&quot;cursor&quot;,&quot;useOffScreen&quot;]),Wt.setGetArray(e,t,[&quot;size&quot;],2),Wt.event(e,t,&quot;windowResizeEvent&quot;),function(e,t){t.classHierarchy.push(&quot;vtkWebGPURenderWindow&quot;),e.getViewNodeFactory=()=>t.myFactory;const n=[0,0];e.onModified((function(){t.renderable&&(t.size[0]===n[0]&&t.size[1]===n[1]||(n[0]=t.size[0],n[1]=t.size[1],t.canvas.setAttribute(&quot;width&quot;,t.size[0]),t.canvas.setAttribute(&quot;height&quot;,t.size[1]),e.recreateSwapChain())),t.viewStream&&t.viewStream.setSize(t.size[0],t.size[1]),t.canvas.style.display=t.useOffScreen?&quot;none&quot;:&quot;block&quot;,t.el&&(t.el.style.cursor=t.cursorVisibility?t.cursor:&quot;none&quot;),t.containerSize=null})),e.recreateSwapChain=()=>{t.context&&(t.context.unconfigure(),t.presentationFormat=navigator.gpu.getPreferredCanvasFormat(t.adapter),t.context.configure({device:t.device.getHandle(),format:t.presentationFormat,alphaMode:&quot;premultiplied&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.COPY_DST,width:t.size[0],height:t.size[1]}),t._configured=!0)},e.getCurrentTexture=()=>t.context.getCurrentTexture(),e.buildPass=n=>{if(n){if(!t.renderable)return;e.prepareNodes(),e.addMissingNodes(t.renderable.getRenderersByReference()),e.removeUnusedNodes(),e.initialize()}else t.initialized&&(t._configured||e.recreateSwapChain(),t.commandEncoder=t.device.createCommandEncoder())},e.initialize=()=>{if(!t.initializing){if(t.initializing=!0,!navigator.gpu)return void Jy(&quot;WebGPU is not enabled.&quot;);e.create3DContextAsync().then((()=>{t.initialized=!0,t.deleted||e.invokeInitialized()}))}},e.setContainer=n=>{t.el&&t.el!==n&&(t.canvas.parentNode!==t.el&&Jy(&quot;Error: canvas parent node does not match container&quot;),t.el.removeChild(t.canvas),t.el.contains(t.bgImage)&&t.el.removeChild(t.bgImage)),t.el!==n&&(t.el=n,t.el&&(t.el.appendChild(t.canvas),t.useBackgroundImage&&t.el.appendChild(t.bgImage)),e.modified())},e.getContainer=()=>t.el,e.getContainerSize=()=>{if(!t.containerSize&&t.el){const{width:e,height:n}=t.el.getBoundingClientRect();t.containerSize=[e,n]}return t.containerSize||t.size},e.getFramebufferSize=()=>t.size,e.create3DContextAsync=async()=>{t.adapter=await navigator.gpu.requestAdapter({powerPreference:&quot;high-performance&quot;}),t.deleted||(t.device=By.newInstance(),t.device.initialize(await t.adapter.requestDevice()),t.deleted?t.device=null:t.context=t.canvas.getContext(&quot;webgpu&quot;))},e.releaseGraphicsResources=()=>{const n=ev.newInstance();n.setCurrentOperation(&quot;Release&quot;),n.traverse(e,null),t.adapter=null,t.device=null,t.context=null,t.initialized=!1,t.initializing=!1},e.setBackgroundImage=e=>{t.bgImage.src=e.src},e.setUseBackgroundImage=e=>{t.useBackgroundImage=e,t.useBackgroundImage&&!t.el.contains(t.bgImage)?t.el.appendChild(t.bgImage):!t.useBackgroundImage&&t.el.contains(t.bgImage)&&t.el.removeChild(t.bgImage)},e.captureNextImage=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;image/png&quot;,{resetCamera:r=!1,size:o=null,scale:a=1}=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(t.deleted)return null;t.imageFormat=n;const i=t.notifyStartCaptureImage;return t.notifyStartCaptureImage=!0,t._screenshot={size:o||1!==a?o||t.size.map((e=>e*a)):null},new Promise(((n,o)=>{const a=e.onImageReady((o=>{if(null===t._screenshot.size)t.notifyStartCaptureImage=i,a.unsubscribe(),t._screenshot.placeHolder&&(t.size=t._screenshot.originalSize,e.modified(),t._screenshot.cameras&&t._screenshot.cameras.forEach((e=>{let{restoreParamsFn:t,arg:n}=e;return t(n)})),e.traverseAllPasses(),t.el.removeChild(t._screenshot.placeHolder),t._screenshot.placeHolder.remove(),t._screenshot=null),n(o);else{const n=document.createElement(&quot;img&quot;);if(n.style=eb,n.src=o,t._screenshot.placeHolder=t.el.appendChild(n),t.canvas.style.display=&quot;none&quot;,t._screenshot.originalSize=t.size,t.size=t._screenshot.size,t._screenshot.size=null,e.modified(),r){const e=!0!==r;t._screenshot.cameras=t.renderable.getRenderers().map((t=>{const n=t.getActiveCamera(),o=n.get(&quot;focalPoint&quot;,&quot;position&quot;,&quot;parallelScale&quot;);return{resetCameraArgs:e?{renderer:t}:void 0,resetCameraFn:e?r:t.resetCamera,restoreParamsFn:n.set,arg:JSON.parse(JSON.stringify(o))}})),t._screenshot.cameras.forEach((e=>{let{resetCameraFn:t,resetCameraArgs:n}=e;return t(n)}))}e.traverseAllPasses()}}))}))},e.traverseAllPasses=()=>{if(!t.deleted)if(t.initialized){if(t.renderPasses)for(let n=0;n<t.renderPasses.length;++n)t.renderPasses[n].traverse(e,null);t.commandEncoder&&(t.device.submitCommandEncoder(t.commandEncoder),t.commandEncoder=null,t.notifyStartCaptureImage&&t.device.onSubmittedWorkDone().then((()=>{!async function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:t.imageFormat;const r=document.createElement(&quot;canvas&quot;),o=r.getContext(&quot;2d&quot;);r.width=t.canvas.width,r.height=t.canvas.height;const a=await e.getPixelsAsync(),i=new ImageData(a.colorValues,a.width,a.height);o.putImageData(i,0,0);const s=t.canvas.getBoundingClientRect();t.renderable.getRenderers().forEach((e=>{e.getViewProps().forEach((e=>{if(e.getContainer){const t=e.getContainer().getElementsByTagName(&quot;canvas&quot;);for(let e=0;e<t.length;e++){const n=t[e],r=n.getBoundingClientRect(),a=r.x-s.x,i=r.y-s.y;o.drawImage(n,a,i)}}}))}));const l=r.toDataURL(n);r.remove(),e.invokeImageReady(l)}()})))}else{e.initialize();const t=e.onInitialized((()=>{t.unsubscribe(),e.traverseAllPasses()}))}},e.setViewStream=n=>t.viewStream!==n&&(t.subscription&&(t.subscription.unsubscribe(),t.subscription=null),t.viewStream=n,t.viewStream&&(t.renderable.getRenderers()[0].getBackgroundByReference()[3]=0,e.setUseBackgroundImage(!0),t.subscription=t.viewStream.onImageReady((t=>e.setBackgroundImage(t.image))),t.viewStream.setSize(t.size[0],t.size[1]),t.viewStream.invalidateCache(),t.viewStream.render(),e.modified()),!0),e.getUniquePropID=()=>t.nextPropID++,e.getPropFromID=e=>{for(let n=0;n<t.children.length;n++){const r=t.children[n].getPropFromID(e);if(null!==r)return r}return null},e.getPixelsAsync=async()=>{const e=t.device,n=t.renderPasses[0].getOpaquePass().getColorTexture(),r={width:n.getWidth(),height:n.getHeight()};r.colorBufferWidth=32*Math.floor((r.width+31)/32),r.colorBufferSizeInBytes=r.colorBufferWidth*r.height*8;const o=LT.newInstance();o.setDevice(e),o.create(r.colorBufferSizeInBytes,GPUBufferUsage.MAP_READ|GPUBufferUsage.COPY_DST);const a=t.device.createCommandEncoder();a.copyTextureToBuffer({texture:n.getHandle()},{buffer:o.getHandle(),bytesPerRow:8*r.colorBufferWidth,rowsPerImage:r.height},{width:r.width,height:r.height,depthOrArrayLayers:1}),e.submitCommandEncoder(a);const i=o.mapAsync(GPUMapMode.READ);await i,r.colorValues=new Uint16Array(o.getMappedRange().slice()),o.unmap();const s=new Uint8ClampedArray(r.height*r.width*4);for(let e=0;e<r.height;e++)for(let t=0;t<r.width;t++){const n=4*(e*r.width+t),o=4*(e*r.colorBufferWidth+t);s[n]=255*gd.fromHalf(r.colorValues[o]),s[n+1]=255*gd.fromHalf(r.colorValues[o+1]),s[n+2]=255*gd.fromHalf(r.colorValues[o+2]),s[n+3]=255*gd.fromHalf(r.colorValues[o+3])}return r.colorValues=s,r},e.createSelector=()=>{const t=qy.newInstance();return t.setWebGPURenderWindow(e),t};const r=e.setSize;e.setSize=(t,n)=>{const o=r(t,n);return o&&e.invokeWindowResizeEvent({width:t,height:n}),o},e.delete=Wt.chain(e.delete,e.setViewStream)}(e,t)}),&quot;vtkWebGPURenderWindow&quot;);var rb;ph(&quot;WebGPU&quot;,nb),rb=nb,Xy.vtkRenderWindow=rb;const ob=Zh(),ab={margin:&quot;0&quot;,padding:&quot;0&quot;,position:&quot;absolute&quot;,top:&quot;0&quot;,left:&quot;0&quot;,width:&quot;100%&quot;,height:&quot;100%&quot;,overflow:&quot;hidden&quot;},ib={position:&quot;absolute&quot;,left:&quot;25px&quot;,top:&quot;25px&quot;,backgroundColor:&quot;white&quot;,borderRadius:&quot;5px&quot;,listStyle:&quot;none&quot;,padding:&quot;5px 10px&quot;,margin:&quot;0&quot;,display:&quot;block&quot;,border:&quot;solid 1px black&quot;,maxWidth:&quot;calc(100% - 70px)&quot;,maxHeight:&quot;calc(100% - 60px)&quot;,overflow:&quot;auto&quot;};function sb(e,t){Object.keys(t).forEach((n=>{e.style[n]=t[n]}))}const lb={background:[.32,.34,.43],containerStyle:null,controlPanelStyle:null,listenWindowResize:!0,resizeCallback:null,controllerVisibility:!0};function cb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,lb,n),Wt.obj(e,t),Wt.get(e,t,[&quot;renderWindow&quot;,&quot;renderer&quot;,&quot;apiSpecificRenderWindow&quot;,&quot;interactor&quot;,&quot;rootContainer&quot;,&quot;container&quot;,&quot;controlContainer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkFullScreenRenderWindow&quot;);const n=document.querySelector(&quot;body&quot;);function r(t){&quot;c&quot;===String.fromCharCode(t.charCode)&&e.toggleControllerVisibility()}t.rootContainer||(t.rootContainer=n),t.container||(t.container=document.createElement(&quot;div&quot;),sb(t.container,t.containerStyle||ab),t.rootContainer.appendChild(t.container)),t.rootContainer===n&&(document.documentElement.style.height=&quot;100%&quot;,n.style.height=&quot;100%&quot;,n.style.padding=&quot;0&quot;,n.style.margin=&quot;0&quot;),t.renderWindow=hh.newInstance(),t.renderer=uh.newInstance(),t.renderWindow.addRenderer(t.renderer),t.apiSpecificRenderWindow=t.renderWindow.newAPISpecificView(ob.viewAPI??t.defaultViewAPI),t.apiSpecificRenderWindow.setContainer(t.container),t.renderWindow.addView(t.apiSpecificRenderWindow),t.interactor=Dh.newInstance(),t.interactor.setInteractorStyle(qh.newInstance()),t.interactor.setView(t.apiSpecificRenderWindow),t.interactor.initialize(),t.interactor.bindEvents(t.container),e.setBackground=t.renderer.setBackground,e.removeController=()=>{const e=t.controlContainer;e&&e.parentNode.removeChild(e)},e.setControllerVisibility=e=>{t.controllerVisibility=e,t.controlContainer&&(t.controlContainer.style.display=e?&quot;block&quot;:&quot;none&quot;)},e.toggleControllerVisibility=()=>{e.setControllerVisibility(!t.controllerVisibility)},e.addController=n=>{t.controlContainer=document.createElement(&quot;div&quot;),sb(t.controlContainer,t.controlPanelStyle||ib),t.rootContainer.appendChild(t.controlContainer),t.controlContainer.innerHTML=n,e.setControllerVisibility(t.controllerVisibility),t.rootContainer.addEventListener(&quot;keypress&quot;,r)},e.setBackground(...t.background),e.addRepresentation=e=>{e.getActors().forEach((e=>{t.renderer.addActor(e)}))},e.removeRepresentation=e=>{e.getActors().forEach((e=>t.renderer.removeActor(e)))},e.delete=Wt.chain(e.setContainer,t.apiSpecificRenderWindow.delete,(()=>{t.rootContainer?.removeEventListener(&quot;keypress&quot;,r),window.removeEventListener(&quot;resize&quot;,e.resize)}),e.delete),e.resize=()=>{const e=t.container.getBoundingClientRect(),n=window.devicePixelRatio||1;t.apiSpecificRenderWindow.setSize(Math.floor(e.width*n),Math.floor(e.height*n)),t.resizeCallback&&t.resizeCallback(e),t.renderWindow.render()},e.setResizeCallback=n=>{t.resizeCallback=n,e.resize()},t.listenWindowResize&&window.addEventListener(&quot;resize&quot;,e.resize),e.resize()}(e,t)}var ub={newInstance:Wt.newInstance(cb),extend:cb},db={ColorSpace:{RGB:0,HSV:1,LAB:2,DIVERGING:3},Scale:{LINEAR:0,LOG10:1}};const{ColorSpace:pb,Scale:fb}=db,{ScalarMappingTarget:gb}=cl,{vtkDebugMacro:mb,vtkErrorMacro:hb,vtkWarningMacro:vb}=Wt;function Tb(e,t){const n=e[0],r=e[1],o=e[2],a=Math.sqrt(n*n+r*r+o*o),i=a>.001?Math.acos(n/a):0,s=i>.001?Math.atan2(o,r):0;t[0]=a,t[1]=i,t[2]=s}function yb(e,t){if(e[0]>=t-.1)return e[2];const n=e[1]*Math.sqrt(t*t-e[0]*e[0])/(e[0]*Math.sin(e[1]));return e[2]>-.3*Math.PI?e[2]+n:e[2]-n}function bb(e,t,n,r){const o=[],a=[];ha(t,o),ha(n,a);const i=[],s=[];Tb(o,i),Tb(a,s);let l=e;if(i[1]>.05&&s[1]>.05&&function(e,t){let n=e-t;for(n<0&&(n=-n);n>=2*Math.PI;)n-=2*Math.PI;return n>Math.PI&&(n=2*Math.PI-n),n}(i[2],s[2])>.33*Math.PI){let t=Math.max(i[0],s[0]);t=Math.max(88,t),e<.5?(s[0]=t,s[1]=0,s[2]=0,l*=2):(i[0]=t,i[1]=0,i[2]=0,l=2*l-1)}i[1]<.05&&s[1]>.05?i[2]=yb(s,i[0]):s[1]<.05&&i[1]>.05&&(s[2]=yb(i,s[0]));const c=[];c[0]=(1-l)*i[0]+l*s[0],c[1]=(1-l)*i[1]+l*s[1],c[2]=(1-l)*i[2]+l*s[2];const u=[];!function(e,t){const n=e[0],r=e[1],o=e[2];t[0]=n*Math.cos(r),t[1]=n*Math.sin(r)*Math.cos(o),t[2]=n*Math.sin(r)*Math.sin(o)}(c,u),va(u,r)}const xb={clamping:!0,colorSpace:pb.RGB,hSVWrap:!0,scale:fb.LINEAR,nanColor:null,belowRangeColor:null,aboveRangeColor:null,useAboveRangeColor:!1,useBelowRangeColor:!1,allowDuplicateScalars:!1,table:null,tableSize:0,buildTime:null,nodes:null,discretize:!1,numberOfValues:256};function Cb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,xb,n),cl.extend(e,t,n),t.table=[],t.nodes=[],t.nanColor=[.5,0,0,1],t.belowRangeColor=[0,0,0,1],t.aboveRangeColor=[1,1,1,1],t.buildTime={},Wt.obj(t.buildTime),Wt.get(e,t,[&quot;buildTime&quot;,&quot;mappingRange&quot;]),Wt.setGet(e,t,[&quot;useAboveRangeColor&quot;,&quot;useBelowRangeColor&quot;,&quot;discretize&quot;,&quot;numberOfValues&quot;,{type:&quot;enum&quot;,name:&quot;colorSpace&quot;,enum:pb},{type:&quot;enum&quot;,name:&quot;scale&quot;,enum:fb}]),Wt.setArray(e,t,[&quot;nanColor&quot;,&quot;belowRangeColor&quot;,&quot;aboveRangeColor&quot;],4),Wt.getArray(e,t,[&quot;nanColor&quot;,&quot;belowRangeColor&quot;,&quot;aboveRangeColor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkColorTransferFunction&quot;),e.getSize=()=>t.nodes.length,e.addRGBPoint=(t,n,r,o)=>e.addRGBPointLong(t,n,r,o,.5,0),e.addRGBPointLong=function(n,r,o,a){let i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:.5,s=arguments.length>5&&void 0!==arguments[5]?arguments[5]:0;if(i<0||i>1)return hb(&quot;Midpoint outside range [0.0, 1.0]&quot;),-1;if(s<0||s>1)return hb(&quot;Sharpness outside range [0.0, 1.0]&quot;),-1;t.allowDuplicateScalars||e.removePoint(n);const l={x:n,r:r,g:o,b:a,midpoint:i,sharpness:s};t.nodes.push(l),e.sortAndUpdateRange();let c=0;for(;c<t.nodes.length&&t.nodes[c].x!==n;c++);return c<t.nodes.length?c:-1},e.addHSVPoint=(t,n,r,o)=>e.addHSVPointLong(t,n,r,o,.5,0),e.addHSVPointLong=function(t,n,r,o){let a=arguments.length>4&&void 0!==arguments[4]?arguments[4]:.5,i=arguments.length>5&&void 0!==arguments[5]?arguments[5]:0;const s=[];return da([n,r,o],s),e.addRGBPoint(t,s[0],s[1],s[2],a,i)},e.setNodes=n=>{if(t.nodes!==n){const r=JSON.stringify(t.nodes);t.nodes=n;const o=JSON.stringify(t.nodes);if(e.sortAndUpdateRange()||r!==o)return e.modified(),!0}return!1},e.sortAndUpdateRange=()=>{const n=JSON.stringify(t.nodes);t.nodes.sort(((e,t)=>e.x-t.x));const r=JSON.stringify(t.nodes),o=e.updateRange();return o||n===r?o:(e.modified(),!0)},e.updateRange=()=>{const n=[2];n[0]=t.mappingRange[0],n[1]=t.mappingRange[1];const r=t.nodes.length;return r?(t.mappingRange[0]=t.nodes[0].x,t.mappingRange[1]=t.nodes[r-1].x):(t.mappingRange[0]=0,t.mappingRange[1]=0),(n[0]!==t.mappingRange[0]||n[1]!==t.mappingRange[1])&&(e.modified(),!0)},e.removePoint=n=>{let r=0;for(;r<t.nodes.length&&t.nodes[r].x!==n;r++);const o=r;if(r>=t.nodes.length)return-1;let a=!1;return t.nodes.splice(r,1),0!==r&&r!==t.nodes.length||(a=e.updateRange()),a||e.modified(),o},e.movePoint=(n,r)=>{if(n!==r){e.removePoint(r);for(let o=0;o<t.nodes.length;o++)if(t.nodes[o].x===n){t.nodes[o].x=r,e.sortAndUpdateRange();break}}},e.removeAllPoints=()=>{t.nodes=[],e.sortAndUpdateRange()},e.addRGBSegment=(n,r,o,a,i,s,l,c)=>{e.sortAndUpdateRange();for(let e=0;e<t.nodes.length;)t.nodes[e].x>=n&&t.nodes[e].x<=i?t.nodes.splice(e,1):e++;e.addRGBPointLong(n,r,o,a,.5,0),e.addRGBPointLong(i,s,l,c,.5,0),e.modified()},e.addHSVSegment=(t,n,r,o,a,i,s,l)=>{const c=[i,s,l],u=[],d=[];da([n,r,o],u),da(c,d),e.addRGBSegment(t,u[0],u[1],u[2],a,d[0],d[1],d[2])},e.mapValue=t=>{const n=[];return e.getColor(t,n),[Math.floor(255*n[0]+.5),Math.floor(255*n[1]+.5),Math.floor(255*n[2]+.5),255]},e.getColor=(n,r)=>{if(t.indexedLookup){const t=e.getSize(),o=e.getAnnotatedValueIndexInternal(n);if(o<0||0===t){const t=e.getNanColorByReference();r[0]=t[0],r[1]=t[1],r[2]=t[2]}else{const n=[];e.getNodeValue(o%t,n),r[0]=n[1],r[1]=n[2],r[2]=n[3]}}else e.getTable(n,n,1,r)},e.getRedValue=t=>{const n=[];return e.getColor(t,n),n[0]},e.getGreenValue=t=>{const n=[];return e.getColor(t,n),n[1]},e.getBlueValue=t=>{const n=[];return e.getColor(t,n),n[2]},e.logScaleEnabled=()=>t.scale===fb.LOG10,e.usingLogScale=()=>e.logScaleEnabled()&&t.mappingRange[0]>0,e.getTable=(n,r,o,a)=>{const i=e.usingLogScale(),s=i?Math.log10(Number(n)):Number(n),l=i?Math.log10(Number(r)):Number(r);if(Oa(s)||Oa(l)){for(let e=0;e<o;e++)a[3*e+0]=t.nanColor[0],a[3*e+1]=t.nanColor[1],a[3*e+2]=t.nanColor[2];return}let c=0;const u=t.nodes.length;let d=0,p=0,f=0;0!==u&&(d=t.nodes[u-1].r,p=t.nodes[u-1].g,f=t.nodes[u-1].b);let g=0,m=0,h=0;const v=[0,0,0],T=[0,0,0];let y=0,b=0;const x=[];let C=t.mappingRange;i&&(C=[Math.log10(t.mappingRange[0]),Math.log10(t.mappingRange[1])]);for(let n=0;n<o;n++){const r=3*n;if(g=o>1?s+n/(o-1)*(l-s):.5*(s+l),t.discretize){const e=C;if(g>=e[0]&&g<=e[1]){const n=t.numberOfValues,r=e[1]-e[0];if(n<=1)g=e[0]+r/2;else{const t=(g-e[0])/r,o=bo(n*t);g=e[0]+o/(n-1)*r}}}for(;c<u&&g>t.nodes[c].x;)c++,c<u&&(m=t.nodes[c-1].x,h=t.nodes[c].x,v[0]=t.nodes[c-1].r,T[0]=t.nodes[c].r,v[1]=t.nodes[c-1].g,T[1]=t.nodes[c].g,v[2]=t.nodes[c-1].b,T[2]=t.nodes[c].b,y=t.nodes[c-1].midpoint,b=t.nodes[c-1].sharpness,y<1e-5&&(y=1e-5),y>.99999&&(y=.99999));if(g>C[1])a[r]=0,a[r+1]=0,a[r+2]=0,t.clamping&&(e.getUseAboveRangeColor()?(a[r]=t.aboveRangeColor[0],a[r+1]=t.aboveRangeColor[1],a[r+2]=t.aboveRangeColor[2]):(a[r]=d,a[r+1]=p,a[r+2]=f));else if(g<C[0]||Aa(g)&&g<0)a[r]=0,a[r+1]=0,a[r+2]=0,t.clamping&&(e.getUseBelowRangeColor()?(a[r]=t.belowRangeColor[0],a[r+1]=t.belowRangeColor[1],a[r+2]=t.belowRangeColor[2]):u>0&&(a[r]=t.nodes[0].r,a[r+1]=t.nodes[0].g,a[r+2]=t.nodes[0].b));else if(0===c&&(Math.abs(g-s)<1e-6||t.discretize))u>0?(a[r]=t.nodes[0].r,a[r+1]=t.nodes[0].g,a[r+2]=t.nodes[0].b):(a[r]=0,a[r+1]=0,a[r+2]=0);else{let e=0;if(e=(g-m)/(h-m),e=e<y?.5*e/y:.5+.5*(e-y)/(1-y),b>.99){if(e<.5){a[r]=v[0],a[r+1]=v[1],a[r+2]=v[2];continue}a[r]=T[0],a[r+1]=T[1],a[r+2]=T[2];continue}if(b<.01){if(t.colorSpace===pb.RGB)a[r]=(1-e)*v[0]+e*T[0],a[r+1]=(1-e)*v[1]+e*T[1],a[r+2]=(1-e)*v[2]+e*T[2];else if(t.colorSpace===pb.HSV){const n=[],o=[];ua(v,n),ua(T,o),t.hSVWrap&&(n[0]-o[0]>.5||o[0]-n[0]>.5)&&(n[0]>o[0]?n[0]-=1:o[0]-=1);const i=[];i[0]=(1-e)*n[0]+e*o[0],i[0]<0&&(i[0]+=1),i[1]=(1-e)*n[1]+e*o[1],i[2]=(1-e)*n[2]+e*o[2],da(i,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]}else if(t.colorSpace===pb.LAB){const t=[],n=[];ha(v,t),ha(T,n);const o=[];o[0]=(1-e)*t[0]+e*n[0],o[1]=(1-e)*t[1]+e*n[1],o[2]=(1-e)*t[2]+e*n[2],va(o,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]}else t.colorSpace===pb.DIVERGING?(bb(e,v,T,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]):hb(&quot;ColorSpace set to invalid value.&quot;,t.colorSpace);continue}e<.5?e=.5*(2*e)**(1+10*b):e>.5&&(e=1-.5*(2*(1-e))**(1+10*b));const n=e*e,o=n*e,i=2*o-3*n+1,s=-2*o+3*n,l=o-2*n+e,c=o-n;let u,d;if(t.colorSpace===pb.RGB)for(let e=0;e<3;e++)u=T[e]-v[e],d=(1-b)*u,a[r+e]=i*v[e]+s*T[e]+l*d+c*d;else if(t.colorSpace===pb.HSV){const e=[],n=[];ua(v,e),ua(T,n),t.hSVWrap&&(e[0]-n[0]>.5||n[0]-e[0]>.5)&&(e[0]>n[0]?e[0]-=1:n[0]-=1);const o=[];for(let t=0;t<3;t++)u=n[t]-e[t],d=(1-b)*u,o[t]=i*e[t]+s*n[t]+l*d+c*d,0===t&&o[t]<0&&(o[t]+=1);da(o,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]}else if(t.colorSpace===pb.LAB){const e=[],t=[];ha(v,e),ha(T,t);const n=[];for(let r=0;r<3;r++)u=t[r]-e[r],d=(1-b)*u,n[r]=i*e[r]+s*t[r]+l*d+c*d;va(n,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]}else t.colorSpace===pb.DIVERGING?(bb(e,v,T,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]):hb(&quot;ColorSpace set to invalid value.&quot;);for(let e=0;e<3;e++)a[r+e]=a[r+e]<0?0:a[r+e],a[r+e]=a[r+e]>1?1:a[r+e]}}},e.getUint8Table=function(n,r,o){let a=arguments.length>3&&void 0!==arguments[3]&&arguments[3];if(e.getMTime()<=t.buildTime&&t.tableSize===o&&t.tableWithAlpha!==a)return t.table;if(0===t.nodes.length)return hb(&quot;Attempting to lookup a value with no points in the function&quot;),t.table;const i=a?4:3;t.tableSize===o&&t.tableWithAlpha===a||(t.table=new Uint8Array(o*i),t.tableSize=o,t.tableWithAlpha=a);const s=[];e.getTable(n,r,o,s);for(let e=0;e<o;e++)t.table[e*i+0]=Math.floor(255*s[3*e+0]+.5),t.table[e*i+1]=Math.floor(255*s[3*e+1]+.5),t.table[e*i+2]=Math.floor(255*s[3*e+2]+.5),a&&(t.table[e*i+3]=255);return t.buildTime.modified(),t.table},e.buildFunctionFromArray=n=>{e.removeAllPoints();const r=n.getNumberOfComponents();for(let e=0;e<n.getNumberOfTuples();e++)switch(r){case 3:t.nodes.push({x:e,r:n.getComponent(e,0),g:n.getComponent(e,1),b:n.getComponent(e,2),midpoint:.5,sharpness:0});break;case 4:t.nodes.push({x:n.getComponent(e,0),r:n.getComponent(e,1),g:n.getComponent(e,2),b:n.getComponent(e,3),midpoint:.5,sharpness:0});break;case 5:t.nodes.push({x:e,r:n.getComponent(e,0),g:n.getComponent(e,1),b:n.getComponent(e,2),midpoint:n.getComponent(e,4),sharpness:n.getComponent(e,5)});break;case 6:t.nodes.push({x:n.getComponent(e,0),r:n.getComponent(e,1),g:n.getComponent(e,2),b:n.getComponent(e,3),midpoint:n.getComponent(e,4),sharpness:n.getComponent(e,5)})}e.sortAndUpdateRange()},e.buildFunctionFromTable=(n,r,o,a)=>{let i=0;e.removeAllPoints(),o>1&&(i=(r-n)/(o-1));for(let e=0;e<o;e++){const r={x:n+i*e,r:a[3*e],g:a[3*e+1],b:a[3*e+2],sharpness:0,midpoint:.5};t.nodes.push(r)}e.sortAndUpdateRange()},e.getNodeValue=(e,n)=>e<0||e>=t.nodes.length?(hb(&quot;Index out of range!&quot;),-1):(n[0]=t.nodes[e].x,n[1]=t.nodes[e].r,n[2]=t.nodes[e].g,n[3]=t.nodes[e].b,n[4]=t.nodes[e].midpoint,n[5]=t.nodes[e].sharpness,1),e.setNodeValue=(n,r)=>{if(n<0||n>=t.nodes.length)return hb(&quot;Index out of range!&quot;),-1;const o=t.nodes[n].x;return t.nodes[n].x=r[0],t.nodes[n].r=r[1],t.nodes[n].g=r[2],t.nodes[n].b=r[3],t.nodes[n].midpoint=r[4],t.nodes[n].sharpness=r[5],o!==r[0]?e.sortAndUpdateRange():e.modified(),1},e.getNumberOfAvailableColors=()=>{if(t.indexedLookup&&e.getSize())return e.getSize();if(t.tableSize)return t.tableSize;const n=t.nodes?.length??0;return Math.max(4094,n)},e.getIndexedColor=(t,n)=>{const r=e.getSize();if(r>0&&t>=0){const o=[];e.getNodeValue(t%r,o);for(let e=0;e<3;++e)n[e]=o[e+1];return void(n[3]=1)}const o=e.getNanColorByReference();n[0]=o[0],n[1]=o[1],n[2]=o[2],n[3]=1},e.fillFromDataPointer=(t,n)=>{if(!(t<=0)&&n){e.removeAllPoints();for(let r=0;r<t;r++)e.addRGBPoint(n[4*r],n[4*r+1],n[4*r+2],n[4*r+3])}},e.setMappingRange=(n,r)=>{const o=[n,r],a=[n,r],i=e.getRange(),s=e.logScaleEnabled();if(i[1]===o[1]&&i[0]===o[0])return;if(o[1]===o[0])return void hb(&quot;attempt to set zero width color range&quot;);s&&(o[0]<=0?console.warn(&quot;attempt to set log scale color range with non-positive minimum&quot;):(a[0]=Math.log10(o[0]),a[1]=Math.log10(o[1])));const l=(a[1]-a[0])/(i[1]-i[0]),c=a[0]-i[0]*l;for(let e=0;e<t.nodes.length;++e)t.nodes[e].x=t.nodes[e].x*l+c;t.mappingRange[0]=o[0],t.mappingRange[1]=o[1],e.modified()},e.adjustRange=n=>{const r=e.getRange(),o=[];r[0]<n[0]?(e.getColor(n[0],o),e.addRGBPoint(n[0],o[0],o[1],o[2])):(e.getColor(r[0],o),e.addRGBPoint(n[0],o[0],o[1],o[2])),r[1]>n[1]?(e.getColor(n[1],o),e.addRGBPoint(n[1],o[0],o[1],o[2])):(e.getColor(r[1],o),e.addRGBPoint(n[1],o[0],o[1],o[2])),e.sortAndUpdateRange();for(let e=0;e<t.nodes.length;)t.nodes[e].x>=n[0]&&t.nodes[e].x<=n[1]?t.nodes.splice(e,1):++e;return 1},e.estimateMinNumberOfSamples=(t,n)=>{const r=e.findMinimumXDistance();return Math.ceil((n-t)/r)},e.findMinimumXDistance=()=>{if(t.nodes.length<2)return-1;let e=Number.MAX_VALUE;for(let n=0;n<t.nodes.length-1;n++){const r=t.nodes[n+1].x-t.nodes[n].x;r<e&&(e=r)}return e},e.mapScalarsThroughTable=(n,r,o,a)=>{0!==e.getSize()?t.indexedLookup?e.mapDataIndexed(n,r,o,a):e.mapData(n,r,o,a):mb(&quot;Transfer Function Has No Points!&quot;)},e.mapData=(t,n,r,o)=>{if(0===e.getSize())return void vb(&quot;Transfer Function Has No Points!&quot;);const a=Math.floor(255*e.getAlpha()+.5),i=t.getNumberOfTuples(),s=t.getNumberOfComponents(),l=n.getData(),c=t.getData(),u=[];if(r===gb.RGBA)for(let t=0;t<i;t++){const n=c[t*s+o];e.getColor(n,u),l[4*t]=Math.floor(255*u[0]+.5),l[4*t+1]=Math.floor(255*u[1]+.5),l[4*t+2]=Math.floor(255*u[2]+.5),l[4*t+3]=a}if(r===gb.RGB)for(let t=0;t<i;t++){const n=c[t*s+o];e.getColor(n,u),l[3*t]=Math.floor(255*u[0]+.5),l[3*t+1]=Math.floor(255*u[1]+.5),l[3*t+2]=Math.floor(255*u[2]+.5)}if(r===gb.LUMINANCE)for(let t=0;t<i;t++){const n=c[t*s+o];e.getColor(n,u),l[t]=Math.floor(76.5*u[0]+150.45*u[1]+28.05*u[2]+.5)}if(r===gb.LUMINANCE_ALPHA)for(let t=0;t<i;t++){const n=c[t*s+o];e.getColor(n,u),l[2*t]=Math.floor(76.5*u[0]+150.45*u[1]+28.05*u[2]+.5),l[2*t+1]=a}},e.applyColorMap=n=>{const r=JSON.stringify(t.colorSpace);n.ColorSpace&&(t.colorSpace=pb[n.ColorSpace.toUpperCase()],void 0===t.colorSpace&&(hb(`ColorSpace ${n.ColorSpace} not supported, using RGB instead`),t.colorSpace=pb.RGB));let o=r!==JSON.stringify(t.colorSpace);const a=o||JSON.stringify(t.nanColor);if(n.NanColor)for(t.nanColor=[].concat(n.NanColor);t.nanColor.length<4;)t.nanColor.push(1);o=o||a!==JSON.stringify(t.nanColor);const i=o||JSON.stringify(t.nodes);if(n.RGBPoints){const e=n.RGBPoints.length;t.nodes=[];const r=.5,o=0;for(let a=0;a<e;a+=4)t.nodes.push({x:n.RGBPoints[a],r:n.RGBPoints[a+1],g:n.RGBPoints[a+2],b:n.RGBPoints[a+3],midpoint:r,sharpness:o})}const s=e.sortAndUpdateRange(),l=!s&&(o||i!==JSON.stringify(t.nodes));return l&&e.modified(),s||l}}(e,t)}var Sb={newInstance:Wt.newInstance(Cb,&quot;vtkColorTransferFunction&quot;),extend:Cb,...db},Ab={OrientationModes:{DIRECTION:0,ROTATION:1,MATRIX:2},ScaleModes:{SCALE_BY_CONSTANT:0,SCALE_BY_MAGNITUDE:1,SCALE_BY_COMPONENTS:2}};const{OrientationModes:Ib,ScaleModes:wb}=Ab,{vtkErrorMacro:Ob}=Wt,Pb={orient:!0,orientationMode:Ib.DIRECTION,orientationArray:null,scaling:!0,scaleFactor:1,scaleMode:wb.SCALE_BY_MAGNITUDE,scaleArray:null,matrixArray:null,normalArray:null,colorArray:null};function Rb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Pb,n),Gl.extend(e,t,n),Wt.algo(e,t,2,0),t.buildTime={},Wt.obj(t.buildTime,{mtime:0}),t.boundsTime={},Wt.obj(t.boundsTime,{mtime:0}),Wt.setGet(e,t,[&quot;orient&quot;,&quot;orientationMode&quot;,&quot;orientationArray&quot;,&quot;scaleArray&quot;,&quot;scaleFactor&quot;,&quot;scaleMode&quot;,&quot;scaling&quot;]),Wt.get(e,t,[&quot;colorArray&quot;,&quot;matrixArray&quot;,&quot;normalArray&quot;,&quot;buildTime&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkGlyph3DMapper&quot;),e.getOrientationModeAsString=()=>Wt.enumToString(Ib,t.orientationMode),e.setOrientationModeToDirection=()=>e.setOrientationMode(Ib.DIRECTION),e.setOrientationModeToRotation=()=>e.setOrientationMode(Ib.ROTATION),e.setOrientationModeToMatrix=()=>e.setOrientationMode(Ib.MATRIX),e.getOrientationArrayData=()=>{const n=e.getInputData(0);return n&&n.getPointData()?t.orientationArray?n.getPointData().getArray(t.orientationArray):n.getPointData().getVectors():null},e.getScaleModeAsString=()=>Wt.enumToString(wb,t.scaleMode),e.setScaleModeToScaleByMagnitude=()=>e.setScaleMode(wb.SCALE_BY_MAGNITUDE),e.setScaleModeToScaleByComponents=()=>e.setScaleMode(wb.SCALE_BY_COMPONENTS),e.setScaleModeToScaleByConstant=()=>e.setScaleMode(wb.SCALE_BY_CONSTANT),e.getScaleArrayData=()=>{const n=e.getInputData(0);return n&&n.getPointData()?t.scaleArray?n.getPointData().getArray(t.scaleArray):n.getPointData().getScalars():null},e.getBounds=()=>{const n=e.getInputData(0),r=e.getInputData(1);return n&&r?(e.buildArrays(),t.bounds):Pa()},e.buildArrays=()=>{const n=e.getInputData(0),r=e.getInputData(1);if(t.buildTime.getMTime()<r.getMTime()||t.buildTime.getMTime()<n.getMTime()||t.buildTime.getMTime()<e.getMTime()){const o=n.getPoints().getData();let a=e.getScaleArrayData(),i=null,s=0;a&&(i=a.getData(),s=a.getNumberOfComponents()),t.scaling&&a&&t.scaleMode===wb.SCALE_BY_COMPONENTS&&3!==a.getNumberOfComponents()&&(Ob(&quot;Cannot scale by components since scale array does not have 3 components.&quot;),a=null);const l=r.getBounds(),c=[];Gi.getCorners(l,c),t.bounds[0]=Gi.INIT_BOUNDS[0],t.bounds[1]=Gi.INIT_BOUNDS[1],t.bounds[2]=Gi.INIT_BOUNDS[2],t.bounds[3]=Gi.INIT_BOUNDS[3],t.bounds[4]=Gi.INIT_BOUNDS[4],t.bounds[5]=Gi.INIT_BOUNDS[5];const u=new Float64Array(3),d=e.getOrientationArrayData(),p=m(new Float64Array(16)),f=[],g=[],h=o.length/3;t.matrixArray=new Float32Array(16*h);const v=t.matrixArray.buffer;t.normalArray=new Float32Array(9*h);const T=t.normalArray.buffer,y=[],O=[];for(let e=0;e<h;++e){const n=new Float32Array(v,64*e,16);if(f[0]=o[3*e],f[1]=o[3*e+1],f[2]=o[3*e+2],x(n,p,f),d)switch(d.getTuple(e,O),t.orientationMode){case Ib.MATRIX:b(n,n,[...O.slice(0,3),0,...O.slice(3,6),0,...O.slice(6,9),0,0,0,0,1]);break;case Ib.ROTATION:w(n,n,O[2]),A(n,n,O[0]),I(n,n,O[1]);break;case Ib.DIRECTION:if(0===O[1]&&0===O[2])O[0]<0&&I(n,n,3.1415926);else{const e=No(O),t=[];t[0]=(O[0]+e)/2,t[1]=O[1]/2,t[2]=O[2]/2,S(n,n,3.1415926,t)}}if(t.scaling){if(g[0]=t.scaleFactor,g[1]=t.scaleFactor,g[2]=t.scaleFactor,a)switch(t.scaleMode){case wb.SCALE_BY_MAGNITUDE:for(let t=0;t<s;++t)y[t]=i[e*s+t];g[0]*=No(y,s),g[1]=g[0],g[2]=g[0];break;case wb.SCALE_BY_COMPONENTS:for(let t=0;t<s;++t)y[t]=i[e*s+t];g[0]*=y[0],g[1]*=y[1],g[2]*=y[2];case wb.SCALE_BY_CONSTANT:}0===g[0]&&(g[0]=1e-10),0===g[1]&&(g[1]=1e-10),0===g[2]&&(g[2]=1e-10),C(n,n,g)}for(let e=0;e<8;++e)In(u,c[e],n),u[0]<t.bounds[0]&&(t.bounds[0]=u[0]),u[1]<t.bounds[2]&&(t.bounds[2]=u[1]),u[2]<t.bounds[4]&&(t.bounds[4]=u[2]),u[0]>t.bounds[1]&&(t.bounds[1]=u[0]),u[1]>t.bounds[3]&&(t.bounds[3]=u[1]),u[2]>t.bounds[5]&&(t.bounds[5]=u[2]);const r=new Float32Array(T,36*e,9);le(r,n),me(r,r),ge(r,r)}const P=e.getAbstractScalars(n,t.scalarMode,t.arrayAccessMode,t.arrayId,t.colorByArrayName).scalars;t.useLookupTableScalarRange||e.getLookupTable().setRange(t.scalarRange[0],t.scalarRange[1]),t.colorArray=null;const R=e.getLookupTable();R&&P&&(R.build(),t.colorArray=R.mapScalars(P,t.colorMode,0)),t.buildTime.modified()}},e.getPrimitiveCount=()=>{const t=e.getInputData(1),n=e.getInputData().getPoints().getNumberOfValues()/3;return{points:n*t.getPoints().getNumberOfValues()/3,verts:n*(t.getVerts().getNumberOfValues()-t.getVerts().getNumberOfCells()),lines:n*(t.getLines().getNumberOfValues()-2*t.getLines().getNumberOfCells()),triangles:n*(t.getPolys().getNumberOfValues()-3*t.getLines().getNumberOfCells())}},e.setSourceConnection=t=>e.setInputConnection(t,1)}(e,t)}var Mb={newInstance:Wt.newInstance(Rb,&quot;vtkGlyph3DMapper&quot;),extend:Rb,...Ab};const{vtkErrorMacro:Eb}=Wt,Vb={range:[0,0],clamping:!0,allowDuplicateScalars:!1};function Db(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Vb,n),Wt.obj(e,t),t.nodes=[],Wt.setGet(e,t,[&quot;allowDuplicateScalars&quot;,&quot;clamping&quot;]),Wt.setArray(e,t,[&quot;range&quot;],2),Wt.getArray(e,t,[&quot;range&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkPiecewiseFunction&quot;),e.getSize=()=>t.nodes.length,e.getType=()=>{let e,n=0,r=0;t.nodes.length>0&&(n=t.nodes[0].y);for(let o=1;o<t.nodes.length;o++){if(e=t.nodes[o].y,e!==n)if(e>n)switch(r){case 0:case 1:r=1;break;default:r=3}else switch(r){case 0:case 2:r=2;break;default:r=3}if(n=e,3===r)break}switch(r){case 0:return&quot;Constant&quot;;case 1:return&quot;NonDecreasing&quot;;case 2:return&quot;NonIncreasing&quot;;default:return&quot;Varied&quot;}},e.getDataPointer=()=>{const e=t.nodes.length;if(t.function=null,e>0){t.function=[];for(let n=0;n<e;n++)t.function[2*n]=t.nodes[n].x,t.function[2*n+1]=t.nodes[n].y}return t.function},e.getFirstNonZeroValue=()=>{if(0===t.nodes.length)return 0;let e=1,n=0,r=0;for(;r<t.nodes.length;r++)if(0!==t.nodes[r].y){e=0;break}return n=e?Number.MAX_VALUE:r>0?t.nodes[r-1].x:t.clamping?-Number.MAX_VALUE:t.nodes[0].x,n},e.getNodeValue=(e,n)=>{const r=t.nodes.length;return e<0||e>=r?(Eb(&quot;Index out of range!&quot;),-1):(n[0]=t.nodes[e].x,n[1]=t.nodes[e].y,n[2]=t.nodes[e].midpoint,n[3]=t.nodes[e].sharpness,1)},e.setNodeValue=(n,r)=>{const o=t.nodes.length;if(n<0||n>=o)return Eb(&quot;Index out of range!&quot;),-1;const a=t.nodes[n].x;return t.nodes[n].x=r[0],t.nodes[n].y=r[1],t.nodes[n].midpoint=r[2],t.nodes[n].sharpness=r[3],a!==r[0]?e.sortAndUpdateRange():e.modified(),1},e.addPoint=(t,n)=>e.addPointLong(t,n,.5,0),e.addPointLong=(n,r,o,a)=>{if(o<0||o>1)return Eb(&quot;Midpoint outside range [0.0, 1.0]&quot;),-1;if(a<0||a>1)return Eb(&quot;Sharpness outside range [0.0, 1.0]&quot;),-1;t.allowDuplicateScalars||e.removePoint(n);const i={x:n,y:r,midpoint:o,sharpness:a};let s;for(t.nodes.push(i),e.sortAndUpdateRange(),s=0;s<t.nodes.length&&t.nodes[s].x!==n;s++);return s<t.nodes.length?s:-1},e.setNodes=n=>{t.nodes!==n&&(t.nodes=n,e.sortAndUpdateRange())},e.sortAndUpdateRange=()=>{t.nodes.sort(((e,t)=>e.x-t.x)),e.updateRange()||e.modified()},e.updateRange=()=>{const n=t.range.slice(),r=t.nodes.length;return r?(t.range[0]=t.nodes[0].x,t.range[1]=t.nodes[r-1].x):(t.range[0]=0,t.range[1]=0),(n[0]!==t.range[0]||n[1]!==t.range[1])&&(e.modified(),!0)},e.removePoint=n=>{let r;for(r=0;r<t.nodes.length&&t.nodes[r].x!==n;r++);if(r>=t.nodes.length)return-1;const o=r;let a=!1;return t.nodes.splice(r,1),0!==r&&r!==t.nodes.length||(a=e.updateRange()),a||e.modified(),o},e.removeAllPoints=()=>{t.nodes=[],e.sortAndUpdateRange()},e.addSegment=(n,r,o,a)=>{e.sortAndUpdateRange();for(let e=0;e<t.nodes.length;)t.nodes[e].x>=n&&t.nodes[e].x<=o?t.nodes.splice(e,1):e++;e.addPoint(n,r,.5,0),e.addPoint(o,a,.5,0)},e.getValue=t=>{const n=[];return e.getTable(t,t,1,n),n[0]},e.adjustRange=n=>{if(n.length<2)return 0;const r=e.getRange();r[0]<n[0]?e.addPoint(n[0],e.getValue(n[0])):e.addPoint(n[0],e.getValue(r[0])),r[1]>n[1]?e.addPoint(n[1],e.getValue(n[1])):e.addPoint(n[1],e.getValue(r[1])),e.sortAndUpdateRange();for(let e=0;e<t.nodes.length;)t.nodes[e].x>=n[0]&&t.nodes[e].x<=n[1]?t.nodes.splice(e,1):++e;return e.sortAndUpdateRange(),1},e.estimateMinNumberOfSamples=(t,n)=>{const r=e.findMinimumXDistance();return Math.ceil((n-t)/r)},e.findMinimumXDistance=()=>{const e=t.nodes.length;if(e<2)return-1;let n=t.nodes[1].x-t.nodes[0].x;for(let r=0;r<e-1;r++){const e=t.nodes[r+1].x-t.nodes[r].x;e<n&&(n=e)}return n},e.getTable=function(e,n,r,o){let a,i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:1,s=0;const l=t.nodes.length;let c=0;0!==l&&(c=t.nodes[l-1].y);let u=0,d=0,p=0,f=0,g=0,m=0,h=0;for(a=0;a<r;a++){const v=i*a;for(u=r>1?e+a/(r-1)*(n-e):.5*(e+n);s<l&&u>t.nodes[s].x;)s++,s<l&&(d=t.nodes[s-1].x,p=t.nodes[s].x,f=t.nodes[s-1].y,g=t.nodes[s].y,m=t.nodes[s-1].midpoint,h=t.nodes[s-1].sharpness,m<1e-5&&(m=1e-5),m>.99999&&(m=.99999));if(s>=l)o[v]=t.clamping?c:0;else if(0===s)o[v]=t.clamping?t.nodes[0].y:0;else{let e=(u-d)/(p-d);if(e=e<m?.5*e/m:.5+.5*(e-m)/(1-m),h>.99){if(e<.5){o[v]=f;continue}o[v]=g;continue}if(h<.01){o[v]=(1-e)*f+e*g;continue}e<.5?e=.5*(2*e)**(1+10*h):e>.5&&(e=1-.5*(2*(1-e))**(1+10*h));const t=e*e,n=t*e,r=2*n-3*t+1,a=-2*n+3*t,i=n-2*t+e,s=n-t,l=(1-h)*(g-f);o[v]=r*f+a*g+i*l+s*l;const c=f<g?f:g,T=f>g?f:g;o[v]=o[v]<c?c:o[v],o[v]=o[v]>T?T:o[v]}}}}(e,t)}var Lb={newInstance:Wt.newInstance(Db,&quot;vtkPiecewiseFunction&quot;),extend:Db};const{InterpolationType:Bb,OpacityMode:Nb,FilterMode:Fb,ColorMixPreset:_b}=Jf,{vtkErrorMacro:kb}=Wt;function Gb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};if(Object.assign(t,(e=>({colorMixPreset:_b.DEFAULT,independentComponents:!0,interpolationType:Bb.FAST_LINEAR,shade:!1,ambient:.1,diffuse:.7,specular:.2,specularPower:10,useLabelOutline:!1,labelOutlineThickness:[1],labelOutlineOpacity:1,ipScalarRange:[-1e6,1e6],filterMode:Fb.OFF,preferSizeOverAccuracy:!1,computeNormalFromOpacity:!1,volumetricScatteringBlending:0,globalIlluminationReach:0,anisotropy:0,localAmbientOcclusion:!1,LAOKernelSize:15,LAOKernelRadius:7,updatedExtents:[],...e}))(n)),Wt.obj(e,t),!t.componentData){t.componentData=[];for(let e=0;e<4;++e)t.componentData.push({colorChannels:1,grayTransferFunction:null,rGBTransferFunction:null,scalarOpacity:null,scalarOpacityUnitDistance:1,opacityMode:Nb.FRACTIONAL,gradientOpacityMinimumValue:0,gradientOpacityMinimumOpacity:0,gradientOpacityMaximumValue:1,gradientOpacityMaximumOpacity:1,useGradientOpacity:!1,componentWeight:1,forceNearestInterpolation:!1})}Wt.setGet(e,t,[&quot;colorMixPreset&quot;,&quot;independentComponents&quot;,&quot;interpolationType&quot;,&quot;shade&quot;,&quot;ambient&quot;,&quot;diffuse&quot;,&quot;specular&quot;,&quot;specularPower&quot;,&quot;useLabelOutline&quot;,&quot;labelOutlineOpacity&quot;,&quot;filterMode&quot;,&quot;preferSizeOverAccuracy&quot;,&quot;computeNormalFromOpacity&quot;,&quot;volumetricScatteringBlending&quot;,&quot;globalIlluminationReach&quot;,&quot;anisotropy&quot;,&quot;localAmbientOcclusion&quot;,&quot;LAOKernelSize&quot;,&quot;LAOKernelRadius&quot;,&quot;updatedExtents&quot;]),Wt.setGetArray(e,t,[&quot;ipScalarRange&quot;],2),Wt.setGetArray(e,t,[&quot;labelOutlineThickness&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkVolumeProperty&quot;);const n={...e};e.getMTime=()=>{let e,n=t.mtime;for(let r=0;r<4;r++)1===t.componentData[r].colorChannels?t.componentData[r].grayTransferFunction&&(e=t.componentData[r].grayTransferFunction.getMTime(),n=n>e?n:e):3===t.componentData[r].colorChannels&&t.componentData[r].rGBTransferFunction&&(e=t.componentData[r].rGBTransferFunction.getMTime(),n=n>e?n:e),t.componentData[r].scalarOpacity&&(e=t.componentData[r].scalarOpacity.getMTime(),n=n>e?n:e),t.componentData[r].gradientOpacity&&(t.componentData[r].disableGradientOpacity||(e=t.componentData[r].gradientOpacity.getMTime(),n=n>e?n:e));return n},e.getColorChannels=e=>e<0||e>3?(kb(&quot;Bad index - must be between 0 and 3&quot;),0):t.componentData[e].colorChannels,e.setGrayTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,o=!1;return t.componentData[n].grayTransferFunction!==r&&(t.componentData[n].grayTransferFunction=r,o=!0),1!==t.componentData[n].colorChannels&&(t.componentData[n].colorChannels=1,o=!0),o&&e.modified(),o},e.getGrayTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return null===t.componentData[n].grayTransferFunction&&(t.componentData[n].grayTransferFunction=Lb.newInstance(),t.componentData[n].grayTransferFunction.addPoint(0,0),t.componentData[n].grayTransferFunction.addPoint(1024,1),1!==t.componentData[n].colorChannels&&(t.componentData[n].colorChannels=1),e.modified()),t.componentData[n].grayTransferFunction},e.setRGBTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,o=!1;return t.componentData[n].rGBTransferFunction!==r&&(t.componentData[n].rGBTransferFunction=r,o=!0),3!==t.componentData[n].colorChannels&&(t.componentData[n].colorChannels=3,o=!0),o&&e.modified(),o},e.getRGBTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return null===t.componentData[n].rGBTransferFunction&&(t.componentData[n].rGBTransferFunction=Sb.newInstance(),t.componentData[n].rGBTransferFunction.addRGBPoint(0,0,0,0),t.componentData[n].rGBTransferFunction.addRGBPoint(1024,1,1,1),3!==t.componentData[n].colorChannels&&(t.componentData[n].colorChannels=3),e.modified()),t.componentData[n].rGBTransferFunction},e.setScalarOpacity=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;return t.componentData[n].scalarOpacity!==r&&(t.componentData[n].scalarOpacity=r,e.modified(),!0)},e.getScalarOpacity=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return null===t.componentData[n].scalarOpacity&&(t.componentData[n].scalarOpacity=Lb.newInstance(),t.componentData[n].scalarOpacity.addPoint(0,1),t.componentData[n].scalarOpacity.addPoint(1024,1),e.modified()),t.componentData[n].scalarOpacity},e.setComponentWeight=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;if(n<0||n>=4)return kb(&quot;Invalid index&quot;),!1;const o=Math.min(1,Math.max(0,r));return t.componentData[n].componentWeight!==o&&(t.componentData[n].componentWeight=o,e.modified(),!0)},e.getComponentWeight=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return e<0||e>=4?(kb(&quot;Invalid index&quot;),0):t.componentData[e].componentWeight},e.setInterpolationTypeToNearest=()=>e.setInterpolationType(Bb.NEAREST),e.setInterpolationTypeToLinear=()=>e.setInterpolationType(Bb.LINEAR),e.setInterpolationTypeToFastLinear=()=>e.setInterpolationType(Bb.FAST_LINEAR),e.getInterpolationTypeAsString=()=>Wt.enumToString(Bb,t.interpolationType),[&quot;useGradientOpacity&quot;,&quot;scalarOpacityUnitDistance&quot;,&quot;gradientOpacityMinimumValue&quot;,&quot;gradientOpacityMinimumOpacity&quot;,&quot;gradientOpacityMaximumValue&quot;,&quot;gradientOpacityMaximumOpacity&quot;,&quot;opacityMode&quot;,&quot;forceNearestInterpolation&quot;].forEach((n=>{const r=Wt.capitalize(n);e[`set${r}`]=(r,o)=>t.componentData[r][`${n}`]!==o&&(t.componentData[r][`${n}`]=o,e.modified(),!0)})),[&quot;useGradientOpacity&quot;,&quot;scalarOpacityUnitDistance&quot;,&quot;gradientOpacityMinimumValue&quot;,&quot;gradientOpacityMinimumOpacity&quot;,&quot;gradientOpacityMaximumValue&quot;,&quot;gradientOpacityMaximumOpacity&quot;,&quot;opacityMode&quot;,&quot;forceNearestInterpolation&quot;].forEach((n=>{const r=Wt.capitalize(n);e[`get${r}`]=e=>t.componentData[e][`${n}`]})),e.setAverageIPScalarRange=(t,n)=>{console.warn(&quot;setAverageIPScalarRange is deprecated use setIpScalarRange&quot;),e.setIpScalarRange(t,n)},e.getFilterModeAsString=()=>Wt.enumToString(Fb,t.filterMode),e.setFilterModeToOff=()=>{e.setFilterMode(Fb.OFF)},e.setFilterModeToNormalized=()=>{e.setFilterMode(Fb.NORMALIZED)},e.setFilterModeToRaw=()=>{e.setFilterMode(Fb.RAW)},e.setGlobalIlluminationReach=e=>n.setGlobalIlluminationReach(ba(e,0,1)),e.setVolumetricScatteringBlending=e=>n.setVolumetricScatteringBlending(ba(e,0,1)),e.setAnisotropy=e=>n.setAnisotropy(ba(e,-.99,.99)),e.setLAOKernelSize=e=>n.setLAOKernelSize(bo(ba(e,1,32))),e.setLAOKernelRadius=e=>n.setLAOKernelRadius(e>=1?e:1)}(e,t)}var Ub={newInstance:Wt.newInstance(Gb,&quot;vtkVolumeProperty&quot;),extend:Gb,...Jf};const zb={mapper:null};function Wb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,zb,n),Xi.extend(e,t,n),t.boundsMTime={},Wt.obj(t.boundsMTime),Wt.setGet(e,t,[&quot;mapper&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkVolume&quot;),e.getVolumes=()=>[e],e.makeProperty=Ub.newInstance,e.getRedrawMTime=()=>{let e=t.mtime;if(null!==t.mapper){let n=t.mapper.getMTime();e=n>e?n:e,null!==t.mapper.getInput()&&(t.mapper.getInputAlgorithm().update(),n=t.mapper.getInput().getMTime(),e=n>e?n:e)}return e}}(e,t)}var Hb={newInstance:Wt.newInstance(Wb,&quot;vtkVolume&quot;),extend:Wb};const{BlendMode:jb}=tg,Kb=[&quot;getAnisotropy&quot;,&quot;getComputeNormalFromOpacity&quot;,&quot;getFilterMode&quot;,&quot;getFilterModeAsString&quot;,&quot;getGlobalIlluminationReach&quot;,&quot;getIpScalarRange&quot;,&quot;getIpScalarRangeByReference&quot;,&quot;getLAOKernelRadius&quot;,&quot;getLAOKernelSize&quot;,&quot;getLocalAmbientOcclusion&quot;,&quot;getPreferSizeOverAccuracy&quot;,&quot;getVolumetricScatteringBlending&quot;,&quot;setAnisotropy&quot;,&quot;setAverageIPScalarRange&quot;,&quot;setComputeNormalFromOpacity&quot;,&quot;setFilterMode&quot;,&quot;setFilterModeToNormalized&quot;,&quot;setFilterModeToOff&quot;,&quot;setFilterModeToRaw&quot;,&quot;setGlobalIlluminationReach&quot;,&quot;setIpScalarRange&quot;,&quot;setIpScalarRangeFrom&quot;,&quot;setLAOKernelRadius&quot;,&quot;setLAOKernelSize&quot;,&quot;setLocalAmbientOcclusion&quot;,&quot;setPreferSizeOverAccuracy&quot;,&quot;setVolumetricScatteringBlending&quot;],$b={createRadonTransferFunction:function(e,t,n,r,o){let a=null;return o?(a=o,a.removeAllPoints()):a=Lb.newInstance(),a.addPointLong(-1024,0,1,1),a.addPoint(e,t),a.addPoint(n,r),a}};function qb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,(e=>({bounds:[...Gi.INIT_BOUNDS],sampleDistance:1,imageSampleDistance:1,maximumSamplesPerRay:1e3,autoAdjustSampleDistances:!0,initialInteractionScale:1,interactionSampleDistanceFactor:1,blendMode:jb.COMPOSITE_BLEND,volumeShadowSamplingDistFactor:5,colorTextureWidth:1024,opacityTextureWidth:1024,labelOutlineTextureWidth:1024,...e}))(n)),As(e,t,n),Wt.setGet(e,t,[&quot;sampleDistance&quot;,&quot;imageSampleDistance&quot;,&quot;maximumSamplesPerRay&quot;,&quot;autoAdjustSampleDistances&quot;,&quot;initialInteractionScale&quot;,&quot;interactionSampleDistanceFactor&quot;,&quot;blendMode&quot;,&quot;volumeShadowSamplingDistFactor&quot;,&quot;colorTextureWidth&quot;,&quot;opacityTextureWidth&quot;,&quot;labelOutlineTextureWidth&quot;]),Wt.event(e,t,&quot;lightingActivated&quot;),function(e,t){t.classHierarchy.push(&quot;vtkVolumeMapper&quot;);const n={...e};e.getBounds=()=>(t.static||e.update(),t.bounds=[...e.getInputData().getBounds()],t.bounds),e.setBlendModeToComposite=()=>{e.setBlendMode(jb.COMPOSITE_BLEND)},e.setBlendModeToMaximumIntensity=()=>{e.setBlendMode(jb.MAXIMUM_INTENSITY_BLEND)},e.setBlendModeToMinimumIntensity=()=>{e.setBlendMode(jb.MINIMUM_INTENSITY_BLEND)},e.setBlendModeToAverageIntensity=()=>{e.setBlendMode(jb.AVERAGE_INTENSITY_BLEND)},e.setBlendModeToAdditiveIntensity=()=>{e.setBlendMode(jb.ADDITIVE_INTENSITY_BLEND)},e.setBlendModeToRadonTransform=()=>{e.setBlendMode(jb.RADON_TRANSFORM_BLEND)},e.getBlendModeAsString=()=>Wt.enumToString(jb,t.blendMode),e.setVolumeShadowSamplingDistFactor=e=>n.setVolumeShadowSamplingDistFactor(e>=1?e:1),Kb.forEach((t=>{e[t]=()=>{throw new Error(`The method &quot;volumeMapper.${t}()&quot; doesn't exist anymore. It is a rendering property that has been moved to the volume property. Replace your code with:\\nvolumeActor.getProperty().${t}()\\n`)}}))}(e,t)}var Xb={newInstance:Wt.newInstance(qb,&quot;vtkVolumeMapper&quot;),extend:qb,...$b};const{InterpolationType:Yb}=Rf,{vtkErrorMacro:Zb}=Wt;function Qb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};if(Object.assign(t,(e=>({independentComponents:!1,interpolationType:Yb.LINEAR,colorWindow:255,colorLevel:127.5,ambient:1,diffuse:0,opacity:1,useLookupTableScalarRange:!1,useLabelOutline:!1,labelOutlineThickness:[1],labelOutlineOpacity:1,updatedExtents:[],...e}))(n)),Wt.obj(e,t),!t.componentData){t.componentData=[];for(let e=0;e<4;e++)t.componentData.push({rGBTransferFunction:null,piecewiseFunction:null,componentWeight:1})}Wt.setGet(e,t,[&quot;independentComponents&quot;,&quot;interpolationType&quot;,&quot;colorWindow&quot;,&quot;colorLevel&quot;,&quot;ambient&quot;,&quot;diffuse&quot;,&quot;opacity&quot;,&quot;useLookupTableScalarRange&quot;,&quot;useLabelOutline&quot;,&quot;labelOutlineOpacity&quot;,&quot;updatedExtents&quot;]),Wt.setGetArray(e,t,[&quot;labelOutlineThickness&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkImageProperty&quot;),e.getMTime=()=>{let e,n=t.mtime;for(let r=0;r<4;r++)t.componentData[r].rGBTransferFunction&&(e=t.componentData[r].rGBTransferFunction.getMTime(),n=n>e?n:e),t.componentData[r].piecewiseFunction&&(e=t.componentData[r].piecewiseFunction.getMTime(),n=n>e?n:e);return n},e.setRGBTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=n,o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;return Number.isInteger(n)||(o=n,r=0),t.componentData[r].rGBTransferFunction!==o&&(t.componentData[r].rGBTransferFunction=o,e.modified(),!0)},e.getRGBTransferFunction=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.componentData[e].rGBTransferFunction},e.setPiecewiseFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=n,o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;return Number.isInteger(n)||(o=n,r=0),t.componentData[r].piecewiseFunction!==o&&(t.componentData[r].piecewiseFunction=o,e.modified(),!0)},e.getPiecewiseFunction=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.componentData[e].piecewiseFunction},e.setScalarOpacity=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,n=t,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;return Number.isInteger(t)||(r=t,n=0),e.setPiecewiseFunction(n,r)},e.getScalarOpacity=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return e.getPiecewiseFunction(t)},e.setComponentWeight=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;if(n<0||n>=4)return Zb(&quot;Invalid index&quot;),!1;const o=Math.min(1,Math.max(0,r));return t.componentData[n].componentWeight!==o&&(t.componentData[n].componentWeight=o,e.modified(),!0)},e.getComponentWeight=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return e<0||e>=4?(Zb(&quot;Invalid index&quot;),0):t.componentData[e].componentWeight},e.setInterpolationTypeToNearest=()=>e.setInterpolationType(Yb.NEAREST),e.setInterpolationTypeToLinear=()=>e.setInterpolationType(Yb.LINEAR),e.getInterpolationTypeAsString=()=>Wt.enumToString(Yb,t.interpolationType)}(e,t)}var Jb={newInstance:Wt.newInstance(Qb,&quot;vtkImageProperty&quot;),extend:Qb};const ex={mapper:null,forceOpaque:!1,forceTranslucent:!1};function tx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ex,n),Xi.extend(e,t,n),t.boundsMTime={},Wt.obj(t.boundsMTime),Wt.setGet(e,t,[&quot;mapper&quot;,&quot;forceOpaque&quot;,&quot;forceTranslucent&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkImageSlice&quot;),e.getActors=()=>e,e.getImages=()=>e,e.getIsOpaque=()=>{if(t.forceOpaque)return!0;if(t.forceTranslucent)return!1;t.properties[0]||e.getProperty();let n=t.properties[0].getOpacity()>=1;return n=n&&(!t.mapper||t.mapper.getIsOpaque()),n},e.hasTranslucentPolygonalGeometry=()=>!1,e.makeProperty=Jb.newInstance,e.getBoundsForSlice=(n,r)=>{const o=t.mapper.getBoundsForSlice(n,r);if(!Gi.isValid(o))return o;e.computeMatrix();const a=new Float64Array(16);return h(a,t.matrix),Gi.transformBounds(o,a)},e.getMinXBound=()=>e.getBounds()[0],e.getMaxXBound=()=>e.getBounds()[1],e.getMinYBound=()=>e.getBounds()[2],e.getMaxYBound=()=>e.getBounds()[3],e.getMinZBound=()=>e.getBounds()[4],e.getMaxZBound=()=>e.getBounds()[5],e.getRedrawMTime=()=>{let e=t.mtime;if(null!==t.mapper){let n=t.mapper.getMTime();e=n>e?n:e,null!==t.mapper.getInput()&&(t.mapper.getInputAlgorithm().update(),n=t.mapper.getInput().getMTime(),e=n>e?n:e)}return t.properties.forEach((t=>{e=Math.max(e,t.getMTime());const n=t.getRGBTransferFunction();null!==n&&(e=Math.max(e,n.getMTime()))})),e},e.getSupportsSelection=()=>!!t.mapper&&t.mapper.getSupportsSelection()}(e,t)}var nx={newInstance:Wt.newInstance(tx,&quot;vtkImageSlice&quot;),extend:tx};const rx={slice:0,customDisplayExtent:[0,0,0,0,0,0],useCustomExtents:!1,backgroundColor:[0,0,0,1],colorTextureWidth:1024,opacityTextureWidth:1024,labelOutlineTextureWidth:1024};var ox=function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,rx,n),As(e,t,n),Wt.setGet(e,t,[&quot;slice&quot;,&quot;useCustomExtents&quot;,&quot;colorTextureWidth&quot;,&quot;opacityTextureWidth&quot;,&quot;labelOutlineTextureWidth&quot;]),Wt.setGetArray(e,t,[&quot;customDisplayExtent&quot;],6),Wt.setGetArray(e,t,[&quot;backgroundColor&quot;],4),function(e,t){t.classHierarchy.push(&quot;vtkAbstractImageMapper&quot;),e.getIsOpaque=()=>!0,e.getCurrentImage=()=>null,e.getBoundsForSlice=()=>(Wt.vtkErrorMacro(&quot;vtkAbstractImageMapper.getBoundsForSlice - NOT IMPLEMENTED&quot;),Pa())}(e,t)};function ax(e,t,n){const r=n.getCurrentImage(),o=r.getExtent(),a=[o[0],o[2],o[4]],{ijkMode:i}=n.getClosestIJKAxis();let s=n.isA(&quot;vtkImageArrayMapper&quot;)?n.getSubSlice():n.getSlice();i!==n.getSlicingMode()&&(s=n.getSliceAtPosition(s)),a[i]+=s;const l=[0,0,0];r.indexToWorld(a,l),a[i]+=1;const c=[0,0,0];r.indexToWorld(a,c),c[0]-=l[0],c[1]-=l[1],c[2]-=l[2],Cn(c,c);const u=ei.intersectWithLine(e,t,l,c);if(u.intersection){const e=u.x,t=[0,0,0];return r.worldToIndex(e,t),{t:u.t,absoluteIJK:t}}return null}const{staticOffsetAPI:ix,otherStaticMethods:sx}=Sl,{SlicingMode:lx}=Lf;const cx={slicingMode:lx.NONE,closestIJKAxis:{ijkMode:lx.NONE,flip:!1},renderToRectangle:!1,sliceAtFocalPoint:!1,preferSizeOverAccuracy:!1};function ux(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,cx,n),ox(e,t,n),Wt.get(e,t,[&quot;slicingMode&quot;]),Wt.setGet(e,t,[&quot;closestIJKAxis&quot;,&quot;renderToRectangle&quot;,&quot;sliceAtFocalPoint&quot;,&quot;preferSizeOverAccuracy&quot;]),Sl.implementCoincidentTopologyMethods(e,t),function(e,t){function n(){let n;switch(t.slicingMode){case lx.X:n=0;break;case lx.Y:n=1;break;case lx.Z:n=2;break;default:return void(t.closestIJKAxis={ijkMode:t.slicingMode,flip:!1})}const r=Ra(e.getCurrentImage().getDirection());let o=0;for(;o<3&&0===r[n+3*o];++o);const a=r[n+3*o]<0;t.closestIJKAxis={ijkMode:o,flip:a}}t.classHierarchy.push(&quot;vtkImageMapper&quot;),e.getSliceAtPosition=n=>{const r=e.getCurrentImage();let o;if(3===n.length)o=n;else if(Number.isFinite(n)){const e=r.getBounds();switch(t.slicingMode){case lx.X:o=[n,(e[3]+e[2])/2,(e[5]+e[4])/2];break;case lx.Y:o=[(e[1]+e[0])/2,n,(e[5]+e[4])/2];break;case lx.Z:o=[(e[1]+e[0])/2,(e[3]+e[2])/2,n]}}const a=[0,0,0];r.worldToIndex(o,a);const i=r.getExtent(),{ijkMode:s}=e.getClosestIJKAxis();let l=0;switch(s){case lx.I:l=ba(a[0],i[0],i[1]);break;case lx.J:l=ba(a[1],i[2],i[3]);break;case lx.K:l=ba(a[2],i[4],i[5]);break;default:return 0}return l},e.setSliceFromCamera=n=>{const r=n.getFocalPoint();switch(t.slicingMode){case lx.I:case lx.J:case lx.K:{const t=e.getSliceAtPosition(r);e.setSlice(t)}break;case lx.X:e.setSlice(r[0]);break;case lx.Y:e.setSlice(r[1]);break;case lx.Z:e.setSlice(r[2])}},e.setXSlice=t=>{e.setSlicingMode(lx.X),e.setSlice(t)},e.setYSlice=t=>{e.setSlicingMode(lx.Y),e.setSlice(t)},e.setZSlice=t=>{e.setSlicingMode(lx.Z),e.setSlice(t)},e.setISlice=t=>{e.setSlicingMode(lx.I),e.setSlice(t)},e.setJSlice=t=>{e.setSlicingMode(lx.J),e.setSlice(t)},e.setKSlice=t=>{e.setSlicingMode(lx.K),e.setSlice(t)},e.getSlicingModeNormal=()=>{const n=[0,0,0],r=e.getCurrentImage().getDirection();switch(t.slicingMode){case lx.X:n[0]=1;break;case lx.Y:n[1]=1;break;case lx.Z:n[2]=1;break;case lx.I:Ho(r,[1,0,0],n);break;case lx.J:Ho(r,[0,1,0],n);break;case lx.K:Ho(r,[0,0,1],n)}return n},e.setSlicingMode=r=>{t.slicingMode!==r&&(t.slicingMode=r,e.getCurrentImage()&&n(),e.modified())},e.getClosestIJKAxis=()=>(void 0!==t.closestIJKAxis&&t.closestIJKAxis.ijkMode!==lx.NONE||!e.getCurrentImage()||n(),t.closestIJKAxis),e.getBounds=()=>{const n=e.getCurrentImage();if(!n)return Pa();if(!t.useCustomExtents)return n.getBounds();const r=t.customDisplayExtent.slice(),{ijkMode:o}=e.getClosestIJKAxis();let a=t.slice;switch(o!==t.slicingMode&&(a=e.getSliceAtPosition(t.slice)),o){case lx.I:r[0]=a,r[1]=a;break;case lx.J:r[2]=a,r[3]=a;break;case lx.K:r[4]=a,r[5]=a}return n.extentToBounds(r)},e.getBoundsForSlice=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:t.slice,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;const o=e.getCurrentImage();if(!o)return Pa();const a=o.getSpatialExtent(),{ijkMode:i}=e.getClosestIJKAxis();let s=n;switch(i!==t.slicingMode&&(s=e.getSliceAtPosition(n)),i){case lx.I:a[0]=s-r,a[1]=s+r;break;case lx.J:a[2]=s-r,a[3]=s+r;break;case lx.K:a[4]=s-r,a[5]=s+r}return o.extentToBounds(a)},e.intersectWithLineForPointPicking=(t,n)=>function(e,t,n){const r=ax(e,t,n);if(r){const e=n.getCurrentImage().getExtent(),t=[Math.round(r.absoluteIJK[0]),Math.round(r.absoluteIJK[1]),Math.round(r.absoluteIJK[2])];return t[0]<e[0]||t[0]>e[1]||t[1]<e[2]||t[1]>e[3]||t[2]<e[4]||t[2]>e[5]?null:{t:r.t,ijk:t}}return null}(t,n,e),e.intersectWithLineForCellPicking=(t,n)=>function(e,t,n){const r=ax(e,t,n);if(r){const e=n.getCurrentImage().getExtent(),t=r.absoluteIJK,o=[Math.floor(t[0]),Math.floor(t[1]),Math.floor(t[2])];if(o[0]<e[0]||o[0]>e[1]-1||o[1]<e[2]||o[1]>e[3]-1||o[2]<e[4]||o[2]>(e[5]?e[5]-1:e[5]))return null;const a=[t[0]-o[0],t[1]-o[1],t[2]-o[2]];return{t:r.t,ijk:o,pCoords:a}}return null}(t,n,e),e.getCurrentImage=()=>e.getInputData()}(e,t)}var dx={newInstance:Wt.newInstance(ux,&quot;vtkImageMapper&quot;),extend:ux,...ix,...sx,...Lf};const{vtkErrorMacro:px}=Wt;function fx(e,t,n,r){e.set(function(e,t){let n=0;return e.map(((e,r)=>r===n?(n+=e+1,e):e+t))}(t,n),r)}const gx={outputPointsPrecision:Ms.DEFAULT};function mx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,gx,n),Wt.setGet(e,t,[&quot;outputPointsPrecision&quot;]),Wt.obj(e,t),Wt.algo(e,t,1,1),function(e,t){t.classHierarchy.push(&quot;vtkAppendPolyData&quot;),e.requestData=(n,r)=>{const o=e.getNumberOfInputPorts();if(!o)return void px(&quot;No input specified.&quot;);if(1===o)return void(r[0]=n[0]);const a=r[0]&&n[0]!==r[0]?r[0].initialize():gu.newInstance();let i=0,s=0,l=1,c=1,u=0,d=0,p=0,f=0,g=!0,m=!0,h=!0;for(let e=0;e<o;e++){const t=n[e];if(!t)continue;const r=t.getPoints().getNumberOfPoints();i+=r,u+=t.getVerts().getNumberOfValues(),d+=t.getLines().getNumberOfValues(),p+=t.getStrips().getNumberOfValues(),f+=t.getPolys().getNumberOfValues(),r&&(c&&(c=0,s=t.getPoints().getDataType()),l=t.getPoints().getDataType(),s=s>l?s:l);const o=t.getPointData();o?(g=g&&null!==o.getNormals(),m=m&&null!==o.getTCoords(),h=h&&null!==o.getScalars()):(g=!1,m=!1,h=!1)}t.outputPointsPrecision===Ms.SINGLE?s=cs.FLOAT:t.outputPointsPrecision===Ms.DOUBLE&&(s=cs.DOUBLE);const v=Yl.newInstance({dataType:s});v.setNumberOfPoints(i);const T=v.getData(),y=new Uint32Array(u),b=new Uint32Array(d),x=new Uint32Array(p),C=new Uint32Array(f);let S=null,A=null,I=null;const w=n[o-1];if(g){const e=w.getPointData().getNormals();S=xs.newInstance({numberOfComponents:3,numberOfTuples:i,size:3*i,dataType:e.getDataType(),name:e.getName()})}if(m){const e=w.getPointData().getTCoords();A=xs.newInstance({numberOfComponents:2,numberOfTuples:i,size:2*i,dataType:e.getDataType(),name:e.getName()})}if(h){const e=w.getPointData().getScalars();I=xs.newInstance({numberOfComponents:e.getNumberOfComponents(),numberOfTuples:i,size:i*e.getNumberOfComponents(),dataType:e.getDataType(),name:e.getName()})}i=0,u=0,d=0,p=0,f=0;for(let e=0;e<o;e++){const t=n[e];T.set(t.getPoints().getData(),3*i),fx(y,t.getVerts().getData(),i,u),u+=t.getVerts().getNumberOfValues(),fx(b,t.getLines().getData(),i,d),d+=t.getLines().getNumberOfValues(),fx(x,t.getStrips().getData(),i,p),p+=t.getStrips().getNumberOfValues(),fx(C,t.getPolys().getData(),i,f),f+=t.getPolys().getNumberOfValues();const r=t.getPointData();if(g){const e=r.getNormals();S.getData().set(e.getData(),3*i)}if(m){const e=r.getTCoords();A.getData().set(e.getData(),2*i)}if(h){const e=r.getScalars();I.getData().set(e.getData(),i*I.getNumberOfComponents())}i+=t.getPoints().getNumberOfPoints()}a.setPoints(v),a.getVerts().setData(y),a.getLines().setData(b),a.getStrips().setData(x),a.getPolys().setData(C),S&&a.getPointData().setNormals(S),A&&a.getPointData().setTCoords(A),I&&a.getPointData().setScalars(I),r[0]=a}}(e,t)}var hx={newInstance:Wt.newInstance(mx,&quot;vtkAppendPolyData&quot;),extend:mx};const vx={height:1,radius:.5,resolution:6,center:[0,0,0],direction:[1,0,0],capping:!0,pointType:&quot;Float64Array&quot;};function Tx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,vx,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;height&quot;,&quot;radius&quot;,&quot;resolution&quot;,&quot;capping&quot;]),Wt.setGetArray(e,t,[&quot;center&quot;,&quot;direction&quot;],3),Wt.algo(e,t,0,1),function(e,t){t.classHierarchy.push(&quot;vtkConeSource&quot;),e.requestData=(e,n)=>{const r=2*Math.PI/t.resolution,o=-t.height/2,a=t.resolution+1,i=4*t.resolution+1+t.resolution;let s=0;const l=Wt.newTypedArray(t.pointType,3*a);let c=0;const u=new Uint32Array(i);l[0]=t.height/2,l[1]=0,l[2]=0,t.capping&&(u[c++]=t.resolution);for(let e=0;e<t.resolution;e++)s++,l[3*s+0]=o,l[3*s+1]=t.radius*Math.cos(e*r),l[3*s+2]=t.radius*Math.sin(e*r),t.capping&&(u[t.resolution-c+++1]=s);for(let e=0;e<t.resolution;e++)u[c++]=3,u[c++]=0,u[c++]=e+1,u[c++]=e+2>t.resolution?1:e+2;df().translate(...t.center).rotateFromDirections([1,0,0],t.direction).apply(l);const d=n[0]?.initialize()||gu.newInstance();d.getPoints().setData(l,3),d.getPolys().setData(u,1),n[0]=d}}(e,t)}var yx={newInstance:Wt.newInstance(Tx,&quot;vtkConeSource&quot;),extend:Tx};const bx={height:1,initAngle:0,radius:1,resolution:6,center:[0,0,0],direction:[0,1,0],capping:!0,pointType:&quot;Float64Array&quot;};function xx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,bx,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;height&quot;,&quot;initAngle&quot;,&quot;otherRadius&quot;,&quot;radius&quot;,&quot;resolution&quot;,&quot;capping&quot;]),Wt.setGetArray(e,t,[&quot;center&quot;,&quot;direction&quot;],3),Wt.algo(e,t,0,1),function(e,t){t.classHierarchy.push(&quot;vtkCylinderSource&quot;),e.requestData=(e,n)=>{const r=2*Math.PI/t.resolution;let o=2*t.resolution,a=5*t.resolution;t.capping&&(o=4*t.resolution,a=7*t.resolution+2);const i=Wt.newTypedArray(t.pointType,3*o);let s=0;const l=new Uint32Array(a),c=new Float32Array(3*o),u=xs.newInstance({numberOfComponents:3,values:c,name:&quot;Normals&quot;}),d=new Float32Array(2*o),p=xs.newInstance({numberOfComponents:2,values:d,name:&quot;TCoords&quot;}),f=[0,0,0],g=[0,0,0],m=[0,0,0],h=[0,0,0],v=[0,0],T=[0,0],y=null==t.otherRadius?t.radius:t.otherRadius;for(let e=0;e<t.resolution;e++){f[0]=Math.cos(e*r+t.initAngle),g[0]=f[0],m[0]=t.radius*f[0]+t.center[0],h[0]=m[0],v[0]=Math.abs(2*e/t.resolution-1),T[0]=v[0],m[1]=.5*t.height+t.center[1],h[1]=-.5*t.height+t.center[1],v[1]=0,T[1]=1,f[2]=-Math.sin(e*r+t.initAngle),g[2]=f[2],m[2]=y*f[2]+t.center[2],h[2]=m[2];const n=2*e;for(let e=0;e<3;e++)c[3*n+e]=f[e],c[3*(n+1)+e]=g[e],i[3*n+e]=m[e],i[3*(n+1)+e]=h[e],e<2&&(d[2*n+e]=v[e],d[2*(n+1)+e]=T[e])}for(let e=0;e<t.resolution;e++){l[s++]=4,l[s++]=2*e,l[s++]=2*e+1;const n=(2*e+3)%(2*t.resolution);l[s++]=n,l[s++]=n-1}if(t.capping){for(let e=0;e<t.resolution;e++){m[0]=t.radius*Math.cos(e*r+t.initAngle),h[0]=m[0],v[0]=m[0],T[0]=m[0],m[0]+=t.center[0],h[0]+=t.center[0],f[1]=1,g[1]=-1,m[1]=.5*t.height+t.center[1],h[1]=-.5*t.height+t.center[1],m[2]=-y*Math.sin(e*r+t.initAngle),h[2]=m[2],v[1]=m[2],T[1]=m[2],m[2]+=t.center[2],h[2]+=t.center[2];const n=2*t.resolution+e,o=3*t.resolution+t.resolution-e-1;for(let e=0;e<3;e++)c[3*n+e]=f[e],c[3*o+e]=g[e],i[3*n+e]=m[e],i[3*o+e]=h[e],e<2&&(d[2*n+e]=v[e],d[2*o+e]=T[e])}l[s++]=t.resolution;for(let e=0;e<t.resolution;e++)l[s++]=2*t.resolution+e;l[s++]=t.resolution;for(let e=0;e<t.resolution;e++)l[s++]=3*t.resolution+e}df().translate(...t.center).rotateFromDirections([0,1,0],t.direction).translate(...t.center.map((e=>-1*e))).apply(i);const b=n[0]?.initialize()||gu.newInstance();b.getPoints().setData(i,3),b.getPolys().setData(l,1),b.getPointData().setNormals(u),b.getPointData().setTCoords(p),n[0]=b}}(e,t)}var Cx={newInstance:Wt.newInstance(xx,&quot;vtkCylinderSource&quot;),extend:xx};const Sx={tipResolution:6,tipRadius:.1,tipLength:.35,shaftResolution:6,shaftRadius:.03,invert:!1,direction:[1,0,0],pointType:&quot;Float64Array&quot;};function Ax(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Sx,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;tipResolution&quot;,&quot;tipRadius&quot;,&quot;tipLength&quot;,&quot;shaftResolution&quot;,&quot;shaftRadius&quot;,&quot;invert&quot;]),Wt.setGetArray(e,t,[&quot;direction&quot;],3),Wt.algo(e,t,0,1),function(e,t){t.classHierarchy.push(&quot;vtkArrowSource&quot;),e.requestData=(e,n)=>{const r=Cx.newInstance({capping:!0});r.setResolution(t.shaftResolution),r.setRadius(t.shaftRadius),r.setHeight(1-t.tipLength),r.setCenter(0,.5*(1-t.tipLength),0);const o=r.getOutputData(),a=o.getPoints().getData(),i=o.getPointData().getNormals().getData();uf().rotateZ(-90).apply(a).apply(i);const s=yx.newInstance();s.setResolution(t.tipResolution),s.setHeight(t.tipLength),s.setRadius(t.tipRadius);const l=s.getOutputData(),c=l.getPoints().getData();df().translate(1-.5*t.tipLength,0,0).apply(c);const u=hx.newInstance();u.setInputData(o),u.addInputData(l);const d=u.getOutputData(),p=d.getPoints().getData();df().translate(.5*t.tipLength-.5,0,0).apply(p),t.invert?(df().rotateFromDirections([1,0,0],t.direction).scale(-1,-1,-1).apply(p),n[0]=d):(df().rotateFromDirections([1,0,0],t.direction).scale(1,1,1).apply(p),n[0]=u.getOutputData())}}(e,t)}var Ix={newInstance:Wt.newInstance(Ax,&quot;vtkArrowSource&quot;),extend:Ax};function wx(e){const t=e.getPoints().getBounds(),n=[.5*-(t[0]+t[1]),.5*-(t[2]+t[3]),.5*-(t[4]+t[5])];uf().translate(...n).apply(e.getPoints().getData())}function Ox(e,t){let n=arguments.length>2&&void 0!==arguments[2]&&arguments[2];const r=e.getPoints().getBounds(),o=[0,0,0];o[t]=n?-r[2*t+1]:-r[2*t],uf().translate(...o).apply(e.getPoints().getData())}function Px(e,t,n,r){const o=e.getPoints().getData().length,a=new Uint8ClampedArray(o);let i=0;for(;i<o;)a[i++]=t,a[i++]=n,a[i++]=r;e.getPointData().setScalars(xs.newInstance({name:&quot;color&quot;,numberOfComponents:3,values:a}))}function Rx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};ss.extend(e,t,function(e){return{config:{recenter:!0,tipResolution:60,tipRadius:.1,tipLength:.2,shaftResolution:60,shaftRadius:.03,invert:!1,...e?.config},xConfig:{color:[255,0,0],invert:!1,...e?.xConfig},yConfig:{color:[255,255,0],invert:!1,...e?.yConfig},zConfig:{color:[0,128,0],invert:!1,...e?.zConfig}}}(n)),Wt.setGet(e,t,[&quot;config&quot;,&quot;xConfig&quot;,&quot;yConfig&quot;,&quot;zConfig&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkAxesActor&quot;);const n=Gl.newInstance();e.setMapper(n),e.update=()=>{let e={...t.config,...t.xConfig};const r=Ix.newInstance({direction:[1,0,0],...e}).getOutputData();t.config.recenter?wx(r):Ox(r,0,e.invert),Px(r,...e.color),e={...t.config,...t.yConfig};const o=Ix.newInstance({direction:[0,1,0],...e}).getOutputData();t.config.recenter?wx(o):Ox(o,1,e.invert),Px(o,...e.color),e={...t.config,...t.zConfig};const a=Ix.newInstance({direction:[0,0,1],...e}).getOutputData();t.config.recenter?wx(a):Ox(a,2,e.invert),Px(a,...e.color);const i=hx.newInstance();i.setInputData(r),i.addInputData(o),i.addInputData(a),n.setInputConnection(i.getOutputPort())},e.update();const r=Wt.debounce(e.update,0);e.setXAxisColor=t=>e.setXConfig({...e.getXConfig(),color:t}),e.setYAxisColor=t=>e.setYConfig({...e.getYConfig(),color:t}),e.setZAxisColor=t=>e.setZConfig({...e.getZConfig(),color:t}),e.getXAxisColor=()=>t.getXConfig().color,e.getYAxisColor=()=>t.getYConfig().color,e.getZAxisColor=()=>t.getZConfig().color,t._onConfigChanged=r,t._onXConfigChanged=r,t._onYConfigChanged=r,t._onZConfigChanged=r}(e,t)}var Mx={newInstance:Wt.newInstance(Rx,&quot;vtkAxesActor&quot;),extend:Rx};const Ex=&quot;resetcamera&quot;,Vx=&quot;orientation&quot;,Dx={MODE_RESET_CAMERA:Ex,MODE_ORIENTATION:Vx,MODE_SAME:&quot;same&quot;};const Lx={mode:Vx,focalPoint:[0,0,0],distance:6.8,active:!0};function Bx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Lx,n),ht(e,t),Ct(e,t,[&quot;mode&quot;,&quot;active&quot;,&quot;srcRenderer&quot;,&quot;dstRenderer&quot;,&quot;distance&quot;]),It(e,t,[&quot;focalPoint&quot;],3,0),function(e,t){t.classHierarchy.push(&quot;vtkCameraSynchronizer&quot;);const n=new Float64Array(9),r=new Float64Array(3),o=[];function a(){for(;o.length;)o.pop().unsubscribe();if(!t.srcRenderer||!t.dstRenderer)return;const n=t.srcRenderer.getActiveCamera(),r=t.srcRenderer.getRenderWindow().getInteractor();o.push(n.onModified((()=>{r.isAnimating()||e.update()}))),o.push(r.onAnimation(e.update)),o.push(r.onEndAnimation(e.update))}t._onSrcRendererChanged=a,t._onDstRendererChanged=a,e.update=()=>{if(!t.active||!t.srcRenderer||!t.dstRenderer)return;const e=t.srcRenderer.getActiveCamera(),o=t.dstRenderer.getActiveCamera(),a=(i=e.getReferenceByName(&quot;position&quot;),s=e.getReferenceByName(&quot;focalPoint&quot;),l=e.getReferenceByName(&quot;viewUp&quot;),(n[0]!==i[0]||n[1]!==i[1]||n[2]!==i[2]||n[3]!==s[0]||n[4]!==s[1]||n[5]!==s[2]||n[6]!==l[0]||n[7]!==l[1]||n[8]!==l[2])&&(n[0]=i[0],n[1]=i[1],n[2]=i[2],n[3]=s[0],n[4]=s[1],n[5]=s[2],n[6]=l[0],n[7]=l[1],n[8]=l[2],n));var i,s,l;a&&(t.mode===Vx?(r[0]=a[0]-a[3],r[1]=a[1]-a[4],r[2]=a[2]-a[5],Fo(r),o.setPosition(t.focalPoint[0]+t.distance*r[0],t.focalPoint[1]+t.distance*r[1],t.focalPoint[2]+t.distance*r[2]),o.setFocalPoint(t.focalPoint[0],t.focalPoint[1],t.focalPoint[2]),o.setViewUp(a[6],a[7],a[8])):(o.setPosition(a[0],a[1],a[2]),o.setFocalPoint(a[3],a[4],a[5]),o.setViewUp(a[6],a[7],a[8])),t.mode===Ex&&t.dstRenderer.resetCamera())},e.delete=Et((()=>e.setSrcRenderer(null)),e.delete),a()}(e,t)}var Nx={newInstance:Mt(Bx,&quot;vtkCameraSynchronizer&quot;),extend:Bx,SynchronizationMode:Dx};const Fx={},_x={CameraSync:class{constructor(e,t){this.ctx=e,this.behavior=Nx.newInstance(this.getProperties(t)),this.behavior.update()}getProperties(e){let{actorBounds:t,srcRenderer:n,dstRenderer:r}=e;return{distance:3.4*Math.max(t[1]-t[0],t[3]-t[2],t[5]-t[4]),focalPoint:[.5*(t[0]+t[1]),.5*(t[2]+t[3]),.5*(t[4]+t[5])],mode:Nx.SynchronizationMode.MODE_ORIENTATION,srcRenderer:this.ctx.getInstance(n),dstRenderer:this.ctx.getInstance(r)}}update(e){this.behavior.set(this.getProperties(e)),this.behavior.update()}delete(){this.behavior.delete()}}};var kx=function(e,t,n){const r=e.get(&quot;synchronizedViewId&quot;).synchronizedViewId;if(!t.behaviors||!r)return;Fx[r]||(Fx[r]={});const o=Fx[r];if(t.behaviors.autoOrientation){const t=e.getRenderers();if(!o.autoOrientationAxes&&2===t.length){let e=null,n=null;for(let r=0;r<t.length;r++){const o=t[r];o.getInteractive()?e=o:n=o}e&&n&&(o.autoOrientationAxes=Nx.newInstance({srcRenderer:e,dstRenderer:n}))}o.autoOrientationAxes&&2!==t.length&&(o.autoOrientationAxes.delete(),delete o.autoOrientationAxes)}const a=Object.keys(t.behaviors),i=Object.keys(o);for(let e=0;e<a.length;e++){const r=a[e];if(o[r])o[r].update(t.behaviors[r]);else{const e=t.behaviors[r];_x[e.type]?o[r]=new _x[e.type](n,e):console.log(&quot;No mapping for&quot;,e)}}for(let e=0;e<i.length;e++){const n=a[e];t.behaviors[n]||(o[n].delete(),delete o[n])}};const Gx={},Ux=/instance:\\${([^}]+)}/,zx={},Wx=[],Hx={},jx={vtkPoints:Yl,vtkCellArray:Kl,vtkDataArray:xs};function Kx(e){return e.map((e=>Ux.exec(e))).filter((e=>e)).map((e=>e[1]))}function $x(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return e.dependencies&&e.dependencies.forEach((e=>{t.push(e.id),$x(e,t)})),t}function qx(e,t,n,r){if(!t)return Promise.reject(new Error(&quot;No instance provided.&quot;));const o=Gx[e];return o&&o.update?o.update(t,n,r):Promise.reject(new Error(`No updater for ${e}`))}function Xx(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};const n=Gx[e];return n&&n.build?n.build(t):(console.log(&quot;No builder for&quot;,e),null)}function Yx(){Object.keys(Gx).forEach((e=>{delete Gx[e]}))}function Zx(e){if(1===e[1].length)return-1===Wx.indexOf(e[1][0]);let t=!1;for(let n=0;n<e[1].length;n++)t=t||-1===Wx.indexOf(e[1][n]);return t}function Qx(e,t,n){n.start(),e.set(t.properties),t.dependencies&&t.dependencies.forEach((e=>{const{id:t,type:r}=e;if(Hx[r]){const{key:n,value:o}=Hx[r];if(!n||e.properties[n]===o)return void Wx.push((e=>`instance:\\${${e}}`)(t))}let o=n.getInstance(t);o||(o=Xx(r,{managedInstanceId:t}),n.registerInstance(t,o)),qx(r,o,e,n)})),t.calls&&t.calls.filter(Zx).forEach((t=>{var r;e[t[0]].apply(null,(r=n,t[1].map((e=>{const t=Ux.exec(e);return t?r.getInstance(t[1]):e}))))}));const r=[];if(t.arrays){const o=[],a=Object.values(t.arrays).map((t=>(n.start(),n.getArray(t.hash,t.dataType,n).then(function(e,t,n){return r=>{const o=t.registration?t.registration:&quot;addArray&quot;,a=t.location?e.getReferenceByName(t.location):e;let i=null;if(i=t.location?e.getReferenceByName(t.location).getArray(t.name):e[`get${o.substring(3)}`](),i)return i.getData()!==r&&n.push([i.setData,[r,t.numberOfComponents]]),i;const s=t.vtkClass?t.vtkClass:&quot;vtkDataArray&quot;,l=jx[s].newInstance({...t,values:r});return n.push([a[o],[l]]),l}}(e,t,o)).catch((e=>{console.log(&quot;Error fetching array&quot;,JSON.stringify(t),e)})).finally(n.end))));n.start(),r.push(Promise.all(a).then((()=>(o.length&&e.modified(),function(e){for(;e.length;){const[t,n]=e.shift();t(...n)}}(o),!0))).catch((e=>{console.error(&quot;Error in array handling for state&quot;,JSON.stringify(t),e)})).finally(n.end))}return n.end(),Promise.all(r)}function Jx(e,t,n){zx[t.id]||Qx(e,t,n),zx[t.id]=!0}function eC(e,t){const n=[],r=e.getNumberOfArrays();for(let o=0;o<r;o++){const r=e.getArray(o).getName();t.has(r)||n.push(r)}for(let t=0;t<n.length;t++)e.removeArray(n[t])}function tC(e){const t=e.name?`_${e.name}`:&quot;&quot;;return`${e.hash}_${e.dataType}${t}`}function nC(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[];return(t,n,r)=>{r.start();const o={...n.properties};n.arrays||(n.arrays={});for(let t=0;t<e.length;t++){const r=e[t];if(n.properties[r]){const e=n.properties[r];e.registration=`set${st(r)}`;const t=tC(e);n.arrays[t]=e,delete o[r]}}const a=n.properties.fields||[];for(let e=0;e<a.length;e++){const t=a[e],r=tC(t);n.arrays[r]=t}delete o.fields;const i={pointData:new Set,cellData:new Set,fieldData:new Set};a.forEach((e=>{let{location:t,name:n}=e;i[t].add(n)})),eC(t.getPointData(),i.pointData),eC(t.getCellData(),i.cellData);const s={...n};s.properties=o;const l=Qx(t,s,r);return r.end(),l}}const rC=nC([&quot;points&quot;,&quot;polys&quot;,&quot;verts&quot;,&quot;lines&quot;,&quot;strips&quot;]),oC=nC([]);function aC(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:Qx;Xx||qx?Gx[e]={build:t,update:n}:delete Gx[e]}const iC={vtkMapper:[&quot;vtkOpenGLPolyDataMapper&quot;,&quot;vtkCompositePolyDataMapper2&quot;,&quot;vtkDataSetMapper&quot;],vtkProperty:[&quot;vtkOpenGLProperty&quot;],vtkRenderer:[&quot;vtkOpenGLRenderer&quot;],vtkCamera:[&quot;vtkOpenGLCamera&quot;],vtkColorTransferFunction:[&quot;vtkPVDiscretizableColorTransferFunction&quot;],vtkActor:[&quot;vtkOpenGLActor&quot;,&quot;vtkPVLODActor&quot;],vtkLight:[&quot;vtkOpenGLLight&quot;,&quot;vtkPVLight&quot;],vtkTexture:[&quot;vtkOpenGLTexture&quot;],vtkImageMapper:[&quot;vtkOpenGLImageSliceMapper&quot;],vtkVolumeMapper:[&quot;vtkFixedPointVolumeRayCastMapper&quot;]},sC={vtkAxesActor:{build:Mx.newInstance,update:Qx},vtkRenderWindow:{build:hh.newInstance,update:function(e,t,n){t.calls&&t.calls.filter(Zx).filter((e=>&quot;removeRenderer&quot;===e[0])).forEach((e=>{Kx(e[1]).forEach((e=>{n.getInstance(e).getViewProps().forEach((e=>{const t=e.get(&quot;flattenedDepIds&quot;).flattenedDepIds;t&&t.forEach((e=>n.unregisterInstance(e))),n.unregisterInstance(n.getInstanceId(e))}))}))})),e.render(),Qx(e,t,n),kx(e,t,n)}},vtkRenderer:{build:uh.newInstance,update:function(e,t,n){Qx(e,t,n);const r=new Set;t.dependencies&&t.dependencies.forEach((e=>{const t=n.getInstance(e.id);if(t){const n=$x(e);t.set({flattenedDepIds:n},!0),n.forEach((e=>r.add(e)))}}));const o=new Set;t.calls&&t.calls.filter(Zx).filter((e=>&quot;removeViewProp&quot;===e[0])).forEach((e=>{Kx(e[1]).forEach((e=>{const t=n.getInstance(e).get(&quot;flattenedDepIds&quot;).flattenedDepIds;t&&t.forEach((e=>o.add(e))),o.add(e)}))})),[...o].filter((e=>!r.has(e))).forEach((e=>n.unregisterInstance(e)))}},vtkLookupTable:{build:fl.newInstance,update:Qx},vtkCamera:{build:Ym.newInstance,update:Jx},vtkPolyData:{build:gu.newInstance,update:rC},vtkImageData:{build:Xs.newInstance,update:oC},vtkMapper:{build:Gl.newInstance,update:Qx},vtkGlyph3DMapper:{build:Mb.newInstance,update:Qx},vtkProperty:{build:os.newInstance,update:Qx},vtkActor:{build:ss.newInstance,update:Qx},vtkLight:{build:Jm.newInstance,update:Qx},vtkColorTransferFunction:{build:Sb.newInstance,update:function(e,t,n){if(n.start(),t.properties.nodes){const n=t.properties.nodes.map((e=>{let[t,n,r,o,a,i]=e;return{x:t,r:n,g:r,b:o,midpoint:a,sharpness:i}}));e.set({...t.properties,nodes:n},!0)}else e.set(t.properties);n.end()}},vtkTexture:{build:vu.newInstance,update:Qx},vtkVolume:{build:Hb.newInstance,update:Qx},vtkVolumeMapper:{build:Xb.newInstance,update:Qx},vtkVolumeProperty:{build:Ub.newInstance,update:Qx},vtkImageSlice:{build:nx.newInstance,update:Qx},vtkImageMapper:{build:dx.newInstance,update:Qx},vtkImageProperty:{build:Jb.newInstance,update:Qx},vtkPiecewiseFunction:{build:Lb.newInstance,update:function(e,t,n){if(n.start(),t.properties.nodes){const n=t.properties.nodes.map((e=>{let[t,n,r,o]=e;return{x:t,y:n,midpoint:r,sharpness:o}}));e.set({...t.properties,nodes:n},!0),e.sortAndUpdateRange()}else e.set(t.properties);n.end()}},vtkCubeAxesActor:{build:Lu.newInstance,update:Qx},vtkScalarBarActor:{build:dp.newInstance,update:Qx}};function lC(){(!(arguments.length>0&&void 0!==arguments[0])||arguments[0])&&Yx(),Object.keys(sC).forEach((e=>{const t=sC[e];aC(e,t.build,t.update)}))}function cC(){Object.keys(iC).forEach((e=>{iC[e].forEach((t=>{Gx[t]=Gx[e]}))}))}lC(),cC(),Hx.vtkPVLight={};var uC={build:Xx,update:qx,genericUpdater:Qx,oneTimeGenericUpdater:Jx,setTypeMapping:aC,clearTypeMapping:Yx,getSupportedTypes:function(){return Object.keys(Gx)},clearOneTimeUpdaters:function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];if(0===t.length)return void Object.keys(zx).forEach((e=>{delete zx[e]}));let r=t;return 1===r.length&&Array.isArray(r[0])&&(r=r[0]),r.forEach((e=>{delete zx[e]})),r},updateRenderWindow:function(e,t,n){return qx(&quot;vtkRenderWindow&quot;,e,t,n)},excludeInstance:function(e,t,n){Hx[e]={key:t,value:n}},setDefaultMapping:lC,applyDefaultAliases:cC,alwaysUpdateCamera:function(){aC(&quot;vtkCamera&quot;,Ym.newInstance),cC()}};const dC={};function pC(){const e={};let t=null;return{setFetchArrayFunction:function(e){t=e},getArray:function(n,r,o){const a=e[n];return a?(a.mtimes[o.getActiveViewId()]=o.getMTime(),new Promise(((e,t)=>{e(a.array)}))):t?new Promise(((a,i)=>{t(n).then((t=>{let i=t;if(&quot;string&quot;==typeof t&&(i=$g.toArrayBuffer(t)),i instanceof Blob){const t=new FileReader;t.onload=()=>{const i=at(r,t.result),s={[o.getActiveViewId()]:o.getMTime()};e[n]={mtimes:s,array:i},a(i)},t.readAsArrayBuffer(i)}else{const t=at(r,i),s={[o.getActiveViewId()]:o.getMTime()};e[n]={mtimes:s,array:t},a(t)}}),(e=>{console.log(&quot;Error getting data array:&quot;),console.log(e),i(e)}))})):Promise.reject(new Error('No array fetcher found, please use &quot;setArrayFetcher&quot; to provide one'))},emptyCachedArrays:function(){Object.keys(e).forEach((t=>{delete e[t]}))},freeOldArrays:function(t,n){const r=n.getMTime()-t;Object.keys(e).filter((t=>e[t].mtimes[n.getActiveViewId()])).filter((t=>e[t].mtimes[n.getActiveViewId()]<r)).forEach((t=>{delete e[t]}))}}}function fC(){const e={};return{getInstance:function(t){return e[t]},getInstanceId:function(t){let n=null;return Object.keys(e).forEach((r=>{t===e[r]&&(n=r)})),n},registerInstance:function(t,n){e[t]=n,n.set({remoteId:t},!0,!0)},unregisterInstance:function(t){delete e[t]},emptyCachedInstances:function(){Object.keys(e).forEach((t=>{delete e[t]}))}}}function gC(){let e=0;const t={start(){e+=1,t.invokeProgressEvent(e)},end(){e-=1,t.invokeProgressEvent(e),0===e&&t.invokeProgressDone()},resetProgress(){e=0}},n={};return Rt(t,n,&quot;progressEvent&quot;),Rt(t,n,&quot;progressDone&quot;),t}function mC(){const e={};let t=&quot;default&quot;;return{getMTime:function(n){return e[n||t]||1},incrementMTime:function(n){const r=n||t;e[r]||(e[r]=1),e[r]+=1},setActiveViewId:function(e){t=e},getActiveViewId:function(){return t}}}function hC(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;default&quot;,t=dC[e];return t||(t={...pC(),...fC(),...gC(),...mC()},dC[e]=t),t}function vC(e,t){let n=-1,r=100;const o=e=>e.get(&quot;managedInstanceId&quot;).managedInstanceId,a=()=>Dt(e,o);function i(t){e.set({synchronizedViewId:t},!0,!0)}function s(){return e.get(&quot;synchronizedViewId&quot;).synchronizedViewId}return{synchronize:function(o){s()||i(o.id);const a=o.mtime||0;return s()===o.id&&n<a?new Promise(((i,s)=>{const l=t.onProgressDone((()=>{l.unsubscribe(),e.render(),i(!0)}));n=a,t.setActiveViewId(o.id),t.incrementMTime(),uC.updateRenderWindow(e,o,t),t.freeOldArrays(r,t)})):Promise.resolve(!1)},setSynchronizedViewId:i,getSynchronizedViewId:s,updateGarbageCollectorThreshold:function(e){r=e},getManagedInstanceIds:a,clearOneTimeUpdaters:function(){uC.clearOneTimeUpdaters(a())}}}const TC={synchronizerContextName:&quot;default&quot;,synchronizerContext:null,synchronizedViewId:null};function yC(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,TC,n),hh.extend(e,t),Tt(e,t,[&quot;synchronizerContext&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkSynchronizableRenderWindow&quot;),t.synchronizerContext||(t.synchronizerContext=hC(t.synchronizerContextName));const n=vC(e,t.synchronizerContext);Object.keys(n).forEach((t=>{e[t]?e[t]=Et(e[t],n[t]):e[t]=n[t]}))}(e,t)}var bC={newInstance:Mt(yC,&quot;vtkSynchronizableRenderWindow&quot;),extend:yC,getSynchronizerContext:hC,setSynchronizerContext:function(e,t){dC[e]=t},clearSynchronizerContext:function(e){if(e&&dC[e]&&delete dC[e],!e){const e=Object.keys(dC);for(let t=0;t<e.length;t++)delete dC[e[t]]}},decorate:function(e){const t=vC(e,hC(arguments.length>1&&void 0!==arguments[1]?arguments[1]:&quot;default&quot;));return{...t,...e,delete:Et(e.delete,t.delete)}},createInstanceMap:fC,createArrayHandler:pC,createProgressHandler:gC,createSceneMtimeHandler:mC,vtkObjectManager:uC};const{vtkErrorMacro:xC,vtkDebugMacro:CC}=Wt;let SC=0;function AC(e){const t=document.querySelector(`.webResource[data-url=&quot;${e}&quot;]`);return t?t.innerHTML:null}function IC(e){return&quot;/&quot;===e[0]?e.substr(1):e}const wC={fetchJSON:function(e,t){return new Promise(((e,n)=>{const r=AC(IC(t));null===r?n(new Error(`No such JSON ${t}`)):e(JSON.parse(r))}))},fetchText:function(e,t){return new Promise(((e,n)=>{const r=AC(t);null===r?n(new Error(`No such text ${t}`)):e(r)}))},fetchArray:function(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return new Promise(((o,a)=>{const i=IC([t,n.ref.basepath,r.compression?`${n.ref.id}.gz`:n.ref.id].join(&quot;/&quot;)),s=AC(i);if(null===s)a(new Error(`No such array ${i}`));else{if(&quot;string&quot;===n.dataType){let e=atob(s);r.compression&&(e=Lm(Em(e))),n.values=JSON.parse(e)}else{const e=new Uint8Array($g.toArrayBuffer(s));n.buffer=new ArrayBuffer(e.length),new Uint8Array(n.buffer).set(e),r.compression&&(&quot;string&quot;===n.dataType||&quot;JSON&quot;===n.dataType?n.buffer=Lm(Em(new Uint8Array(n.buffer))):n.buffer=Em(new Uint8Array(n.buffer)).buffer),&quot;JSON&quot;===n.ref.encode?n.values=JSON.parse(n.buffer):(Gm!==n.ref.encode&&Gm&&(CC(`Swap bytes of ${n.name}`),Um(n.buffer,ls[n.dataType])),n.values=Wt.newTypedArray(n.dataType,n.buffer)),n.values.length!==n.size&&xC(`Error in FetchArray: ${n.name} does not have the proper array size. Got ${n.values.length}, instead of ${n.size}`)}delete n.ref,0==--SC&&e?.invokeBusy&&e.invokeBusy(!1),e?.modified&&e.modified(),o(n)}}))},fetchImage:function(e,t){return new Promise(((e,n)=>{const r=function(e){return document.querySelector(`.webResource[data-url=&quot;${e}&quot;]`)}(t);r?e(r):n(new Error(`No such image ${t}`))}))}};Xg(&quot;html&quot;,(e=>wC));const{vtkErrorMacro:OC,vtkDebugMacro:PC}=Wt;function RC(e){return function(e){return&quot;/&quot;===e[0]?e.substr(1):e}(function(e){return new URL(e,&quot;http://any&quot;).pathname}(e))}const MC=function(e){let t=!1,n=0,r=null,o=&quot;&quot;;var a;return(a=e.zipContent,new Promise(((e,t)=>{&quot;string&quot;==typeof a?e(function(e,t){if(t){for(var n=new Zg(e.length),r=0;r<e.length;++r)n[r]=e.charCodeAt(r);return n}if(Vm)return Vm.encode(e);var o=e.length,a=new Zg(e.length+(e.length>>1)),i=0,s=function(e){a[i++]=e};for(r=0;r<o;++r){if(i+5>a.length){var l=new Zg(i+8+(o-r<<1));l.set(a),a=l}var c=e.charCodeAt(r);c<128||t?s(c):c<2048?(s(192|c>>6),s(128|63&c)):c>55295&&c<57344?(s(240|(c=65536+(1047552&c)|1023&e.charCodeAt(++r))>>18),s(128|c>>12&63),s(128|c>>6&63),s(128|63&c)):(s(224|c>>12),s(128|c>>6&63),s(128|63&c))}return bm(a,0,i)}(a)):a instanceof Blob?e(a.arrayBuffer().then((e=>new Uint8Array(e)))):a instanceof ArrayBuffer?e(new Uint8Array(a)):a?.buffer instanceof ArrayBuffer?e(new Uint8Array(a.buffer)):t(new Error(&quot;Invalid datatype to unpack.&quot;))}))).then((n=>{r=_m(n),t=!0;const a=[];Object.keys(r).forEach((e=>{e.endsWith(&quot;index.json&quot;)&&a.push(e)})),a.sort(((e,t)=>e.length-t.length)),o=a[0].replace(/index\\.json$/,&quot;&quot;),e.callback&&e.callback(r)})),{fetchArray(e,a,i){let s=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return new Promise(((l,c)=>{t||OC(&quot;ERROR!!! zip not ready...&quot;);const u=RC([a,i.ref.basepath,s.compression?`${i.ref.id}.gz`:i.ref.id].join(&quot;/&quot;));function d(){delete i.ref,0==--n&&e?.invokeBusy&&e.invokeBusy(!1),e?.modified&&e.modified(),l(i)}1==++n&&e?.invokeBusy&&e.invokeBusy(!0);const p=r[`${o}${u}`];if(&quot;string&quot;!==i.dataType||s.compression){const e=function(e,t,n){return r=>{e.buffer=new ArrayBuffer(r.length),new Uint8Array(e.buffer).set(r),t&&(&quot;string&quot;===e.dataType||&quot;JSON&quot;===e.dataType?e.buffer=Lm(Em(new Uint8Array(e.buffer))):e.buffer=Em(new Uint8Array(e.buffer)).buffer),&quot;JSON&quot;===e.ref.encode?e.values=JSON.parse(e.buffer):(Gm!==e.ref.encode&&Gm&&(PC(`Swap bytes of ${e.name}`),Um(e.buffer,ls[e.dataType])),e.values=Wt.newTypedArray(e.dataType,e.buffer)),e.values.length!==e.size&&OC(`Error in FetchArray: ${e.name} does not have the proper array size. Got ${e.values.length}, instead of ${e.size}`),n()}}(i,s.compression,d);e(p)}else{const e=function(e,t,n){return r=>{e.values=t?JSON.parse(Lm(Em(r))):JSON.parse(r),n()}}(i,s.compression,d);e(Lm(p))}}))},fetchJSON(e,n){let a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};const i=RC(n);t||OC(&quot;ERROR!!! zip not ready...&quot;);const s=r[`${o}${i}`];if(a.compression){if(&quot;gz&quot;===a.compression){const e=Lm(Em(s));return Promise.resolve(JSON.parse(e))}return Promise.reject(new Error(&quot;Invalid compression&quot;))}return Promise.resolve(JSON.parse(Lm(s)))},fetchText(e,n){let a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};const i=RC(n);t||OC(&quot;ERROR!!! zip not ready...&quot;);const s=r[`${o}${i}`];return a.compression?&quot;gz&quot;===a.compression?Promise.resolve(Lm(_m(s))):Promise.reject(new Error(&quot;Invalid compression&quot;)):Promise.resolve(Lm(s))},fetchImage(e,n){const a=RC(n);t||OC(&quot;ERROR!!! zip not ready...&quot;);const i=r[`${o}${a}`];return new Promise(((e,t)=>{const n=new Image;n.onload=()=>e(n),n.onerror=t;const r=Kg(i.buffer);n.src=`data:image/${function(e){const t=e.split(&quot;.&quot;).pop().toLowerCase();return&quot;jpg&quot;===t?&quot;jpeg&quot;:t}(a)};base64,${r}`}))},fetchBinary(e,n){let a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};const i=RC(n);t||OC(&quot;ERROR!!! zip not ready...&quot;);const s=r[`${o}${i}`];return a.compression?&quot;gz&quot;===a.compression?Promise.resolve(Em(s).buffer):Promise.reject(new Error(&quot;Invalid compression&quot;)):Promise.resolve(s.buffer)}}};Xg(&quot;zip&quot;,(e=>MC(e)));var EC=n(911),VC=n.n(EC),DC=n(893),LC=n.n(DC),BC=n(383),NC=n.n(BC),FC=n(884),_C=n.n(FC),kC=n(88),GC=n.n(kC),UC=n(997),zC=n.n(UC),WC=n(96),HC={};HC.styleTagTransform=zC(),HC.setAttributes=_C(),HC.insert=NC().bind(null,&quot;head&quot;),HC.domAPI=LC(),HC.insertStyleElement=GC(),VC()(WC.A,HC);var jC=WC.A&&WC.A.locals?WC.A.locals:void 0;let KC=!0;function $C(e){e.preventDefault(),e.stopPropagation()}function qC(e,t){KC=!1,function(e){for(;e.firstChild;)e.removeChild(e.firstChild)}(e);const r=ub.newInstance({background:[1,1,1],rootContainer:e,containerStyle:{height:&quot;100%&quot;,width:&quot;100%&quot;,position:&quot;absolute&quot;}}).getRenderWindow(),o=bC.getSynchronizerContext(),a=bC.decorate(r);function i(e){o.setFetchArrayFunction((t=>Promise.resolve(e.hashes[t].content))),console.log(Object.keys(e)),a.synchronize(e.scene),a.render()}if(n.g.renderWindow=r,t.fileURL||t.url){const n=document.createElement(&quot;div&quot;);n.setAttribute(&quot;class&quot;,jC.progress),e.appendChild(n);const r=e=>{if(e.lengthComputable){const t=Math.floor(100*e.loaded/e.total);n.innerHTML=`Loading ${t}%`}else n.innerHTML=Wt.formatBytesToProperUnit(e.loaded)};t.fileURL?Km.fetchBinary(t.fileURL,{progressCallback:r}).then((t=>{e.removeChild(n);const r=Yg.get(&quot;zip&quot;,{zipContent:t,callback:e=>{r.fetchJSON(null,&quot;index.json&quot;).then(i)}})})):Km.fetchJSON(t.url,{progressCallback:r}).then((t=>{e.removeChild(n),i(t)}))}else if(t.file){const e=Yg.get(&quot;zip&quot;,{zipContent:t.file,callback:t=>{e.fetchJSON(null,&quot;index.json&quot;).then(i)}})}else if(t.base64Str){const e=$g.toArrayBuffer(t.base64Str),n=Yg.get(&quot;zip&quot;,{zipContent:e,callback:e=>{n.fetchJSON(null,&quot;index.json&quot;).then(i)}})}}function XC(e){KC=!1;const t=document.querySelector(&quot;.content&quot;),n=document.querySelector(&quot;body&quot;),r=e||t||n;r!==e?(r.classList.add(jC.fullScreen),n.style.margin=&quot;0&quot;,n.style.padding=&quot;0&quot;):(n.style.margin=&quot;0&quot;,n.style.padding=&quot;0&quot;);const o=document.createElement(&quot;div&quot;);o.innerHTML=`<div class=&quot;${jC.bigFileDrop}&quot;/><input type=&quot;file&quot; accept=&quot;.zip,.vtksz&quot; style=&quot;display: none;&quot;/>`,r.appendChild(o);const a=o.querySelector(&quot;input&quot;);function i(e){$C(e);const t=e.dataTransfer,n=e.target.files||t.files;if(1===n.length){r.removeChild(o);const e=n[0].name.split(&quot;.&quot;).slice(-1)[0];qC(r,{file:n[0],ext:e})}}a.addEventListener(&quot;change&quot;,i),o.addEventListener(&quot;drop&quot;,i),o.addEventListener(&quot;click&quot;,(e=>a.click())),o.addEventListener(&quot;dragover&quot;,$C)}const YC=Zh();if(YC.url||YC.fileURL){const e=document.querySelector(&quot;.content&quot;),t=document.querySelector(&quot;body&quot;),n=e||t;n&&(n.classList.add(jC.fullScreen),t.style.margin=&quot;0&quot;,t.style.padding=&quot;0&quot;),KC=!1,function(e){if(!window.frameElement)return e(),!0;window.frameElement.getClientRects().length>0?e():function(e,t){new window.parent.IntersectionObserver(((e,n)=>{e.forEach((e=>{e.intersectionRatio>0&&(t(),n.disconnect())}))})).observe(e)}(window.frameElement,e)}((()=>qC(n,YC)))}setTimeout((()=>{KC&&XC()}),100),window.OfflineLocalView={initLocalFileLoader:XC,load:qC}},613:function(e){&quot;use strict&quot;;e.exports=function(e){var t=[];return t.toString=function(){return this.map((function(t){var n=&quot;&quot;,r=void 0!==t[5];return t[4]&&(n+=&quot;@supports (&quot;.concat(t[4],&quot;) {&quot;)),t[2]&&(n+=&quot;@media &quot;.concat(t[2],&quot; {&quot;)),r&&(n+=&quot;@layer&quot;.concat(t[5].length>0?&quot; &quot;.concat(t[5]):&quot;&quot;,&quot; {&quot;)),n+=e(t),r&&(n+=&quot;}&quot;),t[2]&&(n+=&quot;}&quot;),t[4]&&(n+=&quot;}&quot;),n})).join(&quot;&quot;)},t.i=function(e,n,r,o,a){&quot;string&quot;==typeof e&&(e=[[null,e,void 0]]);var i={};if(r)for(var s=0;s<this.length;s++){var l=this[s][0];null!=l&&(i[l]=!0)}for(var c=0;c<e.length;c++){var u=[].concat(e[c]);r&&i[u[0]]||(void 0!==a&&(void 0===u[5]||(u[1]=&quot;@layer&quot;.concat(u[5].length>0?&quot; &quot;.concat(u[5]):&quot;&quot;,&quot; {&quot;).concat(u[1],&quot;}&quot;)),u[5]=a),n&&(u[2]?(u[1]=&quot;@media &quot;.concat(u[2],&quot; {&quot;).concat(u[1],&quot;}&quot;),u[2]=n):u[2]=n),o&&(u[4]?(u[1]=&quot;@supports (&quot;.concat(u[4],&quot;) {&quot;).concat(u[1],&quot;}&quot;),u[4]=o):u[4]=&quot;&quot;.concat(o)),t.push(u))}},t}},336:function(e){&quot;use strict&quot;;e.exports=function(e,t){return t||(t={}),e?(e=String(e.__esModule?e.default:e),/^['&quot;].*['&quot;]$/.test(e)&&(e=e.slice(1,-1)),t.hash&&(e+=t.hash),/[&quot;'() \\t\\n]|(%20)/.test(e)||t.needQuotes?'&quot;'.concat(e.replace(/&quot;/g,'\\\\&quot;').replace(/\\n/g,&quot;\\\\n&quot;),'&quot;'):e):e}},20:function(e){&quot;use strict&quot;;e.exports=function(e){return e[1]}},555:function(e,t,n){&quot;use strict&quot;;var r=n(382),o=&quot;function&quot;==typeof Symbol&&&quot;symbol&quot;==typeof Symbol(&quot;foo&quot;),a=Object.prototype.toString,i=Array.prototype.concat,s=Object.defineProperty,l=s&&function(){var e={};try{for(var t in s(e,&quot;x&quot;,{enumerable:!1,value:e}),e)return!1;return e.x===e}catch(e){return!1}}(),c=function(e,t,n,r){var o;(!(t in e)||&quot;function&quot;==typeof(o=r)&&&quot;[object Function]&quot;===a.call(o)&&r())&&(l?s(e,t,{configurable:!0,enumerable:!1,value:n,writable:!0}):e[t]=n)},u=function(e,t){var n=arguments.length>2?arguments[2]:{},a=r(t);o&&(a=i.call(a,Object.getOwnPropertySymbols(t)));for(var s=0;s<a.length;s+=1)c(e,a[s],t[a[s]],n[a[s]])};u.supportsDescriptors=!!l,e.exports=u},77:function(e,t,n){&quot;use strict&quot;;e.exports=function(){if(&quot;object&quot;==typeof globalThis)return globalThis;var e;try{e=this||new Function(&quot;return this&quot;)()}catch(e){if(&quot;object&quot;==typeof window)return window;if(&quot;object&quot;==typeof self)return self;if(void 0!==n.g)return n.g}return e}()},730:function(e){&quot;use strict&quot;;e.exports=function e(t,n){if(t===n)return!0;if(t&&n&&&quot;object&quot;==typeof t&&&quot;object&quot;==typeof n){if(t.constructor!==n.constructor)return!1;var r,o,a;if(Array.isArray(t)){if((r=t.length)!=n.length)return!1;for(o=r;0!=o--;)if(!e(t[o],n[o]))return!1;return!0}if(t.constructor===RegExp)return t.source===n.source&&t.flags===n.flags;if(t.valueOf!==Object.prototype.valueOf)return t.valueOf()===n.valueOf();if(t.toString!==Object.prototype.toString)return t.toString()===n.toString();if((r=(a=Object.keys(t)).length)!==Object.keys(n).length)return!1;for(o=r;0!=o--;)if(!Object.prototype.hasOwnProperty.call(n,a[o]))return!1;for(o=r;0!=o--;){var i=a[o];if(!e(t[i],n[i]))return!1}return!0}return t!=t&&n!=n}},979:function(e){&quot;use strict&quot;;&quot;undefined&quot;!=typeof self?e.exports=self:&quot;undefined&quot;!=typeof window?e.exports=window:e.exports=Function(&quot;return this&quot;)()},59:function(e,t,n){&quot;use strict&quot;;var r=n(555),o=n(979),a=n(920),i=n(482),s=a(),l=function(){return s};r(l,{getPolyfill:a,implementation:o,shim:i}),e.exports=l},920:function(e,t,n){&quot;use strict&quot;;var r=n(979);e.exports=function(){return&quot;object&quot;==typeof n.g&&n.g&&n.g.Math===Math&&n.g.Array===Array?n.g:r}},482:function(e,t,n){&quot;use strict&quot;;var r=n(555),o=n(920);e.exports=function(){var e=o();if(r.supportsDescriptors){var t=Object.getOwnPropertyDescriptor(e,&quot;globalThis&quot;);t&&(!t.configurable||!t.enumerable&&t.writable&&globalThis===e)||Object.defineProperty(e,&quot;globalThis&quot;,{configurable:!0,enumerable:!1,value:e,writable:!0})}else&quot;object&quot;==typeof globalThis&&globalThis===e||(e.globalThis=e);return e}},982:function(e,t,n){&quot;use strict&quot;;var r;if(!Object.keys){var o=Object.prototype.hasOwnProperty,a=Object.prototype.toString,i=n(642),s=Object.prototype.propertyIsEnumerable,l=!s.call({toString:null},&quot;toString&quot;),c=s.call((function(){}),&quot;prototype&quot;),u=[&quot;toString&quot;,&quot;toLocaleString&quot;,&quot;valueOf&quot;,&quot;hasOwnProperty&quot;,&quot;isPrototypeOf&quot;,&quot;propertyIsEnumerable&quot;,&quot;constructor&quot;],d=function(e){var t=e.constructor;return t&&t.prototype===e},p={$applicationCache:!0,$console:!0,$external:!0,$frame:!0,$frameElement:!0,$frames:!0,$innerHeight:!0,$innerWidth:!0,$onmozfullscreenchange:!0,$onmozfullscreenerror:!0,$outerHeight:!0,$outerWidth:!0,$pageXOffset:!0,$pageYOffset:!0,$parent:!0,$scrollLeft:!0,$scrollTop:!0,$scrollX:!0,$scrollY:!0,$self:!0,$webkitIndexedDB:!0,$webkitStorageInfo:!0,$window:!0},f=function(){if(&quot;undefined&quot;==typeof window)return!1;for(var e in window)try{if(!p[&quot;$&quot;+e]&&o.call(window,e)&&null!==window[e]&&&quot;object&quot;==typeof window[e])try{d(window[e])}catch(e){return!0}}catch(e){return!0}return!1}();r=function(e){var t=null!==e&&&quot;object&quot;==typeof e,n=&quot;[object Function]&quot;===a.call(e),r=i(e),s=t&&&quot;[object String]&quot;===a.call(e),p=[];if(!t&&!n&&!r)throw new TypeError(&quot;Object.keys called on a non-object&quot;);var g=c&&n;if(s&&e.length>0&&!o.call(e,0))for(var m=0;m<e.length;++m)p.push(String(m));if(r&&e.length>0)for(var h=0;h<e.length;++h)p.push(String(h));else for(var v in e)g&&&quot;prototype&quot;===v||!o.call(e,v)||p.push(String(v));if(l)for(var T=function(e){if(&quot;undefined&quot;==typeof window||!f)return d(e);try{return d(e)}catch(e){return!1}}(e),y=0;y<u.length;++y)T&&&quot;constructor&quot;===u[y]||!o.call(e,u[y])||p.push(u[y]);return p}}e.exports=r},382:function(e,t,n){&quot;use strict&quot;;var r=Array.prototype.slice,o=n(642),a=Object.keys,i=a?function(e){return a(e)}:n(982),s=Object.keys;i.shim=function(){if(Object.keys){var e=function(){var e=Object.keys(arguments);return e&&e.length===arguments.length}(1,2);e||(Object.keys=function(e){return o(e)?s(r.call(e)):s(e)})}else Object.keys=i;return Object.keys||i},e.exports=i},642:function(e){&quot;use strict&quot;;var t=Object.prototype.toString;e.exports=function(e){var n=t.call(e),r=&quot;[object Arguments]&quot;===n;return r||(r=&quot;[object Array]&quot;!==n&&null!==e&&&quot;object&quot;==typeof e&&&quot;number&quot;==typeof e.length&&e.length>=0&&&quot;[object Function]&quot;===t.call(e.callee)),r}},318:function(e,t,n){var r=n(767),o=n(698),a=n(744),i=n(402),s=n(576),l=n(886),c=n(262);c.alea=r,c.xor128=o,c.xorwow=a,c.xorshift7=i,c.xor4096=s,c.tychei=l,e.exports=c},767:function(e,t,n){var r;!function(e,o){function a(e){var t,n=this,r=(t=4022871197,function(e){e=String(e);for(var n=0;n<e.length;n++){var r=.02519603282416938*(t+=e.charCodeAt(n));r-=t=r>>>0,t=(r*=t)>>>0,t+=4294967296*(r-=t)}return 2.3283064365386963e-10*(t>>>0)});n.next=function(){var e=2091639*n.s0+2.3283064365386963e-10*n.c;return n.s0=n.s1,n.s1=n.s2,n.s2=e-(n.c=0|e)},n.c=1,n.s0=r(&quot; &quot;),n.s1=r(&quot; &quot;),n.s2=r(&quot; &quot;),n.s0-=r(e),n.s0<0&&(n.s0+=1),n.s1-=r(e),n.s1<0&&(n.s1+=1),n.s2-=r(e),n.s2<0&&(n.s2+=1),r=null}function i(e,t){return t.c=e.c,t.s0=e.s0,t.s1=e.s1,t.s2=e.s2,t}function s(e,t){var n=new a(e),r=t&&t.state,o=n.next;return o.int32=function(){return 4294967296*n.next()|0},o.double=function(){return o()+11102230246251565e-32*(2097152*o()|0)},o.quick=o,r&&(&quot;object&quot;==typeof r&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.alea=s}(0,e=n.nmd(e),n.amdD)},886:function(e,t,n){var r;!function(e,o){function a(e){var t=this,n=&quot;&quot;;t.next=function(){var e=t.b,n=t.c,r=t.d,o=t.a;return e=e<<25^e>>>7^n,n=n-r|0,r=r<<24^r>>>8^o,o=o-e|0,t.b=e=e<<20^e>>>12^n,t.c=n=n-r|0,t.d=r<<16^n>>>16^o,t.a=o-e|0},t.a=0,t.b=0,t.c=-1640531527,t.d=1367130551,e===Math.floor(e)?(t.a=e/4294967296|0,t.b=0|e):n+=e;for(var r=0;r<n.length+20;r++)t.b^=0|n.charCodeAt(r),t.next()}function i(e,t){return t.a=e.a,t.b=e.b,t.c=e.c,t.d=e.d,t}function s(e,t){var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(&quot;object&quot;==typeof r&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.tychei=s}(0,e=n.nmd(e),n.amdD)},698:function(e,t,n){var r;!function(e,o){function a(e){var t=this,n=&quot;&quot;;t.x=0,t.y=0,t.z=0,t.w=0,t.next=function(){var e=t.x^t.x<<11;return t.x=t.y,t.y=t.z,t.z=t.w,t.w^=t.w>>>19^e^e>>>8},e===(0|e)?t.x=e:n+=e;for(var r=0;r<n.length+64;r++)t.x^=0|n.charCodeAt(r),t.next()}function i(e,t){return t.x=e.x,t.y=e.y,t.z=e.z,t.w=e.w,t}function s(e,t){var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(&quot;object&quot;==typeof r&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.xor128=s}(0,e=n.nmd(e),n.amdD)},576:function(e,t,n){var r;!function(e,o){function a(e){var t=this;t.next=function(){var e,n,r=t.w,o=t.X,a=t.i;return t.w=r=r+1640531527|0,n=o[a+34&127],e=o[a=a+1&127],n^=n<<13,e^=e<<17,n^=n>>>15,e^=e>>>12,n=o[a]=n^e,t.i=a,n+(r^r>>>16)|0},function(e,t){var n,r,o,a,i,s=[],l=128;for(t===(0|t)?(r=t,t=null):(t+=&quot;\\0&quot;,r=0,l=Math.max(l,t.length)),o=0,a=-32;a<l;++a)t&&(r^=t.charCodeAt((a+32)%t.length)),0===a&&(i=r),r^=r<<10,r^=r>>>15,r^=r<<4,r^=r>>>13,a>=0&&(i=i+1640531527|0,o=0==(n=s[127&a]^=r+i)?o+1:0);for(o>=128&&(s[127&(t&&t.length||0)]=-1),o=127,a=512;a>0;--a)r=s[o+34&127],n=s[o=o+1&127],r^=r<<13,n^=n<<17,r^=r>>>15,n^=n>>>12,s[o]=r^n;e.w=i,e.X=s,e.i=o}(t,e)}function i(e,t){return t.i=e.i,t.w=e.w,t.X=e.X.slice(),t}function s(e,t){null==e&&(e=+new Date);var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(r.X&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.xor4096=s}(0,e=n.nmd(e),n.amdD)},402:function(e,t,n){var r;!function(e,o){function a(e){var t=this;t.next=function(){var e,n,r=t.x,o=t.i;return e=r[o],n=(e^=e>>>7)^e<<24,n^=(e=r[o+1&7])^e>>>10,n^=(e=r[o+3&7])^e>>>3,n^=(e=r[o+4&7])^e<<7,e=r[o+7&7],n^=(e^=e<<13)^e<<9,r[o]=n,t.i=o+1&7,n},function(e,t){var n,r=[];if(t===(0|t))r[0]=t;else for(t=&quot;&quot;+t,n=0;n<t.length;++n)r[7&n]=r[7&n]<<15^t.charCodeAt(n)+r[n+1&7]<<13;for(;r.length<8;)r.push(0);for(n=0;n<8&&0===r[n];++n);for(8==n?r[7]=-1:r[n],e.x=r,e.i=0,n=256;n>0;--n)e.next()}(t,e)}function i(e,t){return t.x=e.x.slice(),t.i=e.i,t}function s(e,t){null==e&&(e=+new Date);var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(r.x&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.xorshift7=s}(0,e=n.nmd(e),n.amdD)},744:function(e,t,n){var r;!function(e,o){function a(e){var t=this,n=&quot;&quot;;t.next=function(){var e=t.x^t.x>>>2;return t.x=t.y,t.y=t.z,t.z=t.w,t.w=t.v,(t.d=t.d+362437|0)+(t.v=t.v^t.v<<4^e^e<<1)|0},t.x=0,t.y=0,t.z=0,t.w=0,t.v=0,e===(0|e)?t.x=e:n+=e;for(var r=0;r<n.length+64;r++)t.x^=0|n.charCodeAt(r),r==n.length&&(t.d=t.x<<10^t.x>>>4),t.next()}function i(e,t){return t.x=e.x,t.y=e.y,t.z=e.z,t.w=e.w,t.v=e.v,t.d=e.d,t}function s(e,t){var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(&quot;object&quot;==typeof r&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.xorwow=s}(0,e=n.nmd(e),n.amdD)},262:function(e,t,n){var r;!function(o,a,i){var s,l=256,c=i.pow(l,6),u=i.pow(2,52),d=2*u,p=255;function f(e,t,n){var r=[],p=v(h((t=1==t?{entropy:!0}:t||{}).entropy?[e,T(a)]:null==e?function(){try{var e;return s&&(e=s.randomBytes)?e=e(l):(e=new Uint8Array(l),(o.crypto||o.msCrypto).getRandomValues(e)),T(e)}catch(e){var t=o.navigator,n=t&&t.plugins;return[+new Date,o,n,o.screen,T(a)]}}():e,3),r),f=new g(r),y=function(){for(var e=f.g(6),t=c,n=0;e<u;)e=(e+n)*l,t*=l,n=f.g(1);for(;e>=d;)e/=2,t/=2,n>>>=1;return(e+n)/t};return y.int32=function(){return 0|f.g(4)},y.quick=function(){return f.g(4)/4294967296},y.double=y,v(T(f.S),a),(t.pass||n||function(e,t,n,r){return r&&(r.S&&m(r,f),e.state=function(){return m(f,{})}),n?(i.random=e,t):e})(y,p,&quot;global&quot;in t?t.global:this==i,t.state)}function g(e){var t,n=e.length,r=this,o=0,a=r.i=r.j=0,i=r.S=[];for(n||(e=[n++]);o<l;)i[o]=o++;for(o=0;o<l;o++)i[o]=i[a=p&a+e[o%n]+(t=i[o])],i[a]=t;(r.g=function(e){for(var t,n=0,o=r.i,a=r.j,i=r.S;e--;)t=i[o=p&o+1],n=n*l+i[p&(i[o]=i[a=p&a+t])+(i[a]=t)];return r.i=o,r.j=a,n})(l)}function m(e,t){return t.i=e.i,t.j=e.j,t.S=e.S.slice(),t}function h(e,t){var n,r=[],o=typeof e;if(t&&&quot;object&quot;==o)for(n in e)try{r.push(h(e[n],t-1))}catch(e){}return r.length?r:&quot;string&quot;==o?e:e+&quot;\\0&quot;}function v(e,t){for(var n,r=e+&quot;&quot;,o=0;o<r.length;)t[p&o]=p&(n^=19*t[p&o])+r.charCodeAt(o++);return T(t)}function T(e){return String.fromCharCode.apply(0,e)}if(v(i.random(),a),e.exports){e.exports=f;try{s=n(1)}catch(e){}}else void 0===(r=function(){return f}.call(t,n,t,e))||(e.exports=r)}(&quot;undefined&quot;!=typeof self?self:this,[],Math)},292:function(e){e.exports=function(){&quot;use strict&quot;;var e=[&quot;0&quot;,&quot;1&quot;,&quot;2&quot;,&quot;3&quot;,&quot;4&quot;,&quot;5&quot;,&quot;6&quot;,&quot;7&quot;,&quot;8&quot;,&quot;9&quot;,&quot;a&quot;,&quot;b&quot;,&quot;c&quot;,&quot;d&quot;,&quot;e&quot;,&quot;f&quot;];function t(e,t){var n=e[0],r=e[1],o=e[2],a=e[3];r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&o|~r&a)+t[0]-680876936|0)<<7|n>>>25)+r|0)&r|~n&o)+t[1]-389564586|0)<<12|a>>>20)+n|0)&n|~a&r)+t[2]+606105819|0)<<17|o>>>15)+a|0)&a|~o&n)+t[3]-1044525330|0)<<22|r>>>10)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&o|~r&a)+t[4]-176418897|0)<<7|n>>>25)+r|0)&r|~n&o)+t[5]+1200080426|0)<<12|a>>>20)+n|0)&n|~a&r)+t[6]-1473231341|0)<<17|o>>>15)+a|0)&a|~o&n)+t[7]-45705983|0)<<22|r>>>10)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&o|~r&a)+t[8]+1770035416|0)<<7|n>>>25)+r|0)&r|~n&o)+t[9]-1958414417|0)<<12|a>>>20)+n|0)&n|~a&r)+t[10]-42063|0)<<17|o>>>15)+a|0)&a|~o&n)+t[11]-1990404162|0)<<22|r>>>10)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&o|~r&a)+t[12]+1804603682|0)<<7|n>>>25)+r|0)&r|~n&o)+t[13]-40341101|0)<<12|a>>>20)+n|0)&n|~a&r)+t[14]-1502002290|0)<<17|o>>>15)+a|0)&a|~o&n)+t[15]+1236535329|0)<<22|r>>>10)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&a|o&~a)+t[1]-165796510|0)<<5|n>>>27)+r|0)&o|r&~o)+t[6]-1069501632|0)<<9|a>>>23)+n|0)&r|n&~r)+t[11]+643717713|0)<<14|o>>>18)+a|0)&n|a&~n)+t[0]-373897302|0)<<20|r>>>12)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&a|o&~a)+t[5]-701558691|0)<<5|n>>>27)+r|0)&o|r&~o)+t[10]+38016083|0)<<9|a>>>23)+n|0)&r|n&~r)+t[15]-660478335|0)<<14|o>>>18)+a|0)&n|a&~n)+t[4]-405537848|0)<<20|r>>>12)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&a|o&~a)+t[9]+568446438|0)<<5|n>>>27)+r|0)&o|r&~o)+t[14]-1019803690|0)<<9|a>>>23)+n|0)&r|n&~r)+t[3]-187363961|0)<<14|o>>>18)+a|0)&n|a&~n)+t[8]+1163531501|0)<<20|r>>>12)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&a|o&~a)+t[13]-1444681467|0)<<5|n>>>27)+r|0)&o|r&~o)+t[2]-51403784|0)<<9|a>>>23)+n|0)&r|n&~r)+t[7]+1735328473|0)<<14|o>>>18)+a|0)&n|a&~n)+t[12]-1926607734|0)<<20|r>>>12)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r^o^a)+t[5]-378558|0)<<4|n>>>28)+r|0)^r^o)+t[8]-2022574463|0)<<11|a>>>21)+n|0)^n^r)+t[11]+1839030562|0)<<16|o>>>16)+a|0)^a^n)+t[14]-35309556|0)<<23|r>>>9)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r^o^a)+t[1]-1530992060|0)<<4|n>>>28)+r|0)^r^o)+t[4]+1272893353|0)<<11|a>>>21)+n|0)^n^r)+t[7]-155497632|0)<<16|o>>>16)+a|0)^a^n)+t[10]-1094730640|0)<<23|r>>>9)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r^o^a)+t[13]+681279174|0)<<4|n>>>28)+r|0)^r^o)+t[0]-358537222|0)<<11|a>>>21)+n|0)^n^r)+t[3]-722521979|0)<<16|o>>>16)+a|0)^a^n)+t[6]+76029189|0)<<23|r>>>9)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r^o^a)+t[9]-640364487|0)<<4|n>>>28)+r|0)^r^o)+t[12]-421815835|0)<<11|a>>>21)+n|0)^n^r)+t[15]+530742520|0)<<16|o>>>16)+a|0)^a^n)+t[2]-995338651|0)<<23|r>>>9)+o|0,r=((r+=((a=((a+=(r^((n=((n+=(o^(r|~a))+t[0]-198630844|0)<<6|n>>>26)+r|0)|~o))+t[7]+1126891415|0)<<10|a>>>22)+n|0)^((o=((o+=(n^(a|~r))+t[14]-1416354905|0)<<15|o>>>17)+a|0)|~n))+t[5]-57434055|0)<<21|r>>>11)+o|0,r=((r+=((a=((a+=(r^((n=((n+=(o^(r|~a))+t[12]+1700485571|0)<<6|n>>>26)+r|0)|~o))+t[3]-1894986606|0)<<10|a>>>22)+n|0)^((o=((o+=(n^(a|~r))+t[10]-1051523|0)<<15|o>>>17)+a|0)|~n))+t[1]-2054922799|0)<<21|r>>>11)+o|0,r=((r+=((a=((a+=(r^((n=((n+=(o^(r|~a))+t[8]+1873313359|0)<<6|n>>>26)+r|0)|~o))+t[15]-30611744|0)<<10|a>>>22)+n|0)^((o=((o+=(n^(a|~r))+t[6]-1560198380|0)<<15|o>>>17)+a|0)|~n))+t[13]+1309151649|0)<<21|r>>>11)+o|0,r=((r+=((a=((a+=(r^((n=((n+=(o^(r|~a))+t[4]-145523070|0)<<6|n>>>26)+r|0)|~o))+t[11]-1120210379|0)<<10|a>>>22)+n|0)^((o=((o+=(n^(a|~r))+t[2]+718787259|0)<<15|o>>>17)+a|0)|~n))+t[9]-343485551|0)<<21|r>>>11)+o|0,e[0]=n+e[0]|0,e[1]=r+e[1]|0,e[2]=o+e[2]|0,e[3]=a+e[3]|0}function n(e){var t,n=[];for(t=0;t<64;t+=4)n[t>>2]=e.charCodeAt(t)+(e.charCodeAt(t+1)<<8)+(e.charCodeAt(t+2)<<16)+(e.charCodeAt(t+3)<<24);return n}function r(e){var t,n=[];for(t=0;t<64;t+=4)n[t>>2]=e[t]+(e[t+1]<<8)+(e[t+2]<<16)+(e[t+3]<<24);return n}function o(e){var r,o,a,i,s,l,c=e.length,u=[1732584193,-271733879,-1732584194,271733878];for(r=64;r<=c;r+=64)t(u,n(e.substring(r-64,r)));for(o=(e=e.substring(r-64)).length,a=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],r=0;r<o;r+=1)a[r>>2]|=e.charCodeAt(r)<<(r%4<<3);if(a[r>>2]|=128<<(r%4<<3),r>55)for(t(u,a),r=0;r<16;r+=1)a[r]=0;return i=(i=8*c).toString(16).match(/(.*?)(.{0,8})$/),s=parseInt(i[2],16),l=parseInt(i[1],16)||0,a[14]=s,a[15]=l,t(u,a),u}function a(t){var n,r=&quot;&quot;;for(n=0;n<4;n+=1)r+=e[t>>8*n+4&15]+e[t>>8*n&15];return r}function i(e){var t;for(t=0;t<e.length;t+=1)e[t]=a(e[t]);return e.join(&quot;&quot;)}function s(e){return/[\\u0080-\\uFFFF]/.test(e)&&(e=unescape(encodeURIComponent(e))),e}function l(e){var t,n=[],r=e.length;for(t=0;t<r-1;t+=2)n.push(parseInt(e.substr(t,2),16));return String.fromCharCode.apply(String,n)}function c(){this.reset()}return i(o(&quot;hello&quot;)),&quot;undefined&quot;==typeof ArrayBuffer||ArrayBuffer.prototype.slice||function(){function e(e,t){return(e=0|e||0)<0?Math.max(e+t,0):Math.min(e,t)}ArrayBuffer.prototype.slice=function(t,n){var r,o,a,i,s=this.byteLength,l=e(t,s),c=s;return undefined!==n&&(c=e(n,s)),l>c?new ArrayBuffer(0):(r=c-l,o=new ArrayBuffer(r),a=new Uint8Array(o),i=new Uint8Array(this,l,r),a.set(i),o)}}(),c.prototype.append=function(e){return this.appendBinary(s(e)),this},c.prototype.appendBinary=function(e){this._buff+=e,this._length+=e.length;var r,o=this._buff.length;for(r=64;r<=o;r+=64)t(this._hash,n(this._buff.substring(r-64,r)));return this._buff=this._buff.substring(r-64),this},c.prototype.end=function(e){var t,n,r=this._buff,o=r.length,a=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;t<o;t+=1)a[t>>2]|=r.charCodeAt(t)<<(t%4<<3);return this._finish(a,o),n=i(this._hash),e&&(n=l(n)),this.reset(),n},c.prototype.reset=function(){return this._buff=&quot;&quot;,this._length=0,this._hash=[1732584193,-271733879,-1732584194,271733878],this},c.prototype.getState=function(){return{buff:this._buff,length:this._length,hash:this._hash.slice()}},c.prototype.setState=function(e){return this._buff=e.buff,this._length=e.length,this._hash=e.hash,this},c.prototype.destroy=function(){delete this._hash,delete this._buff,delete this._length},c.prototype._finish=function(e,n){var r,o,a,i=n;if(e[i>>2]|=128<<(i%4<<3),i>55)for(t(this._hash,e),i=0;i<16;i+=1)e[i]=0;r=(r=8*this._length).toString(16).match(/(.*?)(.{0,8})$/),o=parseInt(r[2],16),a=parseInt(r[1],16)||0,e[14]=o,e[15]=a,t(this._hash,e)},c.hash=function(e,t){return c.hashBinary(s(e),t)},c.hashBinary=function(e,t){var n=i(o(e));return t?l(n):n},c.ArrayBuffer=function(){this.reset()},c.ArrayBuffer.prototype.append=function(e){var n,o,a,i,s,l=(o=this._buff.buffer,a=e,i=!0,(s=new Uint8Array(o.byteLength+a.byteLength)).set(new Uint8Array(o)),s.set(new Uint8Array(a),o.byteLength),i?s:s.buffer),c=l.length;for(this._length+=e.byteLength,n=64;n<=c;n+=64)t(this._hash,r(l.subarray(n-64,n)));return this._buff=n-64<c?new Uint8Array(l.buffer.slice(n-64)):new Uint8Array(0),this},c.ArrayBuffer.prototype.end=function(e){var t,n,r=this._buff,o=r.length,a=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;t<o;t+=1)a[t>>2]|=r[t]<<(t%4<<3);return this._finish(a,o),n=i(this._hash),e&&(n=l(n)),this.reset(),n},c.ArrayBuffer.prototype.reset=function(){return this._buff=new Uint8Array(0),this._length=0,this._hash=[1732584193,-271733879,-1732584194,271733878],this},c.ArrayBuffer.prototype.getState=function(){var e,t=c.prototype.getState.call(this);return t.buff=(e=t.buff,String.fromCharCode.apply(null,new Uint8Array(e))),t},c.ArrayBuffer.prototype.setState=function(e){return e.buff=function(e,t){var n,r=e.length,o=new ArrayBuffer(r),a=new Uint8Array(o);for(n=0;n<r;n+=1)a[n]=e.charCodeAt(n);return t?a:o}(e.buff,!0),c.prototype.setState.call(this,e)},c.ArrayBuffer.prototype.destroy=c.prototype.destroy,c.ArrayBuffer.prototype._finish=c.prototype._finish,c.ArrayBuffer.hash=function(e,n){var o=i(function(e){var n,o,a,i,s,l,c=e.length,u=[1732584193,-271733879,-1732584194,271733878];for(n=64;n<=c;n+=64)t(u,r(e.subarray(n-64,n)));for(o=(e=n-64<c?e.subarray(n-64):new Uint8Array(0)).length,a=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],n=0;n<o;n+=1)a[n>>2]|=e[n]<<(n%4<<3);if(a[n>>2]|=128<<(n%4<<3),n>55)for(t(u,a),n=0;n<16;n+=1)a[n]=0;return i=(i=8*c).toString(16).match(/(.*?)(.{0,8})$/),s=parseInt(i[2],16),l=parseInt(i[1],16)||0,a[14]=s,a[15]=l,t(u,a),u}(new Uint8Array(e)));return n?l(o):o},c}()},96:function(e,t,n){&quot;use strict&quot;;var r=n(20),o=n.n(r),a=n(613),i=n.n(a),s=n(336),l=n.n(s),c=new URL(n(183),n.b),u=i()(o()),d=l()(c);u.push([e.id,&quot;.viewer-module-fullScreen_bbk9Y {\\n  position: absolute;\\n  width: 100vw;\\n  height: 100vh;\\n  top: 0;\\n  left: 0;\\n  overflow: hidden;\\n  background: black;\\n  margin: 0;\\n  padding: 0;\\n  z-index: -1;\\n  display: flex;\\n  align-items: center;\\n  justify-content: center;\\n}\\n\\n.viewer-module-fullParentSize_ETopO {\\n  position: absolute;\\n  width: 100%;\\n  height: 100%;\\n  top: 0;\\n  left: 0;\\n  overflow: hidden;\\n}\\n\\n.viewer-module-bigFileDrop_aqCgh {\\n  position: absolute;\\n  left: 50%;\\n  top: 50%;\\n  transform: translate(-50%, -50%);\\n  background-color: white;\\n  background-image: url(&quot;+d+&quot;);\\n  background-repeat: no-repeat;\\n  background-position: center;\\n  background-size: contain;\\n  border-radius: 10px;\\n  width: 50px;\\n  padding: calc(50vh - 2em) calc(50vw - 25px - 2em);\\n  cursor: pointer;\\n}\\n\\n.viewer-module-progress_cYjQJ {\\n  flex: none;\\n  font-size: 50px;\\n  color: black;\\n  z-index: 1;\\n  background: rgba(128,128,128,.5);\\n  padding: 20px;\\n  border-radius: 10px;\\n  -webkit-user-select: none;\\n     -moz-user-select: none;\\n          user-select: none;\\n}\\n\\nbody {\\n  margin: 0;\\n}\\n\\nhtml { \\n  overflow: hidden; \\n}\\n&quot;,&quot;&quot;]),u.locals={fullScreen:&quot;viewer-module-fullScreen_bbk9Y&quot;,fullParentSize:&quot;viewer-module-fullParentSize_ETopO&quot;,bigFileDrop:&quot;viewer-module-bigFileDrop_aqCgh&quot;,progress:&quot;viewer-module-progress_cYjQJ&quot;},t.A=u},50:function(e,t,n){var r=n(853),o=n(77);void 0===o.OfflineLocalView&&(o.OfflineLocalView=r),e.exports=r},911:function(e){&quot;use strict&quot;;var t=[];function n(e){for(var n=-1,r=0;r<t.length;r++)if(t[r].identifier===e){n=r;break}return n}function r(e,r){for(var a={},i=[],s=0;s<e.length;s++){var l=e[s],c=r.base?l[0]+r.base:l[0],u=a[c]||0,d=&quot;&quot;.concat(c,&quot; &quot;).concat(u);a[c]=u+1;var p=n(d),f={css:l[1],media:l[2],sourceMap:l[3],supports:l[4],layer:l[5]};if(-1!==p)t[p].references++,t[p].updater(f);else{var g=o(f,r);r.byIndex=s,t.splice(s,0,{identifier:d,updater:g,references:1})}i.push(d)}return i}function o(e,t){var n=t.domAPI(t);return n.update(e),function(t){if(t){if(t.css===e.css&&t.media===e.media&&t.sourceMap===e.sourceMap&&t.supports===e.supports&&t.layer===e.layer)return;n.update(e=t)}else n.remove()}}e.exports=function(e,o){var a=r(e=e||[],o=o||{});return function(e){e=e||[];for(var i=0;i<a.length;i++){var s=n(a[i]);t[s].references--}for(var l=r(e,o),c=0;c<a.length;c++){var u=n(a[c]);0===t[u].references&&(t[u].updater(),t.splice(u,1))}a=l}}},383:function(e){&quot;use strict&quot;;var t={};e.exports=function(e,n){var r=function(e){if(void 0===t[e]){var n=document.querySelector(e);if(window.HTMLIFrameElement&&n instanceof window.HTMLIFrameElement)try{n=n.contentDocument.head}catch(e){n=null}t[e]=n}return t[e]}(e);if(!r)throw new Error(&quot;Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.&quot;);r.appendChild(n)}},88:function(e){&quot;use strict&quot;;e.exports=function(e){var t=document.createElement(&quot;style&quot;);return e.setAttributes(t,e.attributes),e.insert(t,e.options),t}},884:function(e,t,n){&quot;use strict&quot;;e.exports=function(e){var t=n.nc;t&&e.setAttribute(&quot;nonce&quot;,t)}},893:function(e){&quot;use strict&quot;;e.exports=function(e){var t=e.insertStyleElement(e);return{update:function(n){!function(e,t,n){var r=&quot;&quot;;n.supports&&(r+=&quot;@supports (&quot;.concat(n.supports,&quot;) {&quot;)),n.media&&(r+=&quot;@media &quot;.concat(n.media,&quot; {&quot;));var o=void 0!==n.layer;o&&(r+=&quot;@layer&quot;.concat(n.layer.length>0?&quot; &quot;.concat(n.layer):&quot;&quot;,&quot; {&quot;)),r+=n.css,o&&(r+=&quot;}&quot;),n.media&&(r+=&quot;}&quot;),n.supports&&(r+=&quot;}&quot;);var a=n.sourceMap;a&&&quot;undefined&quot;!=typeof btoa&&(r+=&quot;\\n/*# sourceMappingURL=data:application/json;base64,&quot;.concat(btoa(unescape(encodeURIComponent(JSON.stringify(a)))),&quot; */&quot;)),t.styleTagTransform(r,e,t.options)}(t,e,n)},remove:function(){!function(e){if(null===e.parentNode)return!1;e.parentNode.removeChild(e)}(t)}}}},997:function(e){&quot;use strict&quot;;e.exports=function(e,t){if(t.styleSheet)t.styleSheet.cssText=e;else{for(;t.firstChild;)t.removeChild(t.firstChild);t.appendChild(document.createTextNode(e))}}},183:function(e,t,n){&quot;use strict&quot;;e.exports=n.p+&quot;138e7b1469f64156810a.jpg&quot;},1:function(){}},t={};function n(r){var o=t[r];if(void 0!==o)return o.exports;var a=t[r]={id:r,loaded:!1,exports:{}};return e[r].call(a.exports,a,a.exports,n),a.loaded=!0,a.exports}n.m=e,n.amdD=function(){throw new Error(&quot;define cannot be used indirect&quot;)},n.amdO={},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,{a:t}),t},n.d=function(e,t){for(var r in t)n.o(t,r)&&!n.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},n.g=function(){if(&quot;object&quot;==typeof globalThis)return globalThis;try{return this||new Function(&quot;return this&quot;)()}catch(e){if(&quot;object&quot;==typeof window)return window}}(),n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.r=function(e){&quot;undefined&quot;!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:&quot;Module&quot;}),Object.defineProperty(e,&quot;__esModule&quot;,{value:!0})},n.nmd=function(e){return e.paths=[],e.children||(e.children=[]),e},n.p=&quot;&quot;,n.b=document.baseURI||self.location.href,n.nc=void 0,n(50)}();\n</script>\n<script>\nvar container = document.querySelector('.content');\nvar base64Str = &quot;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&quot;;\n\nOfflineLocalView.load(container, { base64Str });\n</script>\n</body>\n</html>\n\" class=\"pyvista\" style=\"width: 100%; height: 600px; border: 1px solid rgb(221,221,221);\"></iframe>"
      }
     },
     "20bcdd4391324d5b814031dd59233ae8": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "2.0.0",
       "_model_name": "HTMLStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "2.0.0",
       "_view_name": "StyleView",
       "background": null,
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "219ac35db39d48b699b11a71d6d7b816": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "2.0.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "2.0.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border_bottom": null,
       "border_left": null,
       "border_right": null,
       "border_top": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "39cd983a750e44c881a21e512b4a58d5": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "2.0.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "2.0.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border_bottom": null,
       "border_left": null,
       "border_right": null,
       "border_top": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "6883ca1f8e9f416f87a1be5681f0567b": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "2.0.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "2.0.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border_bottom": null,
       "border_left": null,
       "border_right": null,
       "border_top": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "6f3df1bd38f8416caf528a66f463c59f": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "2.0.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "2.0.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_allow_html": false,
       "layout": "IPY_MODEL_6883ca1f8e9f416f87a1be5681f0567b",
       "placeholder": "​",
       "style": "IPY_MODEL_75fb90cdf0f34089b1f9c554e66a84d4",
       "tabbable": null,
       "tooltip": null,
       "value": "<iframe srcdoc=\"<!DOCTYPE html>\n<html>\n  <head>\n    <meta http-equiv=&quot;Content-type&quot; content=&quot;text/html; charset=utf-8&quot;/>\n    <meta name=&quot;viewport&quot; content=&quot;width=device-width, height=device-height, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no&quot;>\n  </head>\n  <body>\n    <div class=&quot;content&quot;></div>\n<script type=&quot;text/javascript&quot;>\n!function(){var e={853:function(e,t,n){&quot;use strict&quot;;n.r(t),n.d(t,{initLocalFileLoader:function(){return XC},load:function(){return qC}});var r={};n.r(r),n.d(r,{add:function(){return J},adjoint:function(){return T},clone:function(){return d},copy:function(){return p},create:function(){return u},determinant:function(){return y},equals:function(){return oe},exactEquals:function(){return re},frob:function(){return Q},fromQuat:function(){return G},fromQuat2:function(){return L},fromRotation:function(){return R},fromRotationTranslation:function(){return D},fromRotationTranslationScale:function(){return _},fromRotationTranslationScaleOrigin:function(){return k},fromScaling:function(){return P},fromTranslation:function(){return O},fromValues:function(){return f},fromXRotation:function(){return M},fromYRotation:function(){return E},fromZRotation:function(){return V},frustum:function(){return U},getRotation:function(){return F},getScaling:function(){return N},getTranslation:function(){return B},identity:function(){return m},invert:function(){return v},lookAt:function(){return X},mul:function(){return ae},multiply:function(){return b},multiplyScalar:function(){return te},multiplyScalarAndAdd:function(){return ne},ortho:function(){return $},orthoNO:function(){return K},orthoZO:function(){return q},perspective:function(){return W},perspectiveFromFieldOfView:function(){return j},perspectiveNO:function(){return z},perspectiveZO:function(){return H},rotate:function(){return S},rotateX:function(){return A},rotateY:function(){return I},rotateZ:function(){return w},scale:function(){return C},set:function(){return g},str:function(){return Z},sub:function(){return ie},subtract:function(){return ee},targetTo:function(){return Y},translate:function(){return x},transpose:function(){return h}});var o={};n.r(o),n.d(o,{add:function(){return Ee},adjoint:function(){return he},clone:function(){return ce},copy:function(){return ue},create:function(){return se},determinant:function(){return ve},equals:function(){return Ne},exactEquals:function(){return Be},frob:function(){return Me},fromMat2d:function(){return Ie},fromMat4:function(){return le},fromQuat:function(){return we},fromRotation:function(){return Se},fromScaling:function(){return Ae},fromTranslation:function(){return Ce},fromValues:function(){return de},identity:function(){return fe},invert:function(){return me},mul:function(){return Fe},multiply:function(){return Te},multiplyScalar:function(){return De},multiplyScalarAndAdd:function(){return Le},normalFromMat4:function(){return Oe},projection:function(){return Pe},rotate:function(){return be},scale:function(){return xe},set:function(){return pe},str:function(){return Re},sub:function(){return _e},subtract:function(){return Ve},translate:function(){return ye},transpose:function(){return ge}});const a=document.querySelector(&quot;head&quot;);a&&[16,32,96,160,196].forEach((e=>{const t=document.createElement(&quot;link&quot;);t.setAttribute(&quot;rel&quot;,&quot;icon&quot;),t.setAttribute(&quot;href&quot;,`https://kitware.github.io/vtk-js/icon/favicon-${e}x${e}.png`),t.setAttribute(&quot;sizes&quot;,`${e}x${e}`),t.setAttribute(&quot;type&quot;,&quot;image/png&quot;),a.appendChild(t)}));var i=1e-6,s=&quot;undefined&quot;!=typeof Float32Array?Float32Array:Array;Math.random;var l=Math.PI/180;function c(e){return e*l}function u(){var e=new s(16);return s!=Float32Array&&(e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0),e[0]=1,e[5]=1,e[10]=1,e[15]=1,e}function d(e){var t=new s(16);return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t[4]=e[4],t[5]=e[5],t[6]=e[6],t[7]=e[7],t[8]=e[8],t[9]=e[9],t[10]=e[10],t[11]=e[11],t[12]=e[12],t[13]=e[13],t[14]=e[14],t[15]=e[15],t}function p(e,t){return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[4]=t[4],e[5]=t[5],e[6]=t[6],e[7]=t[7],e[8]=t[8],e[9]=t[9],e[10]=t[10],e[11]=t[11],e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15],e}function f(e,t,n,r,o,a,i,l,c,u,d,p,f,g,m,h){var v=new s(16);return v[0]=e,v[1]=t,v[2]=n,v[3]=r,v[4]=o,v[5]=a,v[6]=i,v[7]=l,v[8]=c,v[9]=u,v[10]=d,v[11]=p,v[12]=f,v[13]=g,v[14]=m,v[15]=h,v}function g(e,t,n,r,o,a,i,s,l,c,u,d,p,f,g,m,h){return e[0]=t,e[1]=n,e[2]=r,e[3]=o,e[4]=a,e[5]=i,e[6]=s,e[7]=l,e[8]=c,e[9]=u,e[10]=d,e[11]=p,e[12]=f,e[13]=g,e[14]=m,e[15]=h,e}function m(e){return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=1,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=1,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function h(e,t){if(e===t){var n=t[1],r=t[2],o=t[3],a=t[6],i=t[7],s=t[11];e[1]=t[4],e[2]=t[8],e[3]=t[12],e[4]=n,e[6]=t[9],e[7]=t[13],e[8]=r,e[9]=a,e[11]=t[14],e[12]=o,e[13]=i,e[14]=s}else e[0]=t[0],e[1]=t[4],e[2]=t[8],e[3]=t[12],e[4]=t[1],e[5]=t[5],e[6]=t[9],e[7]=t[13],e[8]=t[2],e[9]=t[6],e[10]=t[10],e[11]=t[14],e[12]=t[3],e[13]=t[7],e[14]=t[11],e[15]=t[15];return e}function v(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8],d=t[9],p=t[10],f=t[11],g=t[12],m=t[13],h=t[14],v=t[15],T=n*s-r*i,y=n*l-o*i,b=n*c-a*i,x=r*l-o*s,C=r*c-a*s,S=o*c-a*l,A=u*m-d*g,I=u*h-p*g,w=u*v-f*g,O=d*h-p*m,P=d*v-f*m,R=p*v-f*h,M=T*R-y*P+b*O+x*w-C*I+S*A;return M?(M=1/M,e[0]=(s*R-l*P+c*O)*M,e[1]=(o*P-r*R-a*O)*M,e[2]=(m*S-h*C+v*x)*M,e[3]=(p*C-d*S-f*x)*M,e[4]=(l*w-i*R-c*I)*M,e[5]=(n*R-o*w+a*I)*M,e[6]=(h*b-g*S-v*y)*M,e[7]=(u*S-p*b+f*y)*M,e[8]=(i*P-s*w+c*A)*M,e[9]=(r*w-n*P-a*A)*M,e[10]=(g*C-m*b+v*T)*M,e[11]=(d*b-u*C-f*T)*M,e[12]=(s*I-i*O-l*A)*M,e[13]=(n*O-r*I+o*A)*M,e[14]=(m*y-g*x-h*T)*M,e[15]=(u*x-d*y+p*T)*M,e):null}function T(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8],d=t[9],p=t[10],f=t[11],g=t[12],m=t[13],h=t[14],v=t[15];return e[0]=s*(p*v-f*h)-d*(l*v-c*h)+m*(l*f-c*p),e[1]=-(r*(p*v-f*h)-d*(o*v-a*h)+m*(o*f-a*p)),e[2]=r*(l*v-c*h)-s*(o*v-a*h)+m*(o*c-a*l),e[3]=-(r*(l*f-c*p)-s*(o*f-a*p)+d*(o*c-a*l)),e[4]=-(i*(p*v-f*h)-u*(l*v-c*h)+g*(l*f-c*p)),e[5]=n*(p*v-f*h)-u*(o*v-a*h)+g*(o*f-a*p),e[6]=-(n*(l*v-c*h)-i*(o*v-a*h)+g*(o*c-a*l)),e[7]=n*(l*f-c*p)-i*(o*f-a*p)+u*(o*c-a*l),e[8]=i*(d*v-f*m)-u*(s*v-c*m)+g*(s*f-c*d),e[9]=-(n*(d*v-f*m)-u*(r*v-a*m)+g*(r*f-a*d)),e[10]=n*(s*v-c*m)-i*(r*v-a*m)+g*(r*c-a*s),e[11]=-(n*(s*f-c*d)-i*(r*f-a*d)+u*(r*c-a*s)),e[12]=-(i*(d*h-p*m)-u*(s*h-l*m)+g*(s*p-l*d)),e[13]=n*(d*h-p*m)-u*(r*h-o*m)+g*(r*p-o*d),e[14]=-(n*(s*h-l*m)-i*(r*h-o*m)+g*(r*l-o*s)),e[15]=n*(s*p-l*d)-i*(r*p-o*d)+u*(r*l-o*s),e}function y(e){var t=e[0],n=e[1],r=e[2],o=e[3],a=e[4],i=e[5],s=e[6],l=e[7],c=e[8],u=e[9],d=e[10],p=e[11],f=e[12],g=e[13],m=e[14],h=e[15];return(t*i-n*a)*(d*h-p*m)-(t*s-r*a)*(u*h-p*g)+(t*l-o*a)*(u*m-d*g)+(n*s-r*i)*(c*h-p*f)-(n*l-o*i)*(c*m-d*f)+(r*l-o*s)*(c*g-u*f)}function b(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=t[9],f=t[10],g=t[11],m=t[12],h=t[13],v=t[14],T=t[15],y=n[0],b=n[1],x=n[2],C=n[3];return e[0]=y*r+b*s+x*d+C*m,e[1]=y*o+b*l+x*p+C*h,e[2]=y*a+b*c+x*f+C*v,e[3]=y*i+b*u+x*g+C*T,y=n[4],b=n[5],x=n[6],C=n[7],e[4]=y*r+b*s+x*d+C*m,e[5]=y*o+b*l+x*p+C*h,e[6]=y*a+b*c+x*f+C*v,e[7]=y*i+b*u+x*g+C*T,y=n[8],b=n[9],x=n[10],C=n[11],e[8]=y*r+b*s+x*d+C*m,e[9]=y*o+b*l+x*p+C*h,e[10]=y*a+b*c+x*f+C*v,e[11]=y*i+b*u+x*g+C*T,y=n[12],b=n[13],x=n[14],C=n[15],e[12]=y*r+b*s+x*d+C*m,e[13]=y*o+b*l+x*p+C*h,e[14]=y*a+b*c+x*f+C*v,e[15]=y*i+b*u+x*g+C*T,e}function x(e,t,n){var r,o,a,i,s,l,c,u,d,p,f,g,m=n[0],h=n[1],v=n[2];return t===e?(e[12]=t[0]*m+t[4]*h+t[8]*v+t[12],e[13]=t[1]*m+t[5]*h+t[9]*v+t[13],e[14]=t[2]*m+t[6]*h+t[10]*v+t[14],e[15]=t[3]*m+t[7]*h+t[11]*v+t[15]):(r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=t[9],f=t[10],g=t[11],e[0]=r,e[1]=o,e[2]=a,e[3]=i,e[4]=s,e[5]=l,e[6]=c,e[7]=u,e[8]=d,e[9]=p,e[10]=f,e[11]=g,e[12]=r*m+s*h+d*v+t[12],e[13]=o*m+l*h+p*v+t[13],e[14]=a*m+c*h+f*v+t[14],e[15]=i*m+u*h+g*v+t[15]),e}function C(e,t,n){var r=n[0],o=n[1],a=n[2];return e[0]=t[0]*r,e[1]=t[1]*r,e[2]=t[2]*r,e[3]=t[3]*r,e[4]=t[4]*o,e[5]=t[5]*o,e[6]=t[6]*o,e[7]=t[7]*o,e[8]=t[8]*a,e[9]=t[9]*a,e[10]=t[10]*a,e[11]=t[11]*a,e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15],e}function S(e,t,n,r){var o,a,s,l,c,u,d,p,f,g,m,h,v,T,y,b,x,C,S,A,I,w,O,P,R=r[0],M=r[1],E=r[2],V=Math.hypot(R,M,E);return V<i?null:(R*=V=1/V,M*=V,E*=V,o=Math.sin(n),s=1-(a=Math.cos(n)),l=t[0],c=t[1],u=t[2],d=t[3],p=t[4],f=t[5],g=t[6],m=t[7],h=t[8],v=t[9],T=t[10],y=t[11],b=R*R*s+a,x=M*R*s+E*o,C=E*R*s-M*o,S=R*M*s-E*o,A=M*M*s+a,I=E*M*s+R*o,w=R*E*s+M*o,O=M*E*s-R*o,P=E*E*s+a,e[0]=l*b+p*x+h*C,e[1]=c*b+f*x+v*C,e[2]=u*b+g*x+T*C,e[3]=d*b+m*x+y*C,e[4]=l*S+p*A+h*I,e[5]=c*S+f*A+v*I,e[6]=u*S+g*A+T*I,e[7]=d*S+m*A+y*I,e[8]=l*w+p*O+h*P,e[9]=c*w+f*O+v*P,e[10]=u*w+g*O+T*P,e[11]=d*w+m*O+y*P,t!==e&&(e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15]),e)}function A(e,t,n){var r=Math.sin(n),o=Math.cos(n),a=t[4],i=t[5],s=t[6],l=t[7],c=t[8],u=t[9],d=t[10],p=t[11];return t!==e&&(e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15]),e[4]=a*o+c*r,e[5]=i*o+u*r,e[6]=s*o+d*r,e[7]=l*o+p*r,e[8]=c*o-a*r,e[9]=u*o-i*r,e[10]=d*o-s*r,e[11]=p*o-l*r,e}function I(e,t,n){var r=Math.sin(n),o=Math.cos(n),a=t[0],i=t[1],s=t[2],l=t[3],c=t[8],u=t[9],d=t[10],p=t[11];return t!==e&&(e[4]=t[4],e[5]=t[5],e[6]=t[6],e[7]=t[7],e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15]),e[0]=a*o-c*r,e[1]=i*o-u*r,e[2]=s*o-d*r,e[3]=l*o-p*r,e[8]=a*r+c*o,e[9]=i*r+u*o,e[10]=s*r+d*o,e[11]=l*r+p*o,e}function w(e,t,n){var r=Math.sin(n),o=Math.cos(n),a=t[0],i=t[1],s=t[2],l=t[3],c=t[4],u=t[5],d=t[6],p=t[7];return t!==e&&(e[8]=t[8],e[9]=t[9],e[10]=t[10],e[11]=t[11],e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15]),e[0]=a*o+c*r,e[1]=i*o+u*r,e[2]=s*o+d*r,e[3]=l*o+p*r,e[4]=c*o-a*r,e[5]=u*o-i*r,e[6]=d*o-s*r,e[7]=p*o-l*r,e}function O(e,t){return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=1,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=1,e[11]=0,e[12]=t[0],e[13]=t[1],e[14]=t[2],e[15]=1,e}function P(e,t){return e[0]=t[0],e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=t[1],e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=t[2],e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function R(e,t,n){var r,o,a,s=n[0],l=n[1],c=n[2],u=Math.hypot(s,l,c);return u<i?null:(s*=u=1/u,l*=u,c*=u,r=Math.sin(t),a=1-(o=Math.cos(t)),e[0]=s*s*a+o,e[1]=l*s*a+c*r,e[2]=c*s*a-l*r,e[3]=0,e[4]=s*l*a-c*r,e[5]=l*l*a+o,e[6]=c*l*a+s*r,e[7]=0,e[8]=s*c*a+l*r,e[9]=l*c*a-s*r,e[10]=c*c*a+o,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e)}function M(e,t){var n=Math.sin(t),r=Math.cos(t);return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=r,e[6]=n,e[7]=0,e[8]=0,e[9]=-n,e[10]=r,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function E(e,t){var n=Math.sin(t),r=Math.cos(t);return e[0]=r,e[1]=0,e[2]=-n,e[3]=0,e[4]=0,e[5]=1,e[6]=0,e[7]=0,e[8]=n,e[9]=0,e[10]=r,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function V(e,t){var n=Math.sin(t),r=Math.cos(t);return e[0]=r,e[1]=n,e[2]=0,e[3]=0,e[4]=-n,e[5]=r,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=1,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function D(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=r+r,l=o+o,c=a+a,u=r*s,d=r*l,p=r*c,f=o*l,g=o*c,m=a*c,h=i*s,v=i*l,T=i*c;return e[0]=1-(f+m),e[1]=d+T,e[2]=p-v,e[3]=0,e[4]=d-T,e[5]=1-(u+m),e[6]=g+h,e[7]=0,e[8]=p+v,e[9]=g-h,e[10]=1-(u+f),e[11]=0,e[12]=n[0],e[13]=n[1],e[14]=n[2],e[15]=1,e}function L(e,t){var n=new s(3),r=-t[0],o=-t[1],a=-t[2],i=t[3],l=t[4],c=t[5],u=t[6],d=t[7],p=r*r+o*o+a*a+i*i;return p>0?(n[0]=2*(l*i+d*r+c*a-u*o)/p,n[1]=2*(c*i+d*o+u*r-l*a)/p,n[2]=2*(u*i+d*a+l*o-c*r)/p):(n[0]=2*(l*i+d*r+c*a-u*o),n[1]=2*(c*i+d*o+u*r-l*a),n[2]=2*(u*i+d*a+l*o-c*r)),D(e,t,n),e}function B(e,t){return e[0]=t[12],e[1]=t[13],e[2]=t[14],e}function N(e,t){var n=t[0],r=t[1],o=t[2],a=t[4],i=t[5],s=t[6],l=t[8],c=t[9],u=t[10];return e[0]=Math.hypot(n,r,o),e[1]=Math.hypot(a,i,s),e[2]=Math.hypot(l,c,u),e}function F(e,t){var n=new s(3);N(n,t);var r=1/n[0],o=1/n[1],a=1/n[2],i=t[0]*r,l=t[1]*o,c=t[2]*a,u=t[4]*r,d=t[5]*o,p=t[6]*a,f=t[8]*r,g=t[9]*o,m=t[10]*a,h=i+d+m,v=0;return h>0?(v=2*Math.sqrt(h+1),e[3]=.25*v,e[0]=(p-g)/v,e[1]=(f-c)/v,e[2]=(l-u)/v):i>d&&i>m?(v=2*Math.sqrt(1+i-d-m),e[3]=(p-g)/v,e[0]=.25*v,e[1]=(l+u)/v,e[2]=(f+c)/v):d>m?(v=2*Math.sqrt(1+d-i-m),e[3]=(f-c)/v,e[0]=(l+u)/v,e[1]=.25*v,e[2]=(p+g)/v):(v=2*Math.sqrt(1+m-i-d),e[3]=(l-u)/v,e[0]=(f+c)/v,e[1]=(p+g)/v,e[2]=.25*v),e}function _(e,t,n,r){var o=t[0],a=t[1],i=t[2],s=t[3],l=o+o,c=a+a,u=i+i,d=o*l,p=o*c,f=o*u,g=a*c,m=a*u,h=i*u,v=s*l,T=s*c,y=s*u,b=r[0],x=r[1],C=r[2];return e[0]=(1-(g+h))*b,e[1]=(p+y)*b,e[2]=(f-T)*b,e[3]=0,e[4]=(p-y)*x,e[5]=(1-(d+h))*x,e[6]=(m+v)*x,e[7]=0,e[8]=(f+T)*C,e[9]=(m-v)*C,e[10]=(1-(d+g))*C,e[11]=0,e[12]=n[0],e[13]=n[1],e[14]=n[2],e[15]=1,e}function k(e,t,n,r,o){var a=t[0],i=t[1],s=t[2],l=t[3],c=a+a,u=i+i,d=s+s,p=a*c,f=a*u,g=a*d,m=i*u,h=i*d,v=s*d,T=l*c,y=l*u,b=l*d,x=r[0],C=r[1],S=r[2],A=o[0],I=o[1],w=o[2],O=(1-(m+v))*x,P=(f+b)*x,R=(g-y)*x,M=(f-b)*C,E=(1-(p+v))*C,V=(h+T)*C,D=(g+y)*S,L=(h-T)*S,B=(1-(p+m))*S;return e[0]=O,e[1]=P,e[2]=R,e[3]=0,e[4]=M,e[5]=E,e[6]=V,e[7]=0,e[8]=D,e[9]=L,e[10]=B,e[11]=0,e[12]=n[0]+A-(O*A+M*I+D*w),e[13]=n[1]+I-(P*A+E*I+L*w),e[14]=n[2]+w-(R*A+V*I+B*w),e[15]=1,e}function G(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=n+n,s=r+r,l=o+o,c=n*i,u=r*i,d=r*s,p=o*i,f=o*s,g=o*l,m=a*i,h=a*s,v=a*l;return e[0]=1-d-g,e[1]=u+v,e[2]=p-h,e[3]=0,e[4]=u-v,e[5]=1-c-g,e[6]=f+m,e[7]=0,e[8]=p+h,e[9]=f-m,e[10]=1-c-d,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function U(e,t,n,r,o,a,i){var s=1/(n-t),l=1/(o-r),c=1/(a-i);return e[0]=2*a*s,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=2*a*l,e[6]=0,e[7]=0,e[8]=(n+t)*s,e[9]=(o+r)*l,e[10]=(i+a)*c,e[11]=-1,e[12]=0,e[13]=0,e[14]=i*a*2*c,e[15]=0,e}function z(e,t,n,r,o){var a,i=1/Math.tan(t/2);return e[0]=i/n,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=i,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[11]=-1,e[12]=0,e[13]=0,e[15]=0,null!=o&&o!==1/0?(a=1/(r-o),e[10]=(o+r)*a,e[14]=2*o*r*a):(e[10]=-1,e[14]=-2*r),e}Math.hypot||(Math.hypot=function(){for(var e=0,t=arguments.length;t--;)e+=arguments[t]*arguments[t];return Math.sqrt(e)});var W=z;function H(e,t,n,r,o){var a,i=1/Math.tan(t/2);return e[0]=i/n,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=i,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[11]=-1,e[12]=0,e[13]=0,e[15]=0,null!=o&&o!==1/0?(a=1/(r-o),e[10]=o*a,e[14]=o*r*a):(e[10]=-1,e[14]=-r),e}function j(e,t,n,r){var o=Math.tan(t.upDegrees*Math.PI/180),a=Math.tan(t.downDegrees*Math.PI/180),i=Math.tan(t.leftDegrees*Math.PI/180),s=Math.tan(t.rightDegrees*Math.PI/180),l=2/(i+s),c=2/(o+a);return e[0]=l,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=c,e[6]=0,e[7]=0,e[8]=-(i-s)*l*.5,e[9]=(o-a)*c*.5,e[10]=r/(n-r),e[11]=-1,e[12]=0,e[13]=0,e[14]=r*n/(n-r),e[15]=0,e}function K(e,t,n,r,o,a,i){var s=1/(t-n),l=1/(r-o),c=1/(a-i);return e[0]=-2*s,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=-2*l,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=2*c,e[11]=0,e[12]=(t+n)*s,e[13]=(o+r)*l,e[14]=(i+a)*c,e[15]=1,e}var $=K;function q(e,t,n,r,o,a,i){var s=1/(t-n),l=1/(r-o),c=1/(a-i);return e[0]=-2*s,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=-2*l,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=c,e[11]=0,e[12]=(t+n)*s,e[13]=(o+r)*l,e[14]=a*c,e[15]=1,e}function X(e,t,n,r){var o,a,s,l,c,u,d,p,f,g,h=t[0],v=t[1],T=t[2],y=r[0],b=r[1],x=r[2],C=n[0],S=n[1],A=n[2];return Math.abs(h-C)<i&&Math.abs(v-S)<i&&Math.abs(T-A)<i?m(e):(d=h-C,p=v-S,f=T-A,o=b*(f*=g=1/Math.hypot(d,p,f))-x*(p*=g),a=x*(d*=g)-y*f,s=y*p-b*d,(g=Math.hypot(o,a,s))?(o*=g=1/g,a*=g,s*=g):(o=0,a=0,s=0),l=p*s-f*a,c=f*o-d*s,u=d*a-p*o,(g=Math.hypot(l,c,u))?(l*=g=1/g,c*=g,u*=g):(l=0,c=0,u=0),e[0]=o,e[1]=l,e[2]=d,e[3]=0,e[4]=a,e[5]=c,e[6]=p,e[7]=0,e[8]=s,e[9]=u,e[10]=f,e[11]=0,e[12]=-(o*h+a*v+s*T),e[13]=-(l*h+c*v+u*T),e[14]=-(d*h+p*v+f*T),e[15]=1,e)}function Y(e,t,n,r){var o=t[0],a=t[1],i=t[2],s=r[0],l=r[1],c=r[2],u=o-n[0],d=a-n[1],p=i-n[2],f=u*u+d*d+p*p;f>0&&(u*=f=1/Math.sqrt(f),d*=f,p*=f);var g=l*p-c*d,m=c*u-s*p,h=s*d-l*u;return(f=g*g+m*m+h*h)>0&&(g*=f=1/Math.sqrt(f),m*=f,h*=f),e[0]=g,e[1]=m,e[2]=h,e[3]=0,e[4]=d*h-p*m,e[5]=p*g-u*h,e[6]=u*m-d*g,e[7]=0,e[8]=u,e[9]=d,e[10]=p,e[11]=0,e[12]=o,e[13]=a,e[14]=i,e[15]=1,e}function Z(e){return&quot;mat4(&quot;+e[0]+&quot;, &quot;+e[1]+&quot;, &quot;+e[2]+&quot;, &quot;+e[3]+&quot;, &quot;+e[4]+&quot;, &quot;+e[5]+&quot;, &quot;+e[6]+&quot;, &quot;+e[7]+&quot;, &quot;+e[8]+&quot;, &quot;+e[9]+&quot;, &quot;+e[10]+&quot;, &quot;+e[11]+&quot;, &quot;+e[12]+&quot;, &quot;+e[13]+&quot;, &quot;+e[14]+&quot;, &quot;+e[15]+&quot;)&quot;}function Q(e){return Math.hypot(e[0],e[1],e[2],e[3],e[4],e[5],e[6],e[7],e[8],e[9],e[10],e[11],e[12],e[13],e[14],e[15])}function J(e,t,n){return e[0]=t[0]+n[0],e[1]=t[1]+n[1],e[2]=t[2]+n[2],e[3]=t[3]+n[3],e[4]=t[4]+n[4],e[5]=t[5]+n[5],e[6]=t[6]+n[6],e[7]=t[7]+n[7],e[8]=t[8]+n[8],e[9]=t[9]+n[9],e[10]=t[10]+n[10],e[11]=t[11]+n[11],e[12]=t[12]+n[12],e[13]=t[13]+n[13],e[14]=t[14]+n[14],e[15]=t[15]+n[15],e}function ee(e,t,n){return e[0]=t[0]-n[0],e[1]=t[1]-n[1],e[2]=t[2]-n[2],e[3]=t[3]-n[3],e[4]=t[4]-n[4],e[5]=t[5]-n[5],e[6]=t[6]-n[6],e[7]=t[7]-n[7],e[8]=t[8]-n[8],e[9]=t[9]-n[9],e[10]=t[10]-n[10],e[11]=t[11]-n[11],e[12]=t[12]-n[12],e[13]=t[13]-n[13],e[14]=t[14]-n[14],e[15]=t[15]-n[15],e}function te(e,t,n){return e[0]=t[0]*n,e[1]=t[1]*n,e[2]=t[2]*n,e[3]=t[3]*n,e[4]=t[4]*n,e[5]=t[5]*n,e[6]=t[6]*n,e[7]=t[7]*n,e[8]=t[8]*n,e[9]=t[9]*n,e[10]=t[10]*n,e[11]=t[11]*n,e[12]=t[12]*n,e[13]=t[13]*n,e[14]=t[14]*n,e[15]=t[15]*n,e}function ne(e,t,n,r){return e[0]=t[0]+n[0]*r,e[1]=t[1]+n[1]*r,e[2]=t[2]+n[2]*r,e[3]=t[3]+n[3]*r,e[4]=t[4]+n[4]*r,e[5]=t[5]+n[5]*r,e[6]=t[6]+n[6]*r,e[7]=t[7]+n[7]*r,e[8]=t[8]+n[8]*r,e[9]=t[9]+n[9]*r,e[10]=t[10]+n[10]*r,e[11]=t[11]+n[11]*r,e[12]=t[12]+n[12]*r,e[13]=t[13]+n[13]*r,e[14]=t[14]+n[14]*r,e[15]=t[15]+n[15]*r,e}function re(e,t){return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]&&e[3]===t[3]&&e[4]===t[4]&&e[5]===t[5]&&e[6]===t[6]&&e[7]===t[7]&&e[8]===t[8]&&e[9]===t[9]&&e[10]===t[10]&&e[11]===t[11]&&e[12]===t[12]&&e[13]===t[13]&&e[14]===t[14]&&e[15]===t[15]}function oe(e,t){var n=e[0],r=e[1],o=e[2],a=e[3],s=e[4],l=e[5],c=e[6],u=e[7],d=e[8],p=e[9],f=e[10],g=e[11],m=e[12],h=e[13],v=e[14],T=e[15],y=t[0],b=t[1],x=t[2],C=t[3],S=t[4],A=t[5],I=t[6],w=t[7],O=t[8],P=t[9],R=t[10],M=t[11],E=t[12],V=t[13],D=t[14],L=t[15];return Math.abs(n-y)<=i*Math.max(1,Math.abs(n),Math.abs(y))&&Math.abs(r-b)<=i*Math.max(1,Math.abs(r),Math.abs(b))&&Math.abs(o-x)<=i*Math.max(1,Math.abs(o),Math.abs(x))&&Math.abs(a-C)<=i*Math.max(1,Math.abs(a),Math.abs(C))&&Math.abs(s-S)<=i*Math.max(1,Math.abs(s),Math.abs(S))&&Math.abs(l-A)<=i*Math.max(1,Math.abs(l),Math.abs(A))&&Math.abs(c-I)<=i*Math.max(1,Math.abs(c),Math.abs(I))&&Math.abs(u-w)<=i*Math.max(1,Math.abs(u),Math.abs(w))&&Math.abs(d-O)<=i*Math.max(1,Math.abs(d),Math.abs(O))&&Math.abs(p-P)<=i*Math.max(1,Math.abs(p),Math.abs(P))&&Math.abs(f-R)<=i*Math.max(1,Math.abs(f),Math.abs(R))&&Math.abs(g-M)<=i*Math.max(1,Math.abs(g),Math.abs(M))&&Math.abs(m-E)<=i*Math.max(1,Math.abs(m),Math.abs(E))&&Math.abs(h-V)<=i*Math.max(1,Math.abs(h),Math.abs(V))&&Math.abs(v-D)<=i*Math.max(1,Math.abs(v),Math.abs(D))&&Math.abs(T-L)<=i*Math.max(1,Math.abs(T),Math.abs(L))}var ae=b,ie=ee;function se(){var e=new s(9);return s!=Float32Array&&(e[1]=0,e[2]=0,e[3]=0,e[5]=0,e[6]=0,e[7]=0),e[0]=1,e[4]=1,e[8]=1,e}function le(e,t){return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[4],e[4]=t[5],e[5]=t[6],e[6]=t[8],e[7]=t[9],e[8]=t[10],e}function ce(e){var t=new s(9);return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t[4]=e[4],t[5]=e[5],t[6]=e[6],t[7]=e[7],t[8]=e[8],t}function ue(e,t){return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[4]=t[4],e[5]=t[5],e[6]=t[6],e[7]=t[7],e[8]=t[8],e}function de(e,t,n,r,o,a,i,l,c){var u=new s(9);return u[0]=e,u[1]=t,u[2]=n,u[3]=r,u[4]=o,u[5]=a,u[6]=i,u[7]=l,u[8]=c,u}function pe(e,t,n,r,o,a,i,s,l,c){return e[0]=t,e[1]=n,e[2]=r,e[3]=o,e[4]=a,e[5]=i,e[6]=s,e[7]=l,e[8]=c,e}function fe(e){return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=1,e[5]=0,e[6]=0,e[7]=0,e[8]=1,e}function ge(e,t){if(e===t){var n=t[1],r=t[2],o=t[5];e[1]=t[3],e[2]=t[6],e[3]=n,e[5]=t[7],e[6]=r,e[7]=o}else e[0]=t[0],e[1]=t[3],e[2]=t[6],e[3]=t[1],e[4]=t[4],e[5]=t[7],e[6]=t[2],e[7]=t[5],e[8]=t[8];return e}function me(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8],d=u*i-s*c,p=-u*a+s*l,f=c*a-i*l,g=n*d+r*p+o*f;return g?(g=1/g,e[0]=d*g,e[1]=(-u*r+o*c)*g,e[2]=(s*r-o*i)*g,e[3]=p*g,e[4]=(u*n-o*l)*g,e[5]=(-s*n+o*a)*g,e[6]=f*g,e[7]=(-c*n+r*l)*g,e[8]=(i*n-r*a)*g,e):null}function he(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8];return e[0]=i*u-s*c,e[1]=o*c-r*u,e[2]=r*s-o*i,e[3]=s*l-a*u,e[4]=n*u-o*l,e[5]=o*a-n*s,e[6]=a*c-i*l,e[7]=r*l-n*c,e[8]=n*i-r*a,e}function ve(e){var t=e[0],n=e[1],r=e[2],o=e[3],a=e[4],i=e[5],s=e[6],l=e[7],c=e[8];return t*(c*a-i*l)+n*(-c*o+i*s)+r*(l*o-a*s)}function Te(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=n[0],f=n[1],g=n[2],m=n[3],h=n[4],v=n[5],T=n[6],y=n[7],b=n[8];return e[0]=p*r+f*i+g*c,e[1]=p*o+f*s+g*u,e[2]=p*a+f*l+g*d,e[3]=m*r+h*i+v*c,e[4]=m*o+h*s+v*u,e[5]=m*a+h*l+v*d,e[6]=T*r+y*i+b*c,e[7]=T*o+y*s+b*u,e[8]=T*a+y*l+b*d,e}function ye(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=n[0],f=n[1];return e[0]=r,e[1]=o,e[2]=a,e[3]=i,e[4]=s,e[5]=l,e[6]=p*r+f*i+c,e[7]=p*o+f*s+u,e[8]=p*a+f*l+d,e}function be(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=Math.sin(n),f=Math.cos(n);return e[0]=f*r+p*i,e[1]=f*o+p*s,e[2]=f*a+p*l,e[3]=f*i-p*r,e[4]=f*s-p*o,e[5]=f*l-p*a,e[6]=c,e[7]=u,e[8]=d,e}function xe(e,t,n){var r=n[0],o=n[1];return e[0]=r*t[0],e[1]=r*t[1],e[2]=r*t[2],e[3]=o*t[3],e[4]=o*t[4],e[5]=o*t[5],e[6]=t[6],e[7]=t[7],e[8]=t[8],e}function Ce(e,t){return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=1,e[5]=0,e[6]=t[0],e[7]=t[1],e[8]=1,e}function Se(e,t){var n=Math.sin(t),r=Math.cos(t);return e[0]=r,e[1]=n,e[2]=0,e[3]=-n,e[4]=r,e[5]=0,e[6]=0,e[7]=0,e[8]=1,e}function Ae(e,t){return e[0]=t[0],e[1]=0,e[2]=0,e[3]=0,e[4]=t[1],e[5]=0,e[6]=0,e[7]=0,e[8]=1,e}function Ie(e,t){return e[0]=t[0],e[1]=t[1],e[2]=0,e[3]=t[2],e[4]=t[3],e[5]=0,e[6]=t[4],e[7]=t[5],e[8]=1,e}function we(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=n+n,s=r+r,l=o+o,c=n*i,u=r*i,d=r*s,p=o*i,f=o*s,g=o*l,m=a*i,h=a*s,v=a*l;return e[0]=1-d-g,e[3]=u-v,e[6]=p+h,e[1]=u+v,e[4]=1-c-g,e[7]=f-m,e[2]=p-h,e[5]=f+m,e[8]=1-c-d,e}function Oe(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8],d=t[9],p=t[10],f=t[11],g=t[12],m=t[13],h=t[14],v=t[15],T=n*s-r*i,y=n*l-o*i,b=n*c-a*i,x=r*l-o*s,C=r*c-a*s,S=o*c-a*l,A=u*m-d*g,I=u*h-p*g,w=u*v-f*g,O=d*h-p*m,P=d*v-f*m,R=p*v-f*h,M=T*R-y*P+b*O+x*w-C*I+S*A;return M?(M=1/M,e[0]=(s*R-l*P+c*O)*M,e[1]=(l*w-i*R-c*I)*M,e[2]=(i*P-s*w+c*A)*M,e[3]=(o*P-r*R-a*O)*M,e[4]=(n*R-o*w+a*I)*M,e[5]=(r*w-n*P-a*A)*M,e[6]=(m*S-h*C+v*x)*M,e[7]=(h*b-g*S-v*y)*M,e[8]=(g*C-m*b+v*T)*M,e):null}function Pe(e,t,n){return e[0]=2/t,e[1]=0,e[2]=0,e[3]=0,e[4]=-2/n,e[5]=0,e[6]=-1,e[7]=1,e[8]=1,e}function Re(e){return&quot;mat3(&quot;+e[0]+&quot;, &quot;+e[1]+&quot;, &quot;+e[2]+&quot;, &quot;+e[3]+&quot;, &quot;+e[4]+&quot;, &quot;+e[5]+&quot;, &quot;+e[6]+&quot;, &quot;+e[7]+&quot;, &quot;+e[8]+&quot;)&quot;}function Me(e){return Math.hypot(e[0],e[1],e[2],e[3],e[4],e[5],e[6],e[7],e[8])}function Ee(e,t,n){return e[0]=t[0]+n[0],e[1]=t[1]+n[1],e[2]=t[2]+n[2],e[3]=t[3]+n[3],e[4]=t[4]+n[4],e[5]=t[5]+n[5],e[6]=t[6]+n[6],e[7]=t[7]+n[7],e[8]=t[8]+n[8],e}function Ve(e,t,n){return e[0]=t[0]-n[0],e[1]=t[1]-n[1],e[2]=t[2]-n[2],e[3]=t[3]-n[3],e[4]=t[4]-n[4],e[5]=t[5]-n[5],e[6]=t[6]-n[6],e[7]=t[7]-n[7],e[8]=t[8]-n[8],e}function De(e,t,n){return e[0]=t[0]*n,e[1]=t[1]*n,e[2]=t[2]*n,e[3]=t[3]*n,e[4]=t[4]*n,e[5]=t[5]*n,e[6]=t[6]*n,e[7]=t[7]*n,e[8]=t[8]*n,e}function Le(e,t,n,r){return e[0]=t[0]+n[0]*r,e[1]=t[1]+n[1]*r,e[2]=t[2]+n[2]*r,e[3]=t[3]+n[3]*r,e[4]=t[4]+n[4]*r,e[5]=t[5]+n[5]*r,e[6]=t[6]+n[6]*r,e[7]=t[7]+n[7]*r,e[8]=t[8]+n[8]*r,e}function Be(e,t){return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]&&e[3]===t[3]&&e[4]===t[4]&&e[5]===t[5]&&e[6]===t[6]&&e[7]===t[7]&&e[8]===t[8]}function Ne(e,t){var n=e[0],r=e[1],o=e[2],a=e[3],s=e[4],l=e[5],c=e[6],u=e[7],d=e[8],p=t[0],f=t[1],g=t[2],m=t[3],h=t[4],v=t[5],T=t[6],y=t[7],b=t[8];return Math.abs(n-p)<=i*Math.max(1,Math.abs(n),Math.abs(p))&&Math.abs(r-f)<=i*Math.max(1,Math.abs(r),Math.abs(f))&&Math.abs(o-g)<=i*Math.max(1,Math.abs(o),Math.abs(g))&&Math.abs(a-m)<=i*Math.max(1,Math.abs(a),Math.abs(m))&&Math.abs(s-h)<=i*Math.max(1,Math.abs(s),Math.abs(h))&&Math.abs(l-v)<=i*Math.max(1,Math.abs(l),Math.abs(v))&&Math.abs(c-T)<=i*Math.max(1,Math.abs(c),Math.abs(T))&&Math.abs(u-y)<=i*Math.max(1,Math.abs(u),Math.abs(y))&&Math.abs(d-b)<=i*Math.max(1,Math.abs(d),Math.abs(b))}var Fe=Te,_e=Ve,ke=n(730);const Ge=n(59)(),Ue={vtkObject:()=>null};function ze(e){if(null==e)return e;if(e.isA)return e;if(!e.vtkClass)return Ge.console&&Ge.console.error&&Ge.console.error(&quot;Invalid VTK object&quot;),null;const t=Ue[e.vtkClass];if(!t)return Ge.console&&Ge.console.error&&Ge.console.error(`No vtk class found for Object of type ${e.vtkClass}`),null;const n={...e};Object.keys(n).forEach((e=>{n[e]&&&quot;object&quot;==typeof n[e]&&n[e].vtkClass&&(n[e]=ze(n[e]))}));const r=t(n);return r&&r.modified&&r.modified(),r}ze.register=function(e,t){Ue[e]=t};class We extends Array{push(){for(let e=0;e<arguments.length;e++)this.includes(arguments[e])||super.push(arguments[e]);return this.length}}let He=0;const je=e=>{throw new Error(`Named parameter '${e}' is missing`)},Ke=Symbol(&quot;void&quot;),$e={};function qe(){}[&quot;log&quot;,&quot;debug&quot;,&quot;info&quot;,&quot;warn&quot;,&quot;error&quot;,&quot;time&quot;,&quot;timeEnd&quot;,&quot;group&quot;,&quot;groupEnd&quot;].forEach((e=>{$e[e]=qe})),Ge.console=console.hasOwnProperty(&quot;log&quot;)?console:$e;const Xe={debug:qe,error:Ge.console.error||qe,info:Ge.console.info||qe,log:Ge.console.log||qe,warn:Ge.console.warn||qe};function Ye(e,t){Xe[e]&&(Xe[e]=t||qe)}function Ze(){Xe.log(...arguments)}function Qe(){Xe.info(...arguments)}function Je(){Xe.debug(...arguments)}function et(){Xe.error(...arguments)}function tt(){Xe.warn(...arguments)}const nt={};function rt(e){nt[e]||(Xe.error(e),nt[e]=!0)}const ot=Object.create(null);ot.Float32Array=Float32Array,ot.Float64Array=Float64Array,ot.Uint8Array=Uint8Array,ot.Int8Array=Int8Array,ot.Uint16Array=Uint16Array,ot.Int16Array=Int16Array,ot.Uint32Array=Uint32Array,ot.Int32Array=Int32Array,ot.Uint8ClampedArray=Uint8ClampedArray;try{ot.BigInt64Array=BigInt64Array,ot.BigUint64Array=BigUint64Array}catch{}function at(e){for(var t=arguments.length,n=new Array(t>1?t-1:0),r=1;r<t;r++)n[r-1]=arguments[r];return new(ot[e]||Float64Array)(...n)}function it(e){for(var t=arguments.length,n=new Array(t>1?t-1:0),r=1;r<t;r++)n[r-1]=arguments[r];return(ot[e]||Float64Array).from(...n)}function st(e){return e.charAt(0).toUpperCase()+e.slice(1)}function lt(e){return st(&quot;_&quot;===e[0]?e.slice(1):e)}function ct(e){return e.charAt(0).toLowerCase()+e.slice(1)}function ut(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:2,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1e3;const r=[&quot;TB&quot;,&quot;GB&quot;,&quot;MB&quot;,&quot;KB&quot;];let o=Number(e),a=&quot;B&quot;;for(;o>n;)o/=n,a=r.pop();return`${o.toFixed(t)} ${a}`}function dt(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:&quot; &quot;;const n=[];let r=e;for(;r>1e3;)n.push((&quot;000&quot;+r%1e3).slice(-3)),r=Math.floor(r/1e3);return r>0&&n.push(r),n.reverse(),n.join(t)}function pt(e){Object.keys(e).forEach((t=>{Array.isArray(e[t])&&(e[t]=[].concat(e[t]))}))}function ft(e){return e&&e.isA?e.getState():e}function gt(e){setTimeout(e,0)}function mt(e,t){const n=performance.now();e.finally((()=>{const e=performance.now()-n;t(e)}))}function ht(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};pt(t);const n=[];if(Number.isInteger(t.mtime)||(t.mtime=++He),&quot;classHierarchy&quot;in t){if(!(t.classHierarchy instanceof We)){const e=new We;for(let n=0;n<t.classHierarchy.length;n++)e.push(t.classHierarchy[n]);t.classHierarchy=e}}else t.classHierarchy=new We(&quot;vtkObject&quot;);function r(e){n[e]=null}return e.isDeleted=()=>!!t.deleted,e.modified=r=>{t.deleted?et(&quot;instance deleted - cannot call any method&quot;):r&&r<e.getMTime()||(t.mtime=++He,n.forEach((t=>t&&t(e))))},e.onModified=e=>{if(t.deleted)return et(&quot;instance deleted - cannot call any method&quot;),null;const o=n.length;return n.push(e),function(e){return Object.freeze({unsubscribe:function(){r(e)}})}(o)},e.getMTime=()=>t.mtime,e.isA=e=>{let n=t.classHierarchy.length;for(;n--;)if(t.classHierarchy[n]===e)return!0;return!1},e.getClassName=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.classHierarchy[t.classHierarchy.length-1-e]},e.set=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1&&void 0!==arguments[1]&&arguments[1],o=arguments.length>2&&void 0!==arguments[2]&&arguments[2],a=!1;return Object.keys(n).forEach((i=>{const s=o?null:e[`set${st(i)}`];s&&Array.isArray(n[i])&&s.length>1?a=s(...n[i])||a:s?a=s(n[i])||a:(-1!==[&quot;mtime&quot;].indexOf(i)||r||tt(`Warning: Set value to model directly ${i}, ${n[i]}`),a=t[i]!==n[i]||a,t[i]=n[i])})),a},e.get=function(){for(var e=arguments.length,n=new Array(e),r=0;r<e;r++)n[r]=arguments[r];if(!n.length)return t;const o={};return n.forEach((e=>{o[e]=t[e]})),o},e.getReferenceByName=e=>t[e],e.delete=()=>{Object.keys(t).forEach((e=>delete t[e])),n.forEach(((e,t)=>r(t))),t.deleted=!0},e.getState=()=>{if(t.deleted)return null;const n={...t,vtkClass:e.getClassName()};Object.keys(n).forEach((e=>{null===n[e]||void 0===n[e]||&quot;_&quot;===e[0]?delete n[e]:n[e].isA?n[e]=n[e].getState():Array.isArray(n[e])?n[e]=n[e].map(ft):function(e){return Object.values(ot).some((t=>e instanceof t))}(n[e])&&(n[e]=Array.from(n[e]))}));const r={};return Object.keys(n).sort().forEach((e=>{r[e]=n[e]})),r.mtime&&delete r.mtime,r},e.shallowCopy=function(n){let r=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(n.getClassName()!==e.getClassName())throw new Error(`Cannot ShallowCopy ${n.getClassName()} into ${e.getClassName()}`);const o=n.get(),a=Object.keys(t).sort();Object.keys(o).sort().forEach((e=>{const n=a.indexOf(e);-1===n?r&&Je(`add ${e} in shallowCopy`):a.splice(n,1),t[e]=o[e]})),a.length&&r&&Je(`Untouched keys: ${a.join(&quot;, &quot;)}`),e.modified()},e.toJSON=function(){return e.getState()},e}const vt={object(e,t,n){return function(){return{...t[n.name]}}}};function Tt(e,t,n){n.forEach((n=>{if(&quot;object&quot;==typeof n){const r=vt[n.type];e[`get${lt(n.name)}`]=r?r(e,t,n):()=>t[n.name]}else e[`get${lt(n)}`]=()=>t[n]}))}const yt={enum(e,t,n){const r=`_on${lt(n.name)}Changed`;return o=>{if(&quot;string&quot;==typeof o){if(void 0!==n.enum[o])return t[n.name]!==n.enum[o]&&(t[n.name]=n.enum[o],e.modified(),!0);throw et(`Set Enum with invalid argument ${n}, ${o}`),new RangeError(&quot;Set Enum with invalid string argument&quot;)}if(&quot;number&quot;==typeof o){if(t[n.name]!==o){if(-1!==Object.keys(n.enum).map((e=>n.enum[e])).indexOf(o)){const a=t[n.name];return t[n.name]=o,t[r]?.(e,t,o,a),e.modified(),!0}throw et(`Set Enum outside numeric range ${n}, ${o}`),new RangeError(&quot;Set Enum outside numeric range&quot;)}return!1}throw et(`Set Enum with invalid argument (String/Number) ${n}, ${o}`),new TypeError(&quot;Set Enum with invalid argument (String/Number)&quot;)}},object(e,t,n){1===n.params?.length&&tt('Setter of type &quot;object&quot; with a single &quot;param&quot; field is not supported');const r=`_on${lt(n.name)}Changed`;return function(){for(var o=arguments.length,a=new Array(o),i=0;i<o;i++)a[i]=arguments[i];let s;if(s=a.length>1&&n.params?.length?n.params.reduce(((e,t,n)=>Object.assign(e,{[t]:a[n]})),{}):a[0],!ke(t[n.name],s)){const o=t[n.name];return t[n.name]=s,t[r]?.(e,t,s,o),e.modified(),!0}return!1}}};function bt(e){if(&quot;object&quot;==typeof e){const t=yt[e.type];if(t)return(n,r)=>t(n,r,e);throw et(`No setter for field ${e}`),new TypeError(&quot;No setter for field&quot;)}return function(t,n){const r=`_on${lt(e)}Changed`;return function(o){if(n.deleted)return et(&quot;instance deleted - cannot call any method&quot;),!1;if(n[e]!==o){const a=n[e.name];return n[e]=o,n[r]?.(t,n,o,a),t.modified(),!0}return!1}}}function xt(e,t,n){n.forEach((n=>{&quot;object&quot;==typeof n?e[`set${lt(n.name)}`]=bt(n)(e,t):e[`set${lt(n)}`]=bt(n)(e,t)}))}function Ct(e,t,n){Tt(e,t,n),xt(e,t,n)}function St(e,t,n){n.forEach((n=>{e[`get${lt(n)}`]=()=>t[n]?Array.from(t[n]):t[n],e[`get${lt(n)}ByReference`]=()=>t[n]}))}function At(e,t,n,r){let o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:void 0;n.forEach((n=>{if(t[n]&&r&&t[n].length!==r)throw new RangeError(`Invalid initial number of values for array (${n})`);const a=`_on${lt(n)}Changed`;e[`set${lt(n)}`]=function(){if(t.deleted)return et(&quot;instance deleted - cannot call any method&quot;),!1;for(var i=arguments.length,s=new Array(i),l=0;l<i;l++)s[l]=arguments[l];let c,u=s,d=!1;if(1===u.length&&(null==u[0]||u[0].length>=0)&&(u=u[0],d=!0),null==u)c=t[n]!==u;else{if(r&&u.length!==r){if(!(u.length<r&&void 0!==o))throw new RangeError(`Invalid number of values for array setter (${n})`);for(u=Array.from(u),d=!1;u.length<r;)u.push(o)}c=null==t[n]||t[n].length!==u.length;for(let e=0;!c&&e<u.length;++e)c=t[n][e]!==u[e];c&&d&&(u=Array.from(u))}if(c){const r=t[n.name];t[n]=u,t[a]?.(e,t,u,r),e.modified()}return c},e[`set${lt(n)}From`]=e=>{const r=t[n];e.forEach(((e,t)=>{r[t]=e}))}}))}function It(e,t,n,r){let o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:void 0;St(e,t,n),At(e,t,n,r,o)}function wt(e,t,n){for(let e=0;e<n.length;e++){const r=n[e];void 0!==t[r]&&(t[`_${r}`]=t[r],delete t[r])}}function Ot(e,t,n,r){function o(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;t.deleted?et(&quot;instance deleted - cannot call any method&quot;):r>=t.numberOfInputs?et(`algorithm ${e.getClassName()} only has ${t.numberOfInputs} input ports. To add more input ports, use addInputData()`):(t.inputData[r]!==n||t.inputConnection[r])&&(t.inputData[r]=n,t.inputConnection[r]=null,e.modified&&e.modified())}function a(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;if(t.deleted)et(&quot;instance deleted - cannot call any method&quot;);else{if(r>=t.numberOfInputs){let n=`algorithm ${e.getClassName()} only has `;return n+=`${t.numberOfInputs}`,n+=&quot; input ports. To add more input ports, use addInputConnection()&quot;,void et(n)}t.inputData[r]=null,t.inputConnection[r]=n}}function i(){let e=t.numberOfInputs;for(;e&&!t.inputData[e-1]&&!t.inputConnection[e-1];)e--;return e===t.numberOfInputs&&t.numberOfInputs++,e}function s(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.deleted?(et(&quot;instance deleted - cannot call any method&quot;),null):(e.shouldUpdate()&&e.update(),t.output[n])}if(t.inputData?t.inputData=t.inputData.map(ze):t.inputData=[],t.inputConnection?t.inputConnection=t.inputConnection.map(ze):t.inputConnection=[],t.output?t.output=t.output.map(ze):t.output=[],t.inputArrayToProcess?t.inputArrayToProcess=t.inputArrayToProcess.map(ze):t.inputArrayToProcess=[],t.numberOfInputs=n,e.shouldUpdate=()=>{const n=e.getMTime();let o=1/0,a=r;for(;a--;){if(!t.output[a]||t.output[a].isDeleted())return!0;const e=t.output[a].getMTime();if(e<n)return!0;e<o&&(o=e)}for(a=t.numberOfInputs;a--;)if(t.inputConnection[a]?.filter.shouldUpdate()||e.getInputData(a)?.getMTime()>o)return!0;return!1},t.numberOfInputs){let n=t.numberOfInputs;for(;n--;)t.inputData.push(null),t.inputConnection.push(null);e.setInputData=o,e.setInputConnection=a,e.addInputData=function(e){t.deleted?et(&quot;instance deleted - cannot call any method&quot;):o(e,i())},e.addInputConnection=function(e){t.deleted?et(&quot;instance deleted - cannot call any method&quot;):a(e,i())},e.getInputData=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.inputConnection[e]&&(t.inputData[e]=t.inputConnection[e]()),t.inputData[e]},e.getInputConnection=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.inputConnection[e]}}r&&(e.getOutputData=s,e.getOutputPort=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;const n=()=>s(t);return n.filter=e,n}),e.update=()=>{const n=[];if(t.numberOfInputs){let r=0;for(;r<t.numberOfInputs;)n[r]=e.getInputData(r),r++}e.requestData&&!e.isDeleted()&&e.shouldUpdate()&&e.requestData(n,t.output)},e.getNumberOfInputPorts=()=>t.numberOfInputs,e.getNumberOfOutputPorts=()=>r||t.output.length,e.getInputArrayToProcess=e=>{const n=t.inputArrayToProcess[e],r=t.inputData[e];return n&&r?r[`get${n.fieldAssociation}`]().getArray(n.arrayName):null},e.setInputArrayToProcess=function(e,n,r){let o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:&quot;Scalars&quot;;for(;t.inputArrayToProcess.length<e;)t.inputArrayToProcess.push(null);t.inputArrayToProcess[e]={arrayName:n,fieldAssociation:r,attributeType:o}}}const Pt=Symbol(&quot;Event abort&quot;);function Rt(e,t,n){const r=[],o=e.delete;let a=1;function i(e){for(let t=0;t<r.length;++t){const[n]=r[t];if(n===e)return void r.splice(t,1)}}e[`invoke${lt(n)}`]=function(){if(t.deleted)return void et(&quot;instance deleted - cannot call any method&quot;);const n=r.slice();for(let t=0;t<n.length;++t){const[,r,o]=n[t];if(r)if(o<0)setTimeout((()=>r.apply(e,arguments)),1-o);else if(r.apply(e,arguments)===Pt)break}},e[`on${lt(n)}`]=function(e){let o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;if(!e.apply)return console.error(`Invalid callback for event ${n}`),null;if(t.deleted)return et(&quot;instance deleted - cannot call any method&quot;),null;const s=a++;return r.push([s,e,o]),r.sort(((e,t)=>t[2]-e[2])),function(e){return Object.freeze({unsubscribe:function(){i(e)}})}(s)},e.delete=()=>{o(),r.forEach((e=>{let[t]=e;return i(t)}))}}function Mt(e,t){const n=function(){const t={};return e(t,{},arguments.length>0&&void 0!==arguments[0]?arguments[0]:{}),Object.freeze(t)};return t&&ze.register(t,n),n}function Et(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return function(){for(var e=arguments.length,n=new Array(e),r=0;r<e;r++)n[r]=arguments[r];return t.filter((e=>!!e)).map((e=>e(...n)))}}function Vt(e){return e&&e.isA&&e.isA(&quot;vtkObject&quot;)}function Dt(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[],r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[];if(Vt(e)){if(r.indexOf(e)>=0)return n;r.push(e);const o=t(e);void 0!==o&&n.push(o);const a=e.get();Object.keys(a).forEach((e=>{const o=a[e];Array.isArray(o)?o.forEach((e=>{Dt(e,t,n,r)})):Dt(o,t,n,r)}))}return n}function Lt(e,t,n){var r=this;let o;const a=function(){for(var a=arguments.length,i=new Array(a),s=0;s<a;s++)i[s]=arguments[s];const l=r,c=n&&!o;clearTimeout(o),o=setTimeout((()=>{o=null,n||e.apply(l,i)}),t),c&&e.apply(l,i)};return a.cancel=()=>clearTimeout(o),a}function Bt(e,t){let n=!1,r=null;function o(){n=!1,null!==r&&(a(...r),r=null)}function a(){for(var a=arguments.length,i=new Array(a),s=0;s<a;s++)i[s]=arguments[s];n?r=i:(n=!0,e(...i),setTimeout(o,t))}return a}function Nt(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};t.keystore=Object.assign(t.keystore||{},n),e.setKey=(e,n)=>{t.keystore[e]=n},e.getKey=e=>t.keystore[e],e.getAllKeys=()=>Object.keys(t.keystore),e.deleteKey=e=>delete t.keystore[e],e.clearKeystore=()=>e.getAllKeys().forEach((e=>delete t.keystore[e]))}let Ft=1;const _t=&quot;__root__&quot;;function kt(e,t){Nt(e,t);const n=e.delete;t.proxyId=&quot;&quot;+Ft++,t.ui=JSON.parse(JSON.stringify(t.ui||[])),Tt(e,t,[&quot;proxyId&quot;,&quot;proxyGroup&quot;,&quot;proxyName&quot;]),Ct(e,t,[&quot;proxyManager&quot;]);const r={},o={};function a(e,t){o[t]||(o[t]=[]);const n=o[t];for(let t=0;t<e.length;t++)n.push(e[t].name),r[e[t].name]=e[t],e[t].children&&e[t].children.length&&a(e[t].children,e[t].name)}function i(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:_t;const r=[],a=t.proxyId,s=function(){return o[arguments.length>0&&void 0!==arguments[0]?arguments[0]:_t]}(n)||[];for(let t=0;t<s.length;t++){const n=s[t],o=e[`get${lt(n)}`],l={id:a,name:n,value:o?o():void 0},c=i(n);c.length&&(l.children=c),r.push(l)}return r}a(t.ui,_t),e.updateUI=n=>{t.ui=JSON.parse(JSON.stringify(n||[])),Object.keys(r).forEach((e=>delete r[e])),Object.keys(o).forEach((e=>delete o[e])),a(t.ui,_t),e.modified()},e.updateProxyProperty=(e,t)=>{const n=r[e];n?Object.assign(n,t):r[e]={...t}},e.activate=()=>{if(t.proxyManager){const n=`setActive${lt(e.getProxyGroup().slice(0,-1))}`;t.proxyManager[n]&&t.proxyManager[n](e)}},t.propertyLinkSubscribers={},e.registerPropertyLinkForGC=(e,n)=>{n in t.propertyLinkSubscribers||(t.propertyLinkSubscribers[n]=[]),t.propertyLinkSubscribers[n].push(e)},e.gcPropertyLinks=n=>{const r=t.propertyLinkSubscribers[n]||[];for(;r.length;)r.pop().unbind(e)},t.propertyLinkMap={},e.getPropertyLink=function(e){let n=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(t.propertyLinkMap[e])return t.propertyLinkMap[e];let r=null;const o=[];let a=0,i=!1;function s(n){let s=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(i)return null;const l=[];let c=null;for(a=o.length;a--;){const e=o[a];e.instance===n?c=e:l.push(e)}if(!c)return null;const u=c.instance[`get${lt(c.propertyName)}`]();if(!function(e,t){if(e===t)return!0;if(Array.isArray(e)&&Array.isArray(t)){if(e.length!==t.length)return!1;for(let n=0;n<e.length;n++)if(e[n]!==t[n])return!1;return!0}return!1}(u,r)||s){for(r=u,i=!0;l.length;){const e=l.pop();e.instance.set({[e.propertyName]:r})}i=!1}return t.propertyLinkMap[e].persistent&&(t.propertyLinkMap[e].value=u),u}function l(e,t){const n=[];for(a=o.length;a--;){const r=o[a];r.instance!==e||r.propertyName!==t&&void 0!==t||(r.subscription.unsubscribe(),n.push(a))}for(;n.length;)o.splice(n.pop(),1)}const c={bind:function(n,r){let a=arguments.length>2&&void 0!==arguments[2]&&arguments[2];const i=n.onModified(s),c=o[0];return o.push({instance:n,propertyName:r,subscription:i}),a&&(t.propertyLinkMap[e].persistent&&void 0!==t.propertyLinkMap[e].value?n.set({[r]:t.propertyLinkMap[e].value}):c&&s(c.instance,!0)),{unsubscribe:()=>l(n,r)}},unbind:l,unsubscribe:function(){for(;o.length;)o.pop().subscription.unsubscribe()},persistent:n};return t.propertyLinkMap[e]=c,c},e.listPropertyNames=()=>i().map((e=>e.name)),e.getPropertyByName=e=>i().find((t=>t.name===e)),e.getPropertyDomainByName=e=>(r[e]||{}).domain,e.getProxySection=()=>({id:t.proxyId,name:t.proxyGroup,ui:t.ui,properties:i()}),e.delete=()=>{const r=Object.keys(t.propertyLinkMap);let o=r.length;for(;o--;)t.propertyLinkMap[r[o]].unsubscribe();Object.keys(t.propertyLinkSubscribers).forEach(e.gcPropertyLinks),n()},e.getState=()=>null,gt((function(){if(t.links)for(let n=0;n<t.links.length;n++){const{link:r,property:o,persistent:a,updateOnBind:i,type:s}=t.links[n];if(&quot;application&quot;===s){const n=t.proxyManager.getPropertyLink(r,a);e.registerPropertyLinkForGC(n,&quot;application&quot;),n.bind(e,o,i)}}}))}function Gt(e,t,n){const r=e.delete,o=[],a=Object.keys(n);let i=a.length;for(;i--;){const r=a[i],{modelKey:s,property:l,modified:c=!0}=n[r],u=lt(l),d=lt(r);e[`get${d}`]=t[s][`get${u}`],e[`set${d}`]=t[s][`set${u}`],c&&o.push(t[s].onModified(e.modified))}e.delete=()=>{for(;o.length;)o.pop().unsubscribe();r()}}function Ut(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};function o(e){const n=Object.keys(e);let r=n.length;for(;r--;){const o=n[r];t[o].set(e[o])}}t.this=e;const a=Object.keys(r);let i=a.length;for(;i--;){const s=a[i];t[s]=r[s];const l=n[s];e[`set${lt(s)}`]=n=>{n!==t[s]&&(t[s]=n,o(l[n]),e.modified())}}a.length&&Tt(e,t,a)}function zt(e){let t=0,n=0,r=0,o=0;return&quot;detail&quot;in e&&(n=e.detail),&quot;wheelDelta&quot;in e&&(n=-e.wheelDelta/120),&quot;wheelDeltaY&quot;in e&&(n=-e.wheelDeltaY/120),&quot;wheelDeltaX&quot;in e&&(t=-e.wheelDeltaX/120),&quot;axis&quot;in e&&e.axis===e.HORIZONTAL_AXIS&&(t=n,n=0),r=10*t,o=10*n,&quot;deltaY&quot;in e&&(o=e.deltaY),&quot;deltaX&quot;in e&&(r=e.deltaX),(r||o)&&e.deltaMode&&(1===e.deltaMode?(r*=40,o*=40):(r*=800,o*=800)),r&&!t&&(t=r<1?-1:1),o&&!n&&(n=o<1?-1:1),{spinX:t,spinY:n||t,pixelX:r,pixelY:o||r}}var Wt={algo:Ot,capitalize:st,chain:Et,debounce:Lt,enumToString:function(e,t){return Object.keys(e).find((n=>e[n]===t))},event:Rt,EVENT_ABORT:Pt,formatBytesToProperUnit:ut,formatNumbersWithThousandSeparator:dt,get:Tt,getArray:St,getCurrentGlobalMTime:function(){return He},getStateArrayMapFunc:ft,isVtkObject:Vt,keystore:Nt,measurePromiseExecution:mt,moveToProtected:wt,newInstance:Mt,newTypedArray:at,newTypedArrayFrom:it,normalizeWheel:zt,obj:ht,proxy:kt,proxyPropertyMapping:Gt,proxyPropertyState:Ut,safeArrays:pt,set:xt,setArray:At,setGet:Ct,setGetArray:It,setImmediate:gt,setLoggerFunction:Ye,throttle:Bt,traverseInstanceTree:Dt,TYPED_ARRAYS:ot,uncapitalize:ct,VOID:Ke,vtkDebugMacro:Je,vtkErrorMacro:et,vtkInfoMacro:Qe,vtkLogMacro:Ze,vtkOnceErrorMacro:rt,vtkWarningMacro:tt,objectSetterMap:yt,requiredParam:je},Ht=Object.freeze({__proto__:null,requiredParam:je,VOID:Ke,setLoggerFunction:Ye,vtkLogMacro:Ze,vtkInfoMacro:Qe,vtkDebugMacro:Je,vtkErrorMacro:et,vtkWarningMacro:tt,vtkOnceErrorMacro:rt,TYPED_ARRAYS:ot,newTypedArray:at,newTypedArrayFrom:it,capitalize:st,_capitalize:lt,uncapitalize:ct,formatBytesToProperUnit:ut,formatNumbersWithThousandSeparator:dt,setImmediateVTK:gt,measurePromiseExecution:mt,obj:ht,get:Tt,set:xt,setGet:Ct,getArray:St,setArray:At,setGetArray:It,moveToProtected:wt,algo:Ot,EVENT_ABORT:Pt,event:Rt,newInstance:Mt,chain:Et,isVtkObject:Vt,traverseInstanceTree:Dt,debounce:Lt,throttle:Bt,keystore:Nt,proxy:kt,proxyPropertyMapping:Gt,proxyPropertyState:Ut,normalizeWheel:zt,default:Wt});const{vtkErrorMacro:jt}=Wt,Kt={renderable:null,myFactory:null,children:[],visited:!1};function $t(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Kt,n),Wt.obj(e,t),Wt.event(e,t,&quot;event&quot;),t._renderableChildMap=new Map,Wt.get(e,t,[&quot;visited&quot;]),Wt.setGet(e,t,[&quot;_parent&quot;,&quot;renderable&quot;,&quot;myFactory&quot;]),Wt.getArray(e,t,[&quot;children&quot;]),Wt.moveToProtected(e,t,[&quot;parent&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkViewNode&quot;),e.build=e=>{},e.render=e=>{},e.traverse=n=>{const r=n.getTraverseOperation(),o=e[r];if(o)o(n);else{e.apply(n,!0);for(let e=0;e<t.children.length;e++)t.children[e].traverse(n);e.apply(n,!1)}},e.apply=(t,n)=>{const r=e[t.getOperation()];r&&r(n,t)},e.getViewNodeFor=n=>{if(t.renderable===n)return e;for(let e=0;e<t.children.length;++e){const r=t.children[e].getViewNodeFor(n);if(r)return r}},e.getFirstAncestorOfType=e=>t._parent?t._parent.isA(e)?t._parent:t._parent.getFirstAncestorOfType(e):null,e.getLastAncestorOfType=e=>t._parent?t._parent.getLastAncestorOfType(e)||(t._parent.isA(e)?t._parent:null):null,e.addMissingNode=n=>{if(!n)return;const r=t._renderableChildMap.get(n);if(void 0!==r)return r.setVisited(!0),r;const o=e.createViewNode(n);return o?(o.setParent(e),o.setVisited(!0),t._renderableChildMap.set(n,o),t.children.push(o),o):void 0},e.addMissingNodes=function(n){let r=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(n&&n.length)for(let o=0;o<n.length;++o){const a=n[o],i=e.addMissingNode(a);if(r&&void 0!==i&&t.children[o]!==i)for(let e=o+1;e<t.children.length;++e)if(t.children[e]===i){t.children.splice(e,1),t.children.splice(o,0,i);break}}},e.addMissingChildren=n=>{if(n&&n.length)for(let r=0;r<n.length;++r){const o=n[r];if(-1===t.children.indexOf(o)){o.setParent(e),t.children.push(o);const n=o.getRenderable();n&&t._renderableChildMap.set(n,o)}o.setVisited(!0)}},e.removeNode=e=>{const n=t.children.findIndex((t=>t===e));if(n<0)return!1;const r=e.getRenderable();return r&&t._renderableChildMap.delete(r),e.delete(),t.children.splice(n,1),!0},e.prepareNodes=()=>{for(let e=0;e<t.children.length;++e)t.children[e].setVisited(!1)},e.setVisited=e=>{t.visited=e},e.removeUnusedNodes=()=>{let e=0;for(let n=0;n<t.children.length;++n){const r=t.children[n];if(r.getVisited())t.children[e++]=r,r.setVisited(!1);else{const e=r.getRenderable();e&&t._renderableChildMap.delete(e),r.delete()}}t.children.length=e},e.createViewNode=e=>{if(!t.myFactory)return jt(&quot;Cannot create view nodes without my own factory&quot;),null;const n=t.myFactory.createNode(e);return n&&n.setRenderable(e),n};const n=e.delete;e.delete=()=>{for(let e=0;e<t.children.length;e++)t.children[e].delete();n()}}(e,t)}var qt={newInstance:Wt.newInstance($t,&quot;vtkViewNode&quot;),extend:$t,PASS_TYPES:[&quot;Build&quot;,&quot;Render&quot;]};const Xt={};function Yt(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Xt,n),Wt.obj(e,t),function(e,t){t.overrides||(t.overrides={}),t.classHierarchy.push(&quot;vtkViewNodeFactory&quot;),e.createNode=n=>{if(n.isDeleted())return null;let r=0,o=n.getClassName(r++),a=!1;const i=Object.keys(t.overrides);for(;o&&!a;)-1!==i.indexOf(o)?a=!0:o=n.getClassName(r++);if(!a)return null;const s=t.overrides[o]();return s.setMyFactory(e),s}}(e,t)}var Zt={newInstance:Wt.newInstance(Yt,&quot;vtkViewNodeFactory&quot;),extend:Yt};const Qt=Object.create(null);function Jt(e,t){Qt[e]=t}const en={};function tn(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,en,n),t.overrides=Qt,Zt.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLViewNodeFactory&quot;)}(0,t)}var nn={newInstance:Wt.newInstance(tn,&quot;vtkOpenGLViewNodeFactory&quot;),extend:tn};const rn={context:null,lastRenderer:null,keyMatrixTime:null,keyMatrices:null};const on=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,rn,n),qt.extend(e,t,n),t.keyMatrixTime={},ht(t.keyMatrixTime),t.keyMatrices={normalMatrix:new Float64Array(9),vcpc:new Float64Array(16),wcvc:new Float64Array(16),wcpc:new Float64Array(16)},Ct(e,t,[&quot;context&quot;,&quot;keyMatrixTime&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLCamera&quot;),e.buildPass=n=>{n&&(t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getParent(),t.context=t._openGLRenderWindow.getContext())},e.opaquePass=e=>{if(e){const e=t._openGLRenderer.getTiledSizeAndOrigin();t.context.viewport(e.lowerLeftU,e.lowerLeftV,e.usize,e.vsize),t.context.scissor(e.lowerLeftU,e.lowerLeftV,e.usize,e.vsize)}},e.translucentPass=e.opaquePass,e.zBufferPass=e.opaquePass,e.opaqueZBufferPass=e.opaquePass,e.volumePass=e.opaquePass,e.getKeyMatrices=n=>{if(n!==t.lastRenderer||t._openGLRenderWindow.getMTime()>t.keyMatrixTime.getMTime()||e.getMTime()>t.keyMatrixTime.getMTime()||n.getMTime()>t.keyMatrixTime.getMTime()||t.renderable.getMTime()>t.keyMatrixTime.getMTime()){p(t.keyMatrices.wcvc,t.renderable.getViewMatrix()),le(t.keyMatrices.normalMatrix,t.keyMatrices.wcvc),me(t.keyMatrices.normalMatrix,t.keyMatrices.normalMatrix),h(t.keyMatrices.wcvc,t.keyMatrices.wcvc);const e=t._openGLRenderer.getAspectRatio();p(t.keyMatrices.vcpc,t.renderable.getProjectionMatrix(e,-1,1)),h(t.keyMatrices.vcpc,t.keyMatrices.vcpc),b(t.keyMatrices.wcpc,t.keyMatrices.vcpc,t.keyMatrices.wcvc),t.keyMatrixTime.modified(),t.lastRenderer=n}return t.keyMatrices}}(e,t)}));Jt(&quot;vtkCamera&quot;,on);const{vtkDebugMacro:an}=Ht,sn={context:null,_openGLRenderWindow:null,selector:null};const ln=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,sn,n),qt.extend(e,t,n),Tt(e,t,[&quot;shaderCache&quot;]),Ct(e,t,[&quot;selector&quot;]),wt(0,t,[&quot;openGLRenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLRenderer&quot;),e.buildPass=n=>{if(n){if(!t.renderable)return;e.updateLights(),e.prepareNodes(),e.addMissingNode(t.renderable.getActiveCamera()),e.addMissingNodes(t.renderable.getViewPropsWithNestedProps(),!0),e.removeUnusedNodes()}},e.updateLights=()=>{let e=0;const n=t.renderable.getLightsByReference();for(let t=0;t<n.length;++t)n[t].getSwitch()>0&&e++;return e||(an(&quot;No lights are on, creating one.&quot;),t.renderable.createLight()),e},e.zBufferPass=n=>{if(n){let n=0;const r=t.context;t.renderable.getTransparent()||(t.context.clearColor(1,0,0,1),n|=r.COLOR_BUFFER_BIT),t.renderable.getPreserveDepthBuffer()||(r.clearDepth(1),n|=r.DEPTH_BUFFER_BIT,t.context.depthMask(!0));const o=e.getTiledSizeAndOrigin();r.enable(r.SCISSOR_TEST),r.scissor(o.lowerLeftU,o.lowerLeftV,o.usize,o.vsize),r.viewport(o.lowerLeftU,o.lowerLeftV,o.usize,o.vsize),r.colorMask(!0,!0,!0,!0),n&&r.clear(n),r.enable(r.DEPTH_TEST)}},e.opaqueZBufferPass=t=>e.zBufferPass(t),e.cameraPass=t=>{t&&e.clear()},e.getAspectRatio=()=>{const e=t._parent.getSizeByReference(),n=t.renderable.getViewportByReference();return e[0]*(n[2]-n[0])/((n[3]-n[1])*e[1])},e.getTiledSizeAndOrigin=()=>{const e=t.renderable.getViewportByReference(),n=[0,0,1,1],r=e[0]-n[0],o=e[1]-n[1],a=t._parent.normalizedDisplayToDisplay(r,o),i=Math.round(a[0]),s=Math.round(a[1]),l=e[2]-n[0],c=e[3]-n[1],u=t._parent.normalizedDisplayToDisplay(l,c);let d=Math.round(u[0])-i,p=Math.round(u[1])-s;return d<0&&(d=0),p<0&&(p=0),{usize:d,vsize:p,lowerLeftU:i,lowerLeftV:s}},e.clear=()=>{let n=0;const r=t.context;if(!t.renderable.getTransparent()){const e=t.renderable.getBackgroundByReference();r.clearColor(e[0],e[1],e[2],e[3]),n|=r.COLOR_BUFFER_BIT}t.renderable.getPreserveDepthBuffer()||(r.clearDepth(1),n|=r.DEPTH_BUFFER_BIT,r.depthMask(!0)),r.colorMask(!0,!0,!0,!0);const o=e.getTiledSizeAndOrigin();r.enable(r.SCISSOR_TEST),r.scissor(o.lowerLeftU,o.lowerLeftV,o.usize,o.vsize),r.viewport(o.lowerLeftU,o.lowerLeftV,o.usize,o.vsize),n&&r.clear(n),r.enable(r.DEPTH_TEST)},e.releaseGraphicsResources=()=>{null!==t.selector&&t.selector.releaseGraphicsResources(),t.renderable&&t.renderable.getViewProps().forEach((e=>{e.modified()}))},e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))}}(e,t)}),&quot;vtkOpenGLRenderer&quot;);Jt(&quot;vtkRenderer&quot;,ln);const cn={context:null,keyMatrixTime:null,keyMatrices:null,activeTextures:null};const un=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,cn,n),qt.extend(e,t,n),t.keyMatrixTime={},ht(t.keyMatrixTime,{mtime:0}),t.keyMatrices={normalMatrix:fe(new Float64Array(9)),mcwc:m(new Float64Array(16))},Ct(e,t,[&quot;context&quot;]),Tt(e,t,[&quot;activeTextures&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLActor&quot;),e.buildPass=n=>{if(n){t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t.context=t._openGLRenderWindow.getContext(),e.prepareNodes(),e.addMissingNodes(t.renderable.getTextures()),e.addMissingNode(t.renderable.getMapper()),e.removeUnusedNodes(),t.ogltextures=null,t.activeTextures=null;for(let e=0;e<t.children.length;e++){const n=t.children[e];n.isA(&quot;vtkOpenGLTexture&quot;)?(t.ogltextures||(t.ogltextures=[]),t.ogltextures.push(n)):t.oglmapper=n}}},e.traverseZBufferPass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.traverseOpaqueZBufferPass=t=>e.traverseOpaquePass(t),e.traverseOpaquePass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&t.renderable.getIsOpaque()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.traverseTranslucentPass=n=>{!t.renderable||!t.renderable.getNestedVisibility()||t.renderable.getIsOpaque()||t._openGLRenderer.getSelector()&&!t.renderable.getNestedPickable()||(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.activateTextures=()=>{if(t.ogltextures){t.activeTextures=[];for(let e=0;e<t.ogltextures.length;e++){const n=t.ogltextures[e];n.render(),n.getHandle()&&t.activeTextures.push(n)}}},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;t.renderable.getIsOpaque()?n.incrementOpaqueActorCount():n.incrementTranslucentActorCount()}},e.zBufferPass=(t,n)=>e.opaquePass(t,n),e.opaqueZBufferPass=(t,n)=>e.opaquePass(t,n),e.opaquePass=(n,r)=>{if(n)t.context.depthMask(!0),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()},e.translucentPass=(n,r)=>{if(n)t.context.depthMask(t._openGLRenderer.getSelector()&&t.renderable.getNestedPickable()),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()},e.getKeyMatrices=()=>(t.renderable.getMTime()>t.keyMatrixTime.getMTime()&&(t.renderable.computeMatrix(),p(t.keyMatrices.mcwc,t.renderable.getMatrix()),h(t.keyMatrices.mcwc,t.keyMatrices.mcwc),t.renderable.getIsIdentity()?fe(t.keyMatrices.normalMatrix):(le(t.keyMatrices.normalMatrix,t.keyMatrices.mcwc),me(t.keyMatrices.normalMatrix,t.keyMatrices.normalMatrix),ge(t.keyMatrices.normalMatrix,t.keyMatrices.normalMatrix)),t.keyMatrixTime.modified()),t.keyMatrices)}(e,t)}));Jt(&quot;vtkActor&quot;,un);const dn={context:null,activeTextures:null};const pn=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,dn,n),qt.extend(e,t,n),Ct(e,t,[&quot;context&quot;]),Tt(e,t,[&quot;activeTextures&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLActor2D&quot;),e.buildPass=n=>{if(n){if(!t.renderable)return;t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t.context=t._openGLRenderWindow.getContext(),e.prepareNodes(),e.addMissingNodes(t.renderable.getTextures()),e.addMissingNode(t.renderable.getMapper()),e.removeUnusedNodes(),t.ogltextures=null,t.activeTextures=null;for(let e=0;e<t.children.length;e++){const n=t.children[e];n.isA(&quot;vtkOpenGLTexture&quot;)?(t.ogltextures||(t.ogltextures=[]),t.ogltextures.push(n)):t.oglmapper=n}}},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;n.incrementOverlayActorCount()}},e.traverseOpaquePass=n=>{t.oglmapper&&t.renderable&&t.renderable.getNestedVisibility()&&t.renderable.getIsOpaque()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.traverseTranslucentPass=n=>{t.oglmapper&&t.renderable&&t.renderable.getNestedVisibility()&&!t.renderable.getIsOpaque()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.traverseOverlayPass=n=>{t.oglmapper&&t.renderable&&t.renderable.getNestedVisibility()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable)&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.activateTextures=()=>{if(t.ogltextures){t.activeTextures=[];for(let e=0;e<t.ogltextures.length;e++){const n=t.ogltextures[e];n.render(),n.getHandle()&&t.activeTextures.push(n)}}},e.opaquePass=(n,r)=>{if(n)t.context.depthMask(!0),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()},e.translucentPass=(n,r)=>{if(n)t.context.depthMask(!1),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()},e.overlayPass=(n,r)=>{if(n)t.context.depthMask(!0),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()}}(e,t)}));function fn(){var e=new s(3);return s!=Float32Array&&(e[0]=0,e[1]=0,e[2]=0),e}function gn(e){var t=e[0],n=e[1],r=e[2];return Math.hypot(t,n,r)}function mn(e,t,n){var r=new s(3);return r[0]=e,r[1]=t,r[2]=n,r}function hn(e,t,n,r){return e[0]=t,e[1]=n,e[2]=r,e}function vn(e,t,n){return e[0]=t[0]+n[0],e[1]=t[1]+n[1],e[2]=t[2]+n[2],e}function Tn(e,t,n){return e[0]=t[0]-n[0],e[1]=t[1]-n[1],e[2]=t[2]-n[2],e}function yn(e,t,n){return e[0]=t[0]*n[0],e[1]=t[1]*n[1],e[2]=t[2]*n[2],e}function bn(e,t,n){return e[0]=t[0]*n,e[1]=t[1]*n,e[2]=t[2]*n,e}function xn(e,t){return e[0]=1/t[0],e[1]=1/t[1],e[2]=1/t[2],e}function Cn(e,t){var n=t[0],r=t[1],o=t[2],a=n*n+r*r+o*o;return a>0&&(a=1/Math.sqrt(a)),e[0]=t[0]*a,e[1]=t[1]*a,e[2]=t[2]*a,e}function Sn(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function An(e,t,n){var r=t[0],o=t[1],a=t[2],i=n[0],s=n[1],l=n[2];return e[0]=o*l-a*s,e[1]=a*i-r*l,e[2]=r*s-o*i,e}function In(e,t,n){var r=t[0],o=t[1],a=t[2],i=n[3]*r+n[7]*o+n[11]*a+n[15];return i=i||1,e[0]=(n[0]*r+n[4]*o+n[8]*a+n[12])/i,e[1]=(n[1]*r+n[5]*o+n[9]*a+n[13])/i,e[2]=(n[2]*r+n[6]*o+n[10]*a+n[14])/i,e}function wn(e,t,n){var r=t[0],o=t[1],a=t[2];return e[0]=r*n[0]+o*n[3]+a*n[6],e[1]=r*n[1]+o*n[4]+a*n[7],e[2]=r*n[2]+o*n[5]+a*n[8],e}function On(e,t){return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]}function Pn(e,t){var n=e[0],r=e[1],o=e[2],a=t[0],s=t[1],l=t[2];return Math.abs(n-a)<=i*Math.max(1,Math.abs(n),Math.abs(a))&&Math.abs(r-s)<=i*Math.max(1,Math.abs(r),Math.abs(s))&&Math.abs(o-l)<=i*Math.max(1,Math.abs(o),Math.abs(l))}Jt(&quot;vtkActor2D&quot;,pn);var Rn=Tn,Mn=yn,En=(fn(),Math.sqrt(50)),Vn=Math.sqrt(10),Dn=Math.sqrt(2);function Ln(e,t,n){var r=(t-e)/Math.max(0,n),o=Math.floor(Math.log(r)/Math.LN10),a=r/Math.pow(10,o);return o>=0?(a>=En?10:a>=Vn?5:a>=Dn?2:1)*Math.pow(10,o):-Math.pow(10,-o)/(a>=En?10:a>=Vn?5:a>=Dn?2:1)}function Bn(e,t){return null==e||null==t?NaN:e<t?-1:e>t?1:e>=t?0:NaN}function Nn(e){let t=e,n=e,r=e;function o(e,t,o=0,a=e.length){if(o<a){if(0!==n(t,t))return a;do{const n=o+a>>>1;r(e[n],t)<0?o=n+1:a=n}while(o<a)}return o}return 1===e.length&&(t=(t,n)=>e(t)-n,n=Bn,r=(t,n)=>Bn(e(t),n)),{left:o,center:function(e,n,r=0,a=e.length){const i=o(e,n,r,a-1);return i>r&&t(e[i-1],n)>-t(e[i],n)?i-1:i},right:function(e,t,o=0,a=e.length){if(o<a){if(0!==n(t,t))return a;do{const n=o+a>>>1;r(e[n],t)<=0?o=n+1:a=n}while(o<a)}return o}}}const Fn=Nn(Bn),_n=Fn.right;Fn.left,Nn((function(e){return null===e?NaN:+e})).center;var kn=_n;function Gn(e,t,n){e.prototype=t.prototype=n,n.constructor=e}function Un(e,t){var n=Object.create(e.prototype);for(var r in t)n[r]=t[r];return n}function zn(){}var Wn=.7,Hn=1/Wn,jn=&quot;\\\\s*([+-]?\\\\d+)\\\\s*&quot;,Kn=&quot;\\\\s*([+-]?(?:\\\\d*\\\\.)?\\\\d+(?:[eE][+-]?\\\\d+)?)\\\\s*&quot;,$n=&quot;\\\\s*([+-]?(?:\\\\d*\\\\.)?\\\\d+(?:[eE][+-]?\\\\d+)?)%\\\\s*&quot;,qn=/^#([0-9a-f]{3,8})$/,Xn=new RegExp(`^rgb\\\\(${jn},${jn},${jn}\\\\)$`),Yn=new RegExp(`^rgb\\\\(${$n},${$n},${$n}\\\\)$`),Zn=new RegExp(`^rgba\\\\(${jn},${jn},${jn},${Kn}\\\\)$`),Qn=new RegExp(`^rgba\\\\(${$n},${$n},${$n},${Kn}\\\\)$`),Jn=new RegExp(`^hsl\\\\(${Kn},${$n},${$n}\\\\)$`),er=new RegExp(`^hsla\\\\(${Kn},${$n},${$n},${Kn}\\\\)$`),tr={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function nr(){return this.rgb().formatHex()}function rr(){return this.rgb().formatRgb()}function or(e){var t,n;return e=(e+&quot;&quot;).trim().toLowerCase(),(t=qn.exec(e))?(n=t[1].length,t=parseInt(t[1],16),6===n?ar(t):3===n?new lr(t>>8&15|t>>4&240,t>>4&15|240&t,(15&t)<<4|15&t,1):8===n?ir(t>>24&255,t>>16&255,t>>8&255,(255&t)/255):4===n?ir(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|240&t,((15&t)<<4|15&t)/255):null):(t=Xn.exec(e))?new lr(t[1],t[2],t[3],1):(t=Yn.exec(e))?new lr(255*t[1]/100,255*t[2]/100,255*t[3]/100,1):(t=Zn.exec(e))?ir(t[1],t[2],t[3],t[4]):(t=Qn.exec(e))?ir(255*t[1]/100,255*t[2]/100,255*t[3]/100,t[4]):(t=Jn.exec(e))?gr(t[1],t[2]/100,t[3]/100,1):(t=er.exec(e))?gr(t[1],t[2]/100,t[3]/100,t[4]):tr.hasOwnProperty(e)?ar(tr[e]):&quot;transparent&quot;===e?new lr(NaN,NaN,NaN,0):null}function ar(e){return new lr(e>>16&255,e>>8&255,255&e,1)}function ir(e,t,n,r){return r<=0&&(e=t=n=NaN),new lr(e,t,n,r)}function sr(e,t,n,r){return 1===arguments.length?((o=e)instanceof zn||(o=or(o)),o?new lr((o=o.rgb()).r,o.g,o.b,o.opacity):new lr):new lr(e,t,n,null==r?1:r);var o}function lr(e,t,n,r){this.r=+e,this.g=+t,this.b=+n,this.opacity=+r}function cr(){return`#${fr(this.r)}${fr(this.g)}${fr(this.b)}`}function ur(){const e=dr(this.opacity);return`${1===e?&quot;rgb(&quot;:&quot;rgba(&quot;}${pr(this.r)}, ${pr(this.g)}, ${pr(this.b)}${1===e?&quot;)&quot;:`, ${e})`}`}function dr(e){return isNaN(e)?1:Math.max(0,Math.min(1,e))}function pr(e){return Math.max(0,Math.min(255,Math.round(e)||0))}function fr(e){return((e=pr(e))<16?&quot;0&quot;:&quot;&quot;)+e.toString(16)}function gr(e,t,n,r){return r<=0?e=t=n=NaN:n<=0||n>=1?e=t=NaN:t<=0&&(e=NaN),new hr(e,t,n,r)}function mr(e){if(e instanceof hr)return new hr(e.h,e.s,e.l,e.opacity);if(e instanceof zn||(e=or(e)),!e)return new hr;if(e instanceof hr)return e;var t=(e=e.rgb()).r/255,n=e.g/255,r=e.b/255,o=Math.min(t,n,r),a=Math.max(t,n,r),i=NaN,s=a-o,l=(a+o)/2;return s?(i=t===a?(n-r)/s+6*(n<r):n===a?(r-t)/s+2:(t-n)/s+4,s/=l<.5?a+o:2-a-o,i*=60):s=l>0&&l<1?0:i,new hr(i,s,l,e.opacity)}function hr(e,t,n,r){this.h=+e,this.s=+t,this.l=+n,this.opacity=+r}function vr(e){return(e=(e||0)%360)<0?e+360:e}function Tr(e){return Math.max(0,Math.min(1,e||0))}function yr(e,t,n){return 255*(e<60?t+(n-t)*e/60:e<180?n:e<240?t+(n-t)*(240-e)/60:t)}function br(e,t,n,r,o){var a=e*e,i=a*e;return((1-3*e+3*a-i)*t+(4-6*a+3*i)*n+(1+3*e+3*a-3*i)*r+i*o)/6}Gn(zn,or,{copy(e){return Object.assign(new this.constructor,this,e)},displayable(){return this.rgb().displayable()},hex:nr,formatHex:nr,formatHex8:function(){return this.rgb().formatHex8()},formatHsl:function(){return mr(this).formatHsl()},formatRgb:rr,toString:rr}),Gn(lr,sr,Un(zn,{brighter(e){return e=null==e?Hn:Math.pow(Hn,e),new lr(this.r*e,this.g*e,this.b*e,this.opacity)},darker(e){return e=null==e?Wn:Math.pow(Wn,e),new lr(this.r*e,this.g*e,this.b*e,this.opacity)},rgb(){return this},clamp(){return new lr(pr(this.r),pr(this.g),pr(this.b),dr(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:cr,formatHex:cr,formatHex8:function(){return`#${fr(this.r)}${fr(this.g)}${fr(this.b)}${fr(255*(isNaN(this.opacity)?1:this.opacity))}`},formatRgb:ur,toString:ur})),Gn(hr,(function(e,t,n,r){return 1===arguments.length?mr(e):new hr(e,t,n,null==r?1:r)}),Un(zn,{brighter(e){return e=null==e?Hn:Math.pow(Hn,e),new hr(this.h,this.s,this.l*e,this.opacity)},darker(e){return e=null==e?Wn:Math.pow(Wn,e),new hr(this.h,this.s,this.l*e,this.opacity)},rgb(){var e=this.h%360+360*(this.h<0),t=isNaN(e)||isNaN(this.s)?0:this.s,n=this.l,r=n+(n<.5?n:1-n)*t,o=2*n-r;return new lr(yr(e>=240?e-240:e+120,o,r),yr(e,o,r),yr(e<120?e+240:e-120,o,r),this.opacity)},clamp(){return new hr(vr(this.h),Tr(this.s),Tr(this.l),dr(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){const e=dr(this.opacity);return`${1===e?&quot;hsl(&quot;:&quot;hsla(&quot;}${vr(this.h)}, ${100*Tr(this.s)}%, ${100*Tr(this.l)}%${1===e?&quot;)&quot;:`, ${e})`}`}}));var xr=e=>()=>e;function Cr(e,t){var n=t-e;return n?function(e,t){return function(n){return e+n*t}}(e,n):xr(isNaN(e)?t:e)}var Sr=function e(t){var n=function(e){return 1==(e=+e)?Cr:function(t,n){return n-t?function(e,t,n){return e=Math.pow(e,n),t=Math.pow(t,n)-e,n=1/n,function(r){return Math.pow(e+r*t,n)}}(t,n,e):xr(isNaN(t)?n:t)}}(t);function r(e,t){var r=n((e=sr(e)).r,(t=sr(t)).r),o=n(e.g,t.g),a=n(e.b,t.b),i=Cr(e.opacity,t.opacity);return function(t){return e.r=r(t),e.g=o(t),e.b=a(t),e.opacity=i(t),e+&quot;&quot;}}return r.gamma=e,r}(1);function Ar(e){return function(t){var n,r,o=t.length,a=new Array(o),i=new Array(o),s=new Array(o);for(n=0;n<o;++n)r=sr(t[n]),a[n]=r.r||0,i[n]=r.g||0,s[n]=r.b||0;return a=e(a),i=e(i),s=e(s),r.opacity=1,function(e){return r.r=a(e),r.g=i(e),r.b=s(e),r+&quot;&quot;}}}function Ir(e,t){var n,r=t?t.length:0,o=e?Math.min(r,e.length):0,a=new Array(o),i=new Array(r);for(n=0;n<o;++n)a[n]=Dr(e[n],t[n]);for(;n<r;++n)i[n]=t[n];return function(e){for(n=0;n<o;++n)i[n]=a[n](e);return i}}function wr(e,t){var n=new Date;return e=+e,t=+t,function(r){return n.setTime(e*(1-r)+t*r),n}}function Or(e,t){return e=+e,t=+t,function(n){return e*(1-n)+t*n}}function Pr(e,t){var n,r={},o={};for(n in null!==e&&&quot;object&quot;==typeof e||(e={}),null!==t&&&quot;object&quot;==typeof t||(t={}),t)n in e?r[n]=Dr(e[n],t[n]):o[n]=t[n];return function(e){for(n in r)o[n]=r[n](e);return o}}Ar((function(e){var t=e.length-1;return function(n){var r=n<=0?n=0:n>=1?(n=1,t-1):Math.floor(n*t),o=e[r],a=e[r+1],i=r>0?e[r-1]:2*o-a,s=r<t-1?e[r+2]:2*a-o;return br((n-r/t)*t,i,o,a,s)}})),Ar((function(e){var t=e.length;return function(n){var r=Math.floor(((n%=1)<0?++n:n)*t),o=e[(r+t-1)%t],a=e[r%t],i=e[(r+1)%t],s=e[(r+2)%t];return br((n-r/t)*t,o,a,i,s)}}));var Rr=/[-+]?(?:\\d+\\.?\\d*|\\.?\\d+)(?:[eE][-+]?\\d+)?/g,Mr=new RegExp(Rr.source,&quot;g&quot;);function Er(e,t){var n,r,o,a=Rr.lastIndex=Mr.lastIndex=0,i=-1,s=[],l=[];for(e+=&quot;&quot;,t+=&quot;&quot;;(n=Rr.exec(e))&&(r=Mr.exec(t));)(o=r.index)>a&&(o=t.slice(a,o),s[i]?s[i]+=o:s[++i]=o),(n=n[0])===(r=r[0])?s[i]?s[i]+=r:s[++i]=r:(s[++i]=null,l.push({i:i,x:Or(n,r)})),a=Mr.lastIndex;return a<t.length&&(o=t.slice(a),s[i]?s[i]+=o:s[++i]=o),s.length<2?l[0]?function(e){return function(t){return e(t)+&quot;&quot;}}(l[0].x):function(e){return function(){return e}}(t):(t=l.length,function(e){for(var n,r=0;r<t;++r)s[(n=l[r]).i]=n.x(e);return s.join(&quot;&quot;)})}function Vr(e,t){t||(t=[]);var n,r=e?Math.min(t.length,e.length):0,o=t.slice();return function(a){for(n=0;n<r;++n)o[n]=e[n]*(1-a)+t[n]*a;return o}}function Dr(e,t){var n,r=typeof t;return null==t||&quot;boolean&quot;===r?xr(t):(&quot;number&quot;===r?Or:&quot;string&quot;===r?(n=or(t))?(t=n,Sr):Er:t instanceof or?Sr:t instanceof Date?wr:function(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}(t)?Vr:Array.isArray(t)?Ir:&quot;function&quot;!=typeof t.valueOf&&&quot;function&quot;!=typeof t.toString||isNaN(t)?Pr:Or)(e,t)}function Lr(e,t){return e=+e,t=+t,function(n){return Math.round(e*(1-n)+t*n)}}function Br(e){return+e}var Nr=[0,1];function Fr(e){return e}function _r(e,t){return(t-=e=+e)?function(n){return(n-e)/t}:function(e){return function(){return e}}(isNaN(t)?NaN:.5)}function kr(e,t,n){var r=e[0],o=e[1],a=t[0],i=t[1];return o<r?(r=_r(o,r),a=n(i,a)):(r=_r(r,o),a=n(a,i)),function(e){return a(r(e))}}function Gr(e,t,n){var r=Math.min(e.length,t.length)-1,o=new Array(r),a=new Array(r),i=-1;for(e[r]<e[0]&&(e=e.slice().reverse(),t=t.slice().reverse());++i<r;)o[i]=_r(e[i],e[i+1]),a[i]=n(t[i],t[i+1]);return function(t){var n=kn(e,t,1,r)-1;return a[n](o[n](t))}}function Ur(e,t){switch(arguments.length){case 0:break;case 1:this.range(e);break;default:this.range(t).domain(e)}return this}var zr,Wr=/^(?:(.)?([<>=^]))?([+\\-( ])?([$#])?(0)?(\\d+)?(,)?(\\.\\d+)?(~)?([a-z%])?$/i;function Hr(e){if(!(t=Wr.exec(e)))throw new Error(&quot;invalid format: &quot;+e);var t;return new jr({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}function jr(e){this.fill=void 0===e.fill?&quot; &quot;:e.fill+&quot;&quot;,this.align=void 0===e.align?&quot;>&quot;:e.align+&quot;&quot;,this.sign=void 0===e.sign?&quot;-&quot;:e.sign+&quot;&quot;,this.symbol=void 0===e.symbol?&quot;&quot;:e.symbol+&quot;&quot;,this.zero=!!e.zero,this.width=void 0===e.width?void 0:+e.width,this.comma=!!e.comma,this.precision=void 0===e.precision?void 0:+e.precision,this.trim=!!e.trim,this.type=void 0===e.type?&quot;&quot;:e.type+&quot;&quot;}function Kr(e,t){if((n=(e=t?e.toExponential(t-1):e.toExponential()).indexOf(&quot;e&quot;))<0)return null;var n,r=e.slice(0,n);return[r.length>1?r[0]+r.slice(2):r,+e.slice(n+1)]}function $r(e){return(e=Kr(Math.abs(e)))?e[1]:NaN}function qr(e,t){var n=Kr(e,t);if(!n)return e+&quot;&quot;;var r=n[0],o=n[1];return o<0?&quot;0.&quot;+new Array(-o).join(&quot;0&quot;)+r:r.length>o+1?r.slice(0,o+1)+&quot;.&quot;+r.slice(o+1):r+new Array(o-r.length+2).join(&quot;0&quot;)}Hr.prototype=jr.prototype,jr.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?&quot;0&quot;:&quot;&quot;)+(void 0===this.width?&quot;&quot;:Math.max(1,0|this.width))+(this.comma?&quot;,&quot;:&quot;&quot;)+(void 0===this.precision?&quot;&quot;:&quot;.&quot;+Math.max(0,0|this.precision))+(this.trim?&quot;~&quot;:&quot;&quot;)+this.type};var Xr={&quot;%&quot;:(e,t)=>(100*e).toFixed(t),b:e=>Math.round(e).toString(2),c:e=>e+&quot;&quot;,d:function(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString(&quot;en&quot;).replace(/,/g,&quot;&quot;):e.toString(10)},e:(e,t)=>e.toExponential(t),f:(e,t)=>e.toFixed(t),g:(e,t)=>e.toPrecision(t),o:e=>Math.round(e).toString(8),p:(e,t)=>qr(100*e,t),r:qr,s:function(e,t){var n=Kr(e,t);if(!n)return e+&quot;&quot;;var r=n[0],o=n[1],a=o-(zr=3*Math.max(-8,Math.min(8,Math.floor(o/3))))+1,i=r.length;return a===i?r:a>i?r+new Array(a-i+1).join(&quot;0&quot;):a>0?r.slice(0,a)+&quot;.&quot;+r.slice(a):&quot;0.&quot;+new Array(1-a).join(&quot;0&quot;)+Kr(e,Math.max(0,t+a-1))[0]},X:e=>Math.round(e).toString(16).toUpperCase(),x:e=>Math.round(e).toString(16)};function Yr(e){return e}var Zr,Qr,Jr,eo=Array.prototype.map,to=[&quot;y&quot;,&quot;z&quot;,&quot;a&quot;,&quot;f&quot;,&quot;p&quot;,&quot;n&quot;,&quot;µ&quot;,&quot;m&quot;,&quot;&quot;,&quot;k&quot;,&quot;M&quot;,&quot;G&quot;,&quot;T&quot;,&quot;P&quot;,&quot;E&quot;,&quot;Z&quot;,&quot;Y&quot;];function no(e){var t=e.domain;return e.ticks=function(e){var n=t();return function(e,t,n){var r,o,a,i,s=-1;if(n=+n,(e=+e)==(t=+t)&&n>0)return[e];if((r=t<e)&&(o=e,e=t,t=o),0===(i=Ln(e,t,n))||!isFinite(i))return[];if(i>0){let n=Math.round(e/i),r=Math.round(t/i);for(n*i<e&&++n,r*i>t&&--r,a=new Array(o=r-n+1);++s<o;)a[s]=(n+s)*i}else{i=-i;let n=Math.round(e*i),r=Math.round(t*i);for(n/i<e&&++n,r/i>t&&--r,a=new Array(o=r-n+1);++s<o;)a[s]=(n+s)/i}return r&&a.reverse(),a}(n[0],n[n.length-1],null==e?10:e)},e.tickFormat=function(e,n){var r=t();return function(e,t,n,r){var o,a=function(e,t,n){var r=Math.abs(t-e)/Math.max(0,n),o=Math.pow(10,Math.floor(Math.log(r)/Math.LN10)),a=r/o;return a>=En?o*=10:a>=Vn?o*=5:a>=Dn&&(o*=2),t<e?-o:o}(e,t,n);switch((r=Hr(null==r?&quot;,f&quot;:r)).type){case&quot;s&quot;:var i=Math.max(Math.abs(e),Math.abs(t));return null!=r.precision||isNaN(o=function(e,t){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor($r(t)/3)))-$r(Math.abs(e)))}(a,i))||(r.precision=o),Jr(r,i);case&quot;&quot;:case&quot;e&quot;:case&quot;g&quot;:case&quot;p&quot;:case&quot;r&quot;:null!=r.precision||isNaN(o=function(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,$r(t)-$r(e))+1}(a,Math.max(Math.abs(e),Math.abs(t))))||(r.precision=o-(&quot;e&quot;===r.type));break;case&quot;f&quot;:case&quot;%&quot;:null!=r.precision||isNaN(o=function(e){return Math.max(0,-$r(Math.abs(e)))}(a))||(r.precision=o-2*(&quot;%&quot;===r.type))}return Qr(r)}(r[0],r[r.length-1],null==e?10:e,n)},e.nice=function(n){null==n&&(n=10);var r,o,a=t(),i=0,s=a.length-1,l=a[i],c=a[s],u=10;for(c<l&&(o=l,l=c,c=o,o=i,i=s,s=o);u-- >0;){if((o=Ln(l,c,n))===r)return a[i]=l,a[s]=c,t(a);if(o>0)l=Math.floor(l/o)*o,c=Math.ceil(c/o)*o;else{if(!(o<0))break;l=Math.ceil(l*o)/o,c=Math.floor(c*o)/o}r=o}return e},e}function ro(){var e=function(){var e,t,n,r,o,a,i=Nr,s=Nr,l=Dr,c=Fr;function u(){var e,t,n,l=Math.min(i.length,s.length);return c!==Fr&&(e=i[0],t=i[l-1],e>t&&(n=e,e=t,t=n),c=function(n){return Math.max(e,Math.min(t,n))}),r=l>2?Gr:kr,o=a=null,d}function d(t){return null==t||isNaN(t=+t)?n:(o||(o=r(i.map(e),s,l)))(e(c(t)))}return d.invert=function(n){return c(t((a||(a=r(s,i.map(e),Or)))(n)))},d.domain=function(e){return arguments.length?(i=Array.from(e,Br),u()):i.slice()},d.range=function(e){return arguments.length?(s=Array.from(e),u()):s.slice()},d.rangeRound=function(e){return s=Array.from(e),l=Lr,u()},d.clamp=function(e){return arguments.length?(c=!!e||Fr,u()):c!==Fr},d.interpolate=function(e){return arguments.length?(l=e,u()):l},d.unknown=function(e){return arguments.length?(n=e,d):n},function(n,r){return e=n,t=r,u()}}()(Fr,Fr);return e.copy=function(){return t=e,ro().domain(t.domain()).range(t.range()).interpolate(t.interpolate()).clamp(t.clamp()).unknown(t.unknown());var t},Ur.apply(e,arguments),no(e)}Zr=function(e){var t,n,r=void 0===e.grouping||void 0===e.thousands?Yr:(t=eo.call(e.grouping,Number),n=e.thousands+&quot;&quot;,function(e,r){for(var o=e.length,a=[],i=0,s=t[0],l=0;o>0&&s>0&&(l+s+1>r&&(s=Math.max(1,r-l)),a.push(e.substring(o-=s,o+s)),!((l+=s+1)>r));)s=t[i=(i+1)%t.length];return a.reverse().join(n)}),o=void 0===e.currency?&quot;&quot;:e.currency[0]+&quot;&quot;,a=void 0===e.currency?&quot;&quot;:e.currency[1]+&quot;&quot;,i=void 0===e.decimal?&quot;.&quot;:e.decimal+&quot;&quot;,s=void 0===e.numerals?Yr:function(e){return function(t){return t.replace(/[0-9]/g,(function(t){return e[+t]}))}}(eo.call(e.numerals,String)),l=void 0===e.percent?&quot;%&quot;:e.percent+&quot;&quot;,c=void 0===e.minus?&quot;−&quot;:e.minus+&quot;&quot;,u=void 0===e.nan?&quot;NaN&quot;:e.nan+&quot;&quot;;function d(e){var t=(e=Hr(e)).fill,n=e.align,d=e.sign,p=e.symbol,f=e.zero,g=e.width,m=e.comma,h=e.precision,v=e.trim,T=e.type;&quot;n&quot;===T?(m=!0,T=&quot;g&quot;):Xr[T]||(void 0===h&&(h=12),v=!0,T=&quot;g&quot;),(f||&quot;0&quot;===t&&&quot;=&quot;===n)&&(f=!0,t=&quot;0&quot;,n=&quot;=&quot;);var y=&quot;$&quot;===p?o:&quot;#&quot;===p&&/[boxX]/.test(T)?&quot;0&quot;+T.toLowerCase():&quot;&quot;,b=&quot;$&quot;===p?a:/[%p]/.test(T)?l:&quot;&quot;,x=Xr[T],C=/[defgprs%]/.test(T);function S(e){var o,a,l,p=y,S=b;if(&quot;c&quot;===T)S=x(e)+S,e=&quot;&quot;;else{var A=(e=+e)<0||1/e<0;if(e=isNaN(e)?u:x(Math.abs(e),h),v&&(e=function(e){e:for(var t,n=e.length,r=1,o=-1;r<n;++r)switch(e[r]){case&quot;.&quot;:o=t=r;break;case&quot;0&quot;:0===o&&(o=r),t=r;break;default:if(!+e[r])break e;o>0&&(o=0)}return o>0?e.slice(0,o)+e.slice(t+1):e}(e)),A&&0==+e&&&quot;+&quot;!==d&&(A=!1),p=(A?&quot;(&quot;===d?d:c:&quot;-&quot;===d||&quot;(&quot;===d?&quot;&quot;:d)+p,S=(&quot;s&quot;===T?to[8+zr/3]:&quot;&quot;)+S+(A&&&quot;(&quot;===d?&quot;)&quot;:&quot;&quot;),C)for(o=-1,a=e.length;++o<a;)if(48>(l=e.charCodeAt(o))||l>57){S=(46===l?i+e.slice(o+1):e.slice(o))+S,e=e.slice(0,o);break}}m&&!f&&(e=r(e,1/0));var I=p.length+e.length+S.length,w=I<g?new Array(g-I+1).join(t):&quot;&quot;;switch(m&&f&&(e=r(w+e,w.length?g-S.length:1/0),w=&quot;&quot;),n){case&quot;<&quot;:e=p+e+S+w;break;case&quot;=&quot;:e=p+w+e+S;break;case&quot;^&quot;:e=w.slice(0,I=w.length>>1)+p+e+S+w.slice(I);break;default:e=w+p+e+S}return s(e)}return h=void 0===h?6:/[gprs]/.test(T)?Math.max(1,Math.min(21,h)):Math.max(0,Math.min(20,h)),S.toString=function(){return e+&quot;&quot;},S}return{format:d,formatPrefix:function(e,t){var n=d(((e=Hr(e)).type=&quot;f&quot;,e)),r=3*Math.max(-8,Math.min(8,Math.floor($r(t)/3))),o=Math.pow(10,-r),a=to[8+r/3];return function(e){return n(o*e)+a}}}}({thousands:&quot;,&quot;,grouping:[3],currency:[&quot;$&quot;,&quot;&quot;]}),Qr=Zr.format,Jr=Zr.formatPrefix;var oo=n(318);const ao=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],io=[1,0,0,0,1,0,0,0,1],so=1e-6,lo=1e-12,{vtkErrorMacro:co,vtkWarningMacro:uo}=Wt;let po=0;function fo(e){return()=>co(`vtkMath::${e} - NOT IMPLEMENTED`)}function go(e,t,n,r){let o;for(let a=0;a<t;a++)o=e[n*t+a],e[n*t+a]=e[r*t+a],e[r*t+a]=o}function mo(e,t,n,r){let o;for(let a=0;a<t;a++)o=e[a*t+n],e[a*t+n]=e[a*t+r],e[a*t+r]=o}function ho(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:3;const t=Array(e);for(let n=0;n<e;++n)t[n]=0;return t}function vo(e){return e/180*Math.PI}function To(e){return 180*e/Math.PI}const{round:yo,floor:bo,ceil:xo,min:Co,max:So}=Math;const Ao=fo(&quot;ceilLog2&quot;),Io=fo(&quot;factorial&quot;);function wo(e){let t=1;for(;t<e;)t*=2;return t}function Oo(e){return e===wo(e)}const Po=fo(&quot;gaussian&quot;);function Ro(e,t,n){return n[0]=e[0]+t[0],n[1]=e[1]+t[1],n[2]=e[2]+t[2],n}function Mo(e,t,n){return n[0]=e[0]-t[0],n[1]=e[1]-t[1],n[2]=e[2]-t[2],n}function Eo(e,t){return e[0]*=t,e[1]*=t,e[2]*=t,e}function Vo(e,t){return e[0]*=t,e[1]*=t,e}function Do(e,t,n,r){return r[0]=e[0]+t[0]*n,r[1]=e[1]+t[1]*n,r[2]=e[2]+t[2]*n,r}function Lo(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function Bo(e,t,n){const r=e[1]*t[2]-e[2]*t[1],o=e[2]*t[0]-e[0]*t[2],a=e[0]*t[1]-e[1]*t[0];return n[0]=r,n[1]=o,n[2]=a,n}function No(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:3;switch(t){case 1:return Math.abs(e);case 2:return Math.sqrt(e[0]*e[0]+e[1]*e[1]);case 3:return Math.sqrt(e[0]*e[0]+e[1]*e[1]+e[2]*e[2]);default:{let n=0;for(let r=0;r<t;r++)n+=e[r]*e[r];return Math.sqrt(n)}}}function Fo(e){const t=No(e);return 0!==t&&(e[0]/=t,e[1]/=t,e[2]/=t),t}function _o(e){const t=No(e,3);return 0!==t&&(e[0]/=t,e[1]/=t,e[2]/=t,e[3]/=t),t}function ko(e,t){return e[0]*t[0]+e[1]*t[1]}function Go(e,t){return(e[0]-t[0])*(e[0]-t[0])+(e[1]-t[1])*(e[1]-t[1])+(e[2]-t[2])*(e[2]-t[2])}function Uo(e){return Math.sqrt(e[0]*e[0]+e[1]*e[1])}function zo(e){const t=Uo(e);return 0!==t&&(e[0]/=t,e[1]/=t),t}function Wo(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return 2===t.length?t[0][0]*t[1][1]-t[1][0]*t[0][1]:4===t.length?t[0]*t[3]-t[1]*t[2]:Number.NaN}function Ho(e,t,n){const r=e[0]*t[0]+e[1]*t[1]+e[2]*t[2],o=e[3]*t[0]+e[4]*t[1]+e[5]*t[2],a=e[6]*t[0]+e[7]*t[1]+e[8]*t[2];n[0]=r,n[1]=o,n[2]=a}function jo(e,t,n){const r=[...e],o=[...t];for(let e=0;e<3;e++)n[e]=r[0]*o[e]+r[1]*o[e+3]+r[2]*o[e+6],n[e+3]=r[3]*o[e]+r[4]*o[e+3]+r[5]*o[e+6],n[e+6]=r[6]*o[e]+r[7]*o[e+3]+r[8]*o[e+6]}function Ko(e,t){let n;n=e[3],t[3]=e[1],t[1]=n,n=e[6],t[6]=e[2],t[2]=n,n=e[7],t[7]=e[5],t[5]=n,t[0]=e[0],t[4]=e[4],t[8]=e[8]}function $o(e){return e[0]*e[4]*e[8]+e[3]*e[7]*e[2]+e[6]*e[1]*e[5]-e[0]*e[7]*e[5]-e[3]*e[1]*e[8]-e[6]*e[4]*e[2]}function qo(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:so;return e.length===t.length&&e.every((function(e,r){return Math.abs(e-t[r])<=n}))}const Xo=qo;function Yo(e){for(let t=0;t<3;t++)e[3*t]=e[3*t+1]=e[3*t+2]=0,e[3*t+t]=1}function Zo(e,t){for(let n=0;n<e;n++){for(let r=0;r<e;r++)t[n*e+r]=0;t[n*e+n]=1}return t}function Qo(e,t){const n=e[0]*e[0],r=e[0]*e[1],o=e[0]*e[2],a=e[0]*e[3],i=e[1]*e[1],s=e[2]*e[2],l=e[3]*e[3],c=e[1]*e[2],u=e[1]*e[3],d=e[2]*e[3],p=i+s+l;let f=1/(n+p);const g=(n-p)*f;f*=2,t[0]=i*f+g,t[3]=(c+a)*f,t[6]=(u-o)*f,t[1]=(c-a)*f,t[4]=s*f+g,t[7]=(d+r)*f,t[2]=(u+o)*f,t[5]=(d-r)*f,t[8]=l*f+g}function Jo(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;if(!`${e}`.includes(&quot;e&quot;))return+`${Math.round(`${e}e+${t}`)}e-${t}`;const n=`${e}`.split(&quot;e&quot;);let r=&quot;&quot;;return+n[1]+t>0&&(r=&quot;+&quot;),+`${Math.round(`${+n[0]}e${r}${+n[1]+t}`)}e-${t}`}function ea(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[0,0,0],n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:0;return t[0]=Jo(e[0],n),t[1]=Jo(e[1],n),t[2]=Jo(e[2],n),t}function ta(e,t,n,r){let o,a,i,s,l,c,u,d,p,f,g,m,h,v,T,y;const b=ho(t),x=ho(t),C=(e,t,n)=>{v=e[t],h=e[n],e[t]=v-m*(h+v*f),e[n]=h+m*(v-h*f)};for(Zo(t,r),l=0;l<t;l++)b[l]=n[l]=e[l+l*t],x[l]=0;for(o=0;o<20;o++){for(g=0,l=0;l<t-1;l++)for(s=l+1;s<t;s++)g+=Math.abs(e[l*t+s]);if(0===g)break;for(u=o<3?.2*g/(t*t):0,l=0;l<t-1;l++)for(s=l+1;s<t;s++)if(v=100*Math.abs(e[l*t+s]),o>3&&Math.abs(n[l])+v===Math.abs(n[l])&&Math.abs(n[s])+v===Math.abs(n[s]))e[l*t+s]=0;else if(Math.abs(e[l*t+s])>u){for(h=n[s]-n[l],Math.abs(h)+v===Math.abs(h)?p=e[l*t+s]/h:(d=.5*h/e[l*t+s],p=1/(Math.abs(d)+Math.sqrt(1+d*d)),d<0&&(p=-p)),T=1/Math.sqrt(1+p*p),m=p*T,f=m/(1+T),h=p*e[l*t+s],x[l]-=h,x[s]+=h,n[l]-=h,n[s]+=h,e[l*t+s]=0,a=0;a<=l-1;a++)C(e,a*t+l,a*t+s);for(a=l+1;a<=s-1;a++)C(e,l*t+a,a*t+s);for(a=s+1;a<t;a++)C(e,l*t+a,s*t+a);for(a=0;a<t;a++)C(r,a*t+l,a*t+s)}for(l=0;l<t;l++)b[l]+=x[l],n[l]=b[l],x[l]=0}if(o>=20)return uo(&quot;vtkMath::Jacobi: Error extracting eigenfunctions&quot;),0;for(a=0;a<t-1;a++){for(i=a,y=n[i],o=a+1;o<t;o++)(n[o]>=y||Math.abs(n[o]-y)<lo)&&(i=o,y=n[i]);i!==a&&(n[i]=n[a],n[a]=y,mo(r,t,a,i))}const S=(t>>1)+(1&t);for(c=0,o=0;o<t*t;o++)r[o]>=0&&c++;if(c<S)for(o=0;o<t;o++)r[o*t+a]*=-1;return 1}function na(e,t){const n=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];n[0]=e[0]+e[4]+e[8],n[5]=e[0]-e[4]-e[8],n[10]=-e[0]+e[4]-e[8],n[15]=-e[0]-e[4]+e[8],n[1]=n[4]=e[7]-e[5],n[2]=n[8]=e[2]-e[6],n[3]=n[12]=e[3]-e[1],n[6]=n[9]=e[3]+e[1],n[7]=n[13]=e[2]+e[6],n[11]=n[14]=e[7]+e[5];const r=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];ta([...n],4,[0,0,0,0],r),t[0]=r[0],t[1]=r[4],t[2]=r[8],t[3]=r[12]}function ra(e,t){for(let n=0;n<9;n++)t[n]=e[n];const n=ho(3),r=ho(3);let o;for(let e=0;e<3;e++){const r=Math.abs(t[3*e]),a=Math.abs(t[3*e+1]),i=Math.abs(t[3*e+2]);o=a>r?a:r,o=i>o?i:o,n[e]=1,0!==o&&(n[e]/=o)}const a=Math.abs(t[0])*n[0],i=Math.abs(t[3])*n[1],s=Math.abs(t[6])*n[2];r[0]=0,o=a,i>=o&&(o=i,r[0]=1),s>=o&&(r[0]=2),0!==r[0]&&(mo(t,3,r[0],0),n[r[0]]=n[0]);const l=Math.abs(t[4])*n[1],c=Math.abs(t[7])*n[2];r[1]=1,o=l,c>=o&&(r[1]=2,mo(t,3,1,2)),r[2]=2;let u=0;if($o(t)<0){u=1;for(let e=0;e<9;e++)t[e]=-t[e]}const d=ho(4);if(na(t,d),Qo(d,t),u)for(let e=0;e<9;e++)t[e]=-t[e];1!==r[1]&&mo(t,3,r[1],1),0!==r[0]&&mo(t,3,r[0],0)}function oa(e,t,n){let r,o,a,i,s,l;if(ta([...e],3,t,n),t[0]!==t[1]||t[0]!==t[2]){for(Ko(n,n),r=0;r<3;r++)if(t[(r+1)%3]===t[(r+2)%3]){for(l=Math.abs(n[3*r]),i=0,o=1;o<3;o++)l<(s=Math.abs(n[3*r+o]))&&(l=s,i=o);i!==r&&(s=t[i],t[i]=t[r],t[r]=s,go(n,3,r,i)),n[3*i+i]<0&&(n[3*i]=-n[3*i],n[3*i+1]=-n[3*i+1],n[3*i+2]=-n[3*i+2]),o=(i+1)%3,a=(i+2)%3,n[3*o]=0,n[3*o+1]=0,n[3*o+2]=0,n[3*o+o]=1;const e=Bo([n[3*i],n[3*i+1],n[3*i+2]],[n[3*o],n[3*o+1],n[3*o+2]],[]);Fo(e);const c=Bo(e,[n[3*i],n[3*i+1],n[3*i+2]],[]);for(let t=0;t<3;t++)n[3*a+t]=e[t],n[3*o+t]=c[t];return void Ko(n,n)}for(l=Math.abs(n[0]),i=0,r=1;r<3;r++)l<(s=Math.abs(n[3*r]))&&(l=s,i=r);if(0!==i){const e=t[i];t[i]=t[0],t[0]=e,go(n,3,i,0)}if(Math.abs(n[4])<Math.abs(n[7])){const e=t[2];t[2]=t[1],t[1]=e,go(n,3,1,2)}for(r=0;r<2;r++)n[3*r+r]<0&&(n[3*r]=-n[3*r],n[3*r+1]=-n[3*r+1],n[3*r+2]=-n[3*r+2]);$o(n)<0&&(n[6]=-n[6],n[7]=-n[7],n[8]=-n[8]),Ko(n,n)}else Yo(n)}function aa(e,t,n){let r,o,a,i,s,l,c,u=0;const d=ho(n);for(r=0;r<n;r++){for(i=0,o=0;o<n;o++)(c=Math.abs(e[r*n+o]))>i&&(i=c);if(0===i)return uo(&quot;Unable to factor linear system&quot;),0;d[r]=1/i}for(o=0;o<n;o++){for(r=0;r<o;r++){for(s=e[r*n+o],a=0;a<r;a++)s-=e[r*n+a]*e[a*n+o];e[r*n+o]=s}for(i=0,r=o;r<n;r++){for(s=e[r*n+o],a=0;a<o;a++)s-=e[r*n+a]*e[a*n+o];e[r*n+o]=s,(l=d[r]*Math.abs(s))>=i&&(i=l,u=r)}if(o!==u){for(a=0;a<n;a++)l=e[u*n+a],e[u*n+a]=e[o*n+a],e[o*n+a]=l;d[u]=d[o]}if(t[o]=u,Math.abs(e[o*n+o])<=lo)return uo(&quot;Unable to factor linear system&quot;),0;if(o!==n-1)for(l=1/e[o*n+o],r=o+1;r<n;r++)e[r*n+o]*=l}return 1}function ia(e,t,n,r){let o,a,i,s,l;for(i=-1,o=0;o<r;o++){if(s=t[o],l=n[s],n[s]=n[o],i>=0)for(a=i;a<=o-1;a++)l-=e[o*r+a]*n[a];else 0!==l&&(i=o);n[o]=l}for(o=r-1;o>=0;o--){for(l=n[o],a=o+1;a<r;a++)l-=e[o*r+a]*n[a];n[o]=l/e[o*r+o]}}function sa(e,t,n){if(2===n){const n=ho(2),r=Wo(e[0],e[1],e[2],e[3]);return 0===r?0:(n[0]=(e[3]*t[0]-e[1]*t[1])/r,n[1]=(-e[2]*t[0]+e[0]*t[1])/r,t[0]=n[0],t[1]=n[1],1)}if(1===n)return 0===e[0]?0:(t[0]/=e[0],1);const r=ho(n);return 0===aa(e,r,n)?0:(ia(e,r,t,n),1)}function la(e,t,n){let r=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null;const o=(arguments.length>3&&void 0!==arguments[3]?arguments[3]:null)||ho(n),a=r||ho(n);if(0===aa(e,o,n))return null;for(let r=0;r<n;r++){for(let e=0;e<n;e++)a[e]=0;a[r]=1,ia(e,o,a,n);for(let e=0;e<n;e++)t[e*n+r]=a[e]}return t}function ca(e,t,n,r){if(e<n)return uo(&quot;Insufficient number of samples. Underdetermined.&quot;),0;let o,a,i;const s=ho(n*n),l=ho(n),c=ho(n*n);for(i=0;i<e;i++)for(o=0;o<n;o++)for(a=o;a<n;a++)s[o*n+a]+=t[i*n+o]*t[i*n+a];for(o=0;o<n;o++)for(a=0;a<o;a++)s[o*n+a]=s[a*n+o];for(ta(s,n,l,c),o=0;o<n;o++)r[o]=c[o*n+n-1];return 1}function ua(e,t){let n,r;const[o,a,i]=e,s=1/6;let l=o,c=o;a>l?l=a:a<c&&(c=a),i>l?l=i:i<c&&(c=i);const u=l;r=u>0?(l-c)/l:0,r>0?(n=o===l?s*(a-i)/(l-c):a===l?1/3+s*(i-o)/(l-c):2/3+s*(o-a)/(l-c),n<0&&(n+=1)):n=0,t[0]=n,t[1]=r,t[2]=u}function da(e,t){const[n,r,o]=e,a=1/3,i=1/6,s=2/3,l=5/6;let c,u,d;n>i&&n<=a?(u=1,c=(a-n)/i,d=0):n>a&&n<=.5?(u=1,d=(n-a)/i,c=0):n>.5&&n<=s?(d=1,u=(s-n)/i,c=0):n>s&&n<=l?(d=1,c=(n-s)/i,u=0):n>l&&n<=1?(c=1,d=(1-n)/i,u=0):(c=1,u=n/i,d=0),c=r*c+(1-r),u=r*u+(1-r),d=r*d+(1-r),c*=o,u*=o,d*=o,t[0]=c,t[1]=u,t[2]=d}function pa(e,t){const[n,r,o]=e;let a=(n+16)/116,i=r/500+a,s=a-o/200;a**3>.008856?a**=3:a=(a-16/116)/7.787,i**3>.008856?i**=3:i=(i-16/116)/7.787,s**3>.008856?s**=3:s=(s-16/116)/7.787,t[0]=.9505*i,t[1]=1*a,t[2]=1.089*s}function fa(e,t){const[n,r,o]=e;let a=n/.9505,i=r/1,s=o/1.089;a>.008856?a**=1/3:a=7.787*a+16/116,i>.008856?i**=1/3:i=7.787*i+16/116,s>.008856?s**=1/3:s=7.787*s+16/116,t[0]=116*i-16,t[1]=500*(a-i),t[2]=200*(i-s)}function ga(e,t){const[n,r,o]=e;let a=3.2406*n+-1.5372*r+-.4986*o,i=-.9689*n+1.8758*r+.0415*o,s=.0557*n+-.204*r+1.057*o;a>.0031308?a=1.055*a**(1/2.4)-.055:a*=12.92,i>.0031308?i=1.055*i**(1/2.4)-.055:i*=12.92,s>.0031308?s=1.055*s**(1/2.4)-.055:s*=12.92;let l=a;l<i&&(l=i),l<s&&(l=s),l>1&&(a/=l,i/=l,s/=l),a<0&&(a=0),i<0&&(i=0),s<0&&(s=0),t[0]=a,t[1]=i,t[2]=s}function ma(e,t){let[n,r,o]=e;n>.04045?n=((n+.055)/1.055)**2.4:n/=12.92,r>.04045?r=((r+.055)/1.055)**2.4:r/=12.92,o>.04045?o=((o+.055)/1.055)**2.4:o/=12.92,t[0]=.4124*n+.3576*r+.1805*o,t[1]=.2126*n+.7152*r+.0722*o,t[2]=.0193*n+.1192*r+.9505*o}function ha(e,t){const n=[0,0,0];ma(e,n),fa(n,t)}function va(e,t){const n=[0,0,0];pa(e,n),ga(n,t)}function Ta(e){return e[0]=1,e[1]=-1,e[2]=1,e[3]=-1,e[4]=1,e[5]=-1,e}function ya(e){return!(e[1]-e[0]<0)}function ba(e,t,n){return e<t?t:e>n?n:e}function xa(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[0,0,0];return r[0]=ba(e[0],t[0],n[0]),r[1]=ba(e[1],t[1],n[1]),r[2]=ba(e[2],t[2],n[2]),r}const Ca=fo(&quot;GetScalarTypeFittingRange&quot;),Sa=fo(&quot;GetAdjustedScalarRange&quot;);const Aa=e=>!Number.isFinite(e),{isFinite:Ia,isNaN:wa}=Number,Oa=wa;function Pa(){return[].concat([Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE])}function Ra(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:3;const n=new Array(t),r=new Array(t);for(let e=0;e<t;++e)n[e]=e,r[e]=e;for(let o=t-1;o>0;o--){let a=-1/0,i=0,s=0;for(let l=0;l<=o;++l){const c=n[l];for(let n=0;n<=o;++n){const o=r[n],u=Math.abs(e[c+t*o]);u>a&&(a=u,i=l,s=n)}}[n[o],n[i]]=[n[i],n[o]],[r[o],r[s]]=[r[s],r[o]]}const o=new Array(t*t).fill(0);for(let a=0;a<t;++a){const i=n[a]+t*r[a];o[i]=e[i]<0?-1:1}return o}function Ma(e){const t=Math.floor(255*e);return t>15?t.toString(16):`0${t.toString(16)}`}function Ea(e){return Math.round(255*e)}var Va,Da={Pi:()=>Math.PI,ldexp:function(e,t){return t>1023?e*2**1023*2**(t-1023):t<-1074?5e-324*e*2**(t+1074):e*2**t},radiansFromDegrees:vo,degreesFromRadians:To,round:yo,floor:bo,ceil:xo,ceilLog2:Ao,min:Co,max:So,arrayMin:function(e){let t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,n=1/0;for(let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,o=e.length;r<o;r+=t)e[r]<n&&(n=e[r]);return n},arrayMax:function(e){let t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,n=-1/0;for(let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,o=e.length;r<o;r+=t)n<e[r]&&(n=e[r]);return n},arrayRange:function(e){let t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,n=1/0,r=-1/0;for(let o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,a=e.length;o<a;o+=t)e[o]<n&&(n=e[o]),r<e[o]&&(r=e[o]);return[n,r]},isPowerOfTwo:Oo,nearestPowerOfTwo:wo,factorial:Io,binomial:function(e,t){let n=1;for(let r=1;r<=t;++r)n*=(e-r+1)/r;return Math.floor(n)},beginCombination:function(e,t){if(e<t)return 0;const n=ho(t);for(let e=0;e<t;++e)n[e]=e;return n},nextCombination:function(e,t,n){let r=0;for(let o=t-1;o>=0;--o)if(n[o]<e-t+o){let e=n[o]+1;for(;o<t;)n[o++]=e++;r=1;break}return r},randomSeed:function(e){oo(`${e}`,{global:!0}),po=e},getSeed:function(){return po},random:function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return e+((arguments.length>1&&void 0!==arguments[1]?arguments[1]:1)-e)*Math.random()},gaussian:Po,add:Ro,subtract:Mo,multiplyScalar:Eo,multiplyScalar2D:Vo,multiplyAccumulate:Do,multiplyAccumulate2D:function(e,t,n,r){return r[0]=e[0]+t[0]*n,r[1]=e[1]+t[1]*n,r},dot:Lo,outer:function(e,t,n){n[0]=e[0]*t[0],n[1]=e[0]*t[1],n[2]=e[0]*t[2],n[3]=e[1]*t[0],n[4]=e[1]*t[1],n[5]=e[1]*t[2],n[6]=e[2]*t[0],n[7]=e[2]*t[1],n[8]=e[2]*t[2]},cross:Bo,norm:No,normalize:Fo,perpendiculars:function(e,t,n,r){const o=e[0]*e[0],a=e[1]*e[1],i=e[2]*e[2],s=Math.sqrt(o+a+i);let l,c,u;o>a&&o>i?(l=0,c=1,u=2):a>i?(l=1,c=2,u=0):(l=2,c=0,u=1);const d=e[l]/s,p=e[c]/s,f=e[u]/s,g=Math.sqrt(d*d+f*f);if(0!==r){const e=Math.sin(r),o=Math.cos(r);t&&(t[l]=(f*o-d*p*e)/g,t[c]=e*g,t[u]=(-d*o-p*f*e)/g),n&&(n[l]=(-f*e-d*p*o)/g,n[c]=o*g,n[u]=(d*e-p*f*o)/g)}else t&&(t[l]=f/g,t[c]=0,t[u]=-d/g),n&&(n[l]=-d*p/g,n[c]=g,n[u]=-p*f/g)},projectVector:function(e,t,n){const r=Lo(t,t);if(0===r)return n[0]=0,n[1]=0,n[2]=0,!1;const o=Lo(e,t)/r;for(let e=0;e<3;e++)n[e]=t[e];return Eo(n,o),!0},projectVector2D:function(e,t,n){const r=ko(t,t);if(0===r)return n[0]=0,n[1]=0,!1;const o=ko(e,t)/r;for(let e=0;e<2;e++)n[e]=t[e];return Vo(n,o),!0},distance2BetweenPoints:Go,angleBetweenVectors:function(e,t){const n=[0,0,0];return Bo(e,t,n),Math.atan2(No(n),Lo(e,t))},gaussianAmplitude:function(e,t,n){const r=Math.abs(e-n);return 1/Math.sqrt(2*Math.PI*t)*Math.exp(-(r**2)/(2*t))},gaussianWeight:function(e,t,n){const r=Math.abs(e-n);return Math.exp(-(r**2)/(2*t))},dot2D:ko,outer2D:function(e,t,n){n[0]=e[0]*t[0],n[1]=e[0]*t[1],n[2]=e[1]*t[0],n[3]=e[1]*t[1]},norm2D:Uo,normalize2D:zo,determinant2x2:Wo,LUFactor3x3:function(e,t){let n,r,o;const a=[0,0,0];for(let t=0;t<3;t++)o=Math.abs(e[3*t]),(r=Math.abs(e[3*t+1]))>o&&(o=r),(r=Math.abs(e[3*t+2]))>o&&(o=r),a[t]=1/o;o=a[0]*Math.abs(e[0]),n=0,(r=a[1]*Math.abs(e[3]))>=o&&(o=r,n=1),(r=a[2]*Math.abs(e[6]))>=o&&(n=2),0!==n&&(go(e,3,n,0),a[n]=a[0]),t[0]=n,e[3]/=e[0],e[6]/=e[0],e[4]-=e[3]*e[1],e[7]-=e[6]*e[1],o=a[1]*Math.abs(e[4]),n=1,(r=a[2]*Math.abs(e[7]))>=o&&(n=2,go(e,3,1,2),a[2]=a[1]),t[1]=n,e[7]/=e[4],e[5]-=e[3]*e[2],e[8]-=e[6]*e[2]+e[7]*e[5],t[2]=2},LUSolve3x3:function(e,t,n){let r=n[t[0]];n[t[0]]=n[0],n[0]=r,r=n[t[1]],n[t[1]]=n[1],n[1]=r-e[3]*n[0],r=n[t[2]],n[t[2]]=n[2],n[2]=r-e[6]*n[0]-e[7]*n[1],n[2]/=e[8],n[1]=(n[1]-e[5]*n[2])/e[4],n[0]=(n[0]-e[1]*n[1]-e[2]*n[2])/e[0]},linearSolve3x3:function(e,t,n){const r=e[0],o=e[1],a=e[2],i=e[3],s=e[4],l=e[5],c=e[6],u=e[7],d=e[8],p=+Wo(s,u,l,d),f=-Wo(i,c,l,d),g=+Wo(i,c,s,u),m=-Wo(o,u,a,d),h=+Wo(r,c,a,d),v=-Wo(r,c,o,u),T=+Wo(o,s,a,l),y=-Wo(r,i,a,l),b=+Wo(r,i,o,s),x=r*p+o*f+a*g,C=p*t[0]+m*t[1]+T*t[2],S=f*t[0]+h*t[1]+y*t[2],A=g*t[0]+v*t[1]+b*t[2];n[0]=C/x,n[1]=S/x,n[2]=A/x},multiply3x3_vect3:Ho,multiply3x3_mat3:jo,multiplyMatrix:function(e,t,n,r,o,a,i){r!==o&&co(&quot;Number of columns of A must match number of rows of B.&quot;);const s=[...e],l=[...t];for(let e=0;e<n;e++)for(let t=0;t<a;t++){i[e*a+t]=0;for(let n=0;n<r;n++)i[e*a+t]+=s[e*r+n]*l[t+a*n]}},transpose3x3:Ko,invert3x3:function(e,t){const n=e[0],r=e[1],o=e[2],a=e[3],i=e[4],s=e[5],l=e[6],c=e[7],u=e[8],d=+Wo(i,c,s,u),p=-Wo(a,l,s,u),f=+Wo(a,l,i,c),g=-Wo(r,c,o,u),m=+Wo(n,l,o,u),h=-Wo(n,l,r,c),v=+Wo(r,i,o,s),T=-Wo(n,a,o,s),y=+Wo(n,a,r,i),b=n*d+r*p+o*f;0===b&&uo(&quot;Matrix has 0 determinant&quot;),t[0]=d/b,t[3]=p/b,t[6]=f/b,t[1]=g/b,t[4]=m/b,t[7]=h/b,t[2]=v/b,t[5]=T/b,t[8]=y/b},identity3x3:Yo,identity:Zo,isIdentity:function(e){return Xo(e,ao,arguments.length>1&&void 0!==arguments[1]?arguments[1]:so)},isIdentity3x3:function(e){return Xo(e,io,arguments.length>1&&void 0!==arguments[1]?arguments[1]:so)},determinant3x3:$o,quaternionToMatrix3x3:Qo,areEquals:qo,areMatricesEqual:Xo,roundNumber:Jo,roundVector:ea,matrix3x3ToQuaternion:na,multiplyQuaternion:function(e,t,n){const r=e[0]*t[0],o=e[0]*t[1],a=e[0]*t[2],i=e[0]*t[3],s=e[1]*t[0],l=e[1]*t[1],c=e[1]*t[2],u=e[1]*t[3],d=e[2]*t[0],p=e[2]*t[1],f=e[2]*t[2],g=e[2]*t[3],m=e[3]*t[0],h=e[3]*t[1],v=e[3]*t[2],T=e[3]*t[3];n[0]=r-l-f-T,n[1]=o+s+g-v,n[2]=a-u+d+h,n[3]=i+c-p+m},orthogonalize3x3:ra,diagonalize3x3:oa,singularValueDecomposition3x3:function(e,t,n,r){let o;const a=[...e],i=$o(a);if(i<0)for(o=0;o<9;o++)a[o]=-a[o];ra(a,t),Ko(a,a),jo(a,t,r),oa(r,n,r),jo(t,r,t),Ko(r,r),i<0&&(n[0]=-n[0],n[1]=-n[1],n[2]=-n[2])},solveLinearSystem:sa,invertMatrix:la,luFactorLinearSystem:aa,luSolveLinearSystem:ia,estimateMatrixCondition:function(e,t){let n=+Number.MAX_VALUE,r=-Number.MAX_VALUE;for(let n=0;n<t;n++)for(let o=n;o<t;o++)Math.abs(e[n*t+o])>r&&(r=Math.abs(e[n*t+o]));for(let r=0;r<t;r++)Math.abs(e[r*t+r])<n&&(n=Math.abs(e[r*t+r]));return 0===n?Number.MAX_VALUE:r/n},jacobi:function(e,t,n){return ta(e,3,t,n)},jacobiN:ta,solveHomogeneousLeastSquares:ca,solveLeastSquares:function(e,t,n,r,o,a){let i=!(arguments.length>6&&void 0!==arguments[6])||arguments[6];if(e<n||e<o)return uo(&quot;Insufficient number of samples. Underdetermined.&quot;),0;const s=ho(o);let l,c,u,d,p=1,f=0,g=0;if(i){for(u=0;u<o;u++)s[u]=1;for(c=0;c<e;c++)for(u=0;u<o;u++)Math.abs(r[c*o+u])>lo&&(p=0,s[u]=0);if(p&&1===o)return uo(&quot;Detected homogeneous system (Y=0), calling SolveHomogeneousLeastSquares()&quot;),ca(e,t,n,a);if(p)g=1;else for(u=0;u<o;u++)s[u]&&(g=1)}g&&(l=ho(n),f=ca(e,t,n,l));const m=ho(n*n),h=ho(n*n),v=ho(n*o);for(d=0;d<e;d++)for(c=0;c<n;c++){for(u=c;u<n;u++)m[c*n+u]+=t[d*n+c]*t[d*n+u];for(u=0;u<o;u++)v[c*o+u]+=t[d*n+c]*r[d*o+u]}for(c=0;c<n;c++)for(u=0;u<c;u++)m[c*n+u]=m[u*n+c];const T=la(m,h,n);if(T)for(c=0;c<n;c++)for(u=0;u<o;u++)for(a[c*o+u]=0,d=0;d<n;d++)a[c*o+u]+=h[c*n+d]*v[d*o+u];if(g)for(u=0;u<o;u++)if(s[u])for(c=0;c<n;c++)a[c*o+u]=l[c*o];return g?f&&T:T},hex2float:function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[0,.5,1];switch(e.length){case 3:return t[0]=17*parseInt(e[0],16)/255,t[1]=17*parseInt(e[1],16)/255,t[2]=17*parseInt(e[2],16)/255,t;case 4:return t[0]=17*parseInt(e[1],16)/255,t[1]=17*parseInt(e[2],16)/255,t[2]=17*parseInt(e[3],16)/255,t;case 6:return t[0]=parseInt(e.substr(0,2),16)/255,t[1]=parseInt(e.substr(2,2),16)/255,t[2]=parseInt(e.substr(4,2),16)/255,t;case 7:return t[0]=parseInt(e.substr(1,2),16)/255,t[1]=parseInt(e.substr(3,2),16)/255,t[2]=parseInt(e.substr(5,2),16)/255,t;case 9:return t[0]=parseInt(e.substr(1,2),16)/255,t[1]=parseInt(e.substr(3,2),16)/255,t[2]=parseInt(e.substr(5,2),16)/255,t[3]=parseInt(e.substr(7,2),16)/255,t;default:return t}},rgb2hsv:ua,hsv2rgb:da,lab2xyz:pa,xyz2lab:fa,xyz2rgb:ga,rgb2xyz:ma,rgb2lab:ha,lab2rgb:va,uninitializeBounds:Ta,areBoundsInitialized:ya,computeBoundsFromPoints:function(e,t,n){return n[0]=Math.min(e[0],t[0]),n[1]=Math.max(e[0],t[0]),n[2]=Math.min(e[1],t[1]),n[3]=Math.max(e[1],t[1]),n[4]=Math.min(e[2],t[2]),n[5]=Math.max(e[2],t[2]),n},clampValue:ba,clampVector:xa,clampAndNormalizeValue:function(e,t){let n=0;return t[0]!==t[1]&&(n=e<t[0]?t[0]:e>t[1]?t[1]:e,n=(n-t[0])/(t[1]-t[0])),n},getScalarTypeFittingRange:Ca,getAdjustedScalarRange:Sa,extentIsWithinOtherExtent:function(e,t){if(!e||!t)return 0;for(let n=0;n<6;n+=2)if(e[n]<t[n]||e[n]>t[n+1]||e[n+1]<t[n]||e[n+1]>t[n+1])return 0;return 1},boundsIsWithinOtherBounds:function(e,t,n){if(!e||!t)return 0;for(let r=0;r<6;r+=2)if(e[r]+n[r/2]<t[r]||e[r]-n[r/2]>t[r+1]||e[r+1]+n[r/2]<t[r]||e[r+1]-n[r/2]>t[r+1])return 0;return 1},pointIsWithinBounds:function(e,t,n){if(!e||!t||!n)return 0;for(let r=0;r<3;r++)if(e[r]+n[r]<t[2*r]||e[r]-n[r]>t[2*r+1])return 0;return 1},solve3PointCircle:function(e,t,n,r){const o=ho(3),a=ho(3),i=ho(3),s=ho(3),l=ho(3),c=ho(3);for(let r=0;r<3;++r)o[r]=e[r]-t[r],a[r]=t[r]-n[r],i[r]=n[r]-e[r],s[r]=-o[r],l[r]=-a[r],c[r]=-i[r];const u=No(s),d=No(l),p=No(i),f=ho(3);Bo(o,a,f);const g=No(f),m=u*d*p/(2*g),h=2*g*g,v=d*d*Lo(o,c)/h,T=p*p*Lo(s,a)/h,y=u*u*Lo(i,l)/h;for(let o=0;o<3;++o)r[o]=v*e[o]+T*t[o]+y*n[o];return m},inf:1/0,negInf:-1/0,isInf:Aa,isNan:wa,isNaN:wa,isFinite:Ia,createUninitializedBounds:Pa,getMajorAxisIndex:function(e){let t=-1,n=-1;for(let r=0;r<e.length;r++){const o=Math.abs(e[r]);o>t&&(n=r,t=o)}return n},getSparseOrthogonalMatrix:Ra,floatToHex2:Ma,floatRGB2HexCode:function(e){return`${arguments.length>1&&void 0!==arguments[1]?arguments[1]:&quot;#&quot;}${e.map(Ma).join(&quot;&quot;)}`},float2CssRGBA:function(e){return 3===e.length?`rgb(${e.map(Ea).join(&quot;, &quot;)})`:`rgba(${Ea(e[0]||0)}, ${Ea(e[1]||0)}, ${Ea(e[2]||0)}, ${e[3]||0})`}};function La(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3];return e[0]=n[0]*r+n[4]*o+n[8]*a+n[12]*i,e[1]=n[1]*r+n[5]*o+n[9]*a+n[13]*i,e[2]=n[2]*r+n[6]*o+n[10]*a+n[14]*i,e[3]=n[3]*r+n[7]*o+n[11]*a+n[15]*i,e}function Ba(){var e=new s(4);return s!=Float32Array&&(e[0]=0,e[1]=0,e[2]=0),e[3]=1,e}function Na(e,t,n){n*=.5;var r=Math.sin(n);return e[0]=r*t[0],e[1]=r*t[1],e[2]=r*t[2],e[3]=Math.cos(n),e}function Fa(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=n[0],l=n[1],c=n[2],u=n[3];return e[0]=r*u+i*s+o*c-a*l,e[1]=o*u+i*l+a*s-r*c,e[2]=a*u+i*c+r*l-o*s,e[3]=i*u-r*s-o*l-a*c,e}Va=new s(4),s!=Float32Array&&(Va[0]=0,Va[1]=0,Va[2]=0,Va[3]=0);var _a=function(e,t,n,r){var o=new s(4);return o[0]=e,o[1]=t,o[2]=n,o[3]=r,o};fn(),mn(1,0,0),mn(0,1,0),Ba(),Ba(),se();const ka={};function Ga(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ka,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;transform&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkImplicitFunction&quot;),e.functionValue=n=>{if(!t.transform)return e.evaluateFunction(n);const r=[];return t.transform.transformPoint(n,r),e.evaluateFunction(r)},e.evaluateFunction=e=>{Wt.vtkErrorMacro(&quot;not implemented&quot;)}}(e,t)}var Ua={newInstance:Wt.newInstance(Ga,&quot;vtkImplicitFunction&quot;),extend:Ga};const za=1e-6,Wa=&quot;coincide&quot;,Ha=&quot;disjoint&quot;;function ja(e,t,n){const r=n[0]*(e[0]-t[0])+n[1]*(e[1]-t[1])+n[2]*(e[2]-t[2]);return Math.abs(r)}function Ka(e,t,n,r){const o=[];Mo(e,t,o);const a=Lo(n,o);r[0]=e[0]-a*n[0],r[1]=e[1]-a*n[1],r[2]=e[2]-a*n[2]}function $a(e,t,n){const r=Lo(e,t);let o=Lo(t,t);return 0===o&&(o=1),n[0]=e[0]-r*t[0]/o,n[1]=e[1]-r*t[1]/o,n[2]=e[2]-r*t[2]/o,n}function qa(e,t,n,r){const o=[];Mo(e,t,o);const a=Lo(n,o),i=Lo(n,n);0!==i?(r[0]=e[0]-a*n[0]/i,r[1]=e[1]-a*n[1]/i,r[2]=e[2]-a*n[2]/i):(r[0]=e[0],r[1]=e[1],r[2]=e[2])}function Xa(e,t,n,r){const o={intersection:!1,betweenPoints:!1,t:Number.MAX_VALUE,x:[]},a=[],i=[];Mo(t,e,a),Mo(n,e,i);const s=Lo(r,i),l=Lo(r,a);let c,u;return c=l<0?-l:l,u=s<0?-s*za:s*za,c<=u||(o.t=s/l,o.x[0]=e[0]+o.t*a[0],o.x[1]=e[1]+o.t*a[1],o.x[2]=e[2]+o.t*a[2],o.intersection=!0,o.betweenPoints=o.t>=0&&o.t<=1),o}function Ya(e,t,n,r){const o={intersection:!1,l0:[],l1:[],error:null},a=[];Bo(t,r,a);const i=a.map((e=>Math.abs(e)));if(i[0]+i[1]+i[2]<za){const r=[];return Mo(e,n,r),0===Lo(t,r)?o.error=Wa:o.error=Ha,o}let s;s=i[0]>i[1]&&i[0]>i[2]?&quot;x&quot;:i[1]>i[2]?&quot;y&quot;:&quot;z&quot;;const l=[],c=-Lo(t,e),u=-Lo(r,n);switch(s){case&quot;x&quot;:l[0]=0,l[1]=(u*t[2]-c*r[2])/a[0],l[2]=(c*r[1]-u*t[1])/a[0];break;case&quot;y&quot;:l[0]=(c*r[2]-u*t[2])/a[1],l[1]=0,l[2]=(u*t[0]-c*r[0])/a[1];break;case&quot;z&quot;:l[0]=(u*t[1]-c*r[1])/a[2],l[1]=(c*r[0]-u*t[0])/a[2],l[2]=0}return o.l0=l,Ro(l,a,o.l1),o.intersection=!0,o}const Za={evaluate:function(e,t,n){return e[0]*(n[0]-t[0])+e[1]*(n[1]-t[1])+e[2]*(n[2]-t[2])},distanceToPlane:ja,projectPoint:Ka,projectVector:$a,generalizedProjectPoint:qa,intersectWithLine:Xa,intersectWithPlane:Ya,DISJOINT:Ha,COINCIDE:Wa},Qa={normal:[0,0,1],origin:[0,0,0]};function Ja(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Qa,n),Ua.extend(e,t,n),Wt.setGetArray(e,t,[&quot;normal&quot;,&quot;origin&quot;],3),function(e,t){t.classHierarchy.push(&quot;vtkPlane&quot;),e.distanceToPlane=e=>ja(e,t.origin,t.normal),e.projectPoint=(e,n)=>{Ka(e,t.origin,t.normal,n)},e.projectVector=(e,n)=>$a(e,t.normal,n),e.push=e=>{if(0!==e)for(let n=0;n<3;n++)t.origin[n]+=e*t.normal[n]},e.generalizedProjectPoint=(e,n)=>{qa(e,t.origin,t.normal,n)},e.evaluateFunction=(e,n,r)=>Array.isArray(e)?t.normal[0]*(e[0]-t.origin[0])+t.normal[1]*(e[1]-t.origin[1])+t.normal[2]*(e[2]-t.origin[2]):t.normal[0]*(e-t.origin[0])+t.normal[1]*(n-t.origin[1])+t.normal[2]*(r-t.origin[2]),e.evaluateGradient=e=>[t.normal[0],t.normal[1],t.normal[2]],e.intersectWithLine=(e,n)=>Xa(e,n,t.origin,t.normal),e.intersectWithPlane=(e,n)=>Ya(e,n,t.origin,t.normal)}(e,t)}var ei={newInstance:Wt.newInstance(Ja,&quot;vtkPlane&quot;),extend:Ja,...Za};const ti=[Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE];function ni(e,t){return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]&&e[3]===t[3]&&e[4]===t[4]&&e[5]===t[5]}function ri(e){return e?.length>=6&&e[0]<=e[1]&&e[2]<=e[3]&&e[4]<=e[5]}function oi(e,t){return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[4]=t[4],e[5]=t[5],e}function ai(e){return oi(e,ti)}function ii(e,t,n,r){const[o,a,i,s,l,c]=e;return e[0]=o<t?o:t,e[1]=a>t?a:t,e[2]=i<n?i:n,e[3]=s>n?s:n,e[4]=l<r?l:r,e[5]=c>r?c:r,e}function si(e,t){if(0===t.length)return e;if(Array.isArray(t[0]))for(let n=0;n<t.length;++n)ii(e,...t[n]);else for(let n=0;n<t.length;n+=3)ii(e,...t.slice(n,n+3));return e}function li(e,t,n,r,o,a,i){const[s,l,c,u,d,p]=e;return void 0===i?(e[0]=Math.min(t[0],s),e[1]=Math.max(t[1],l),e[2]=Math.min(t[2],c),e[3]=Math.max(t[3],u),e[4]=Math.min(t[4],d),e[5]=Math.max(t[5],p)):(e[0]=Math.min(t,s),e[1]=Math.max(n,l),e[2]=Math.min(r,c),e[3]=Math.max(o,u),e[4]=Math.min(a,d),e[5]=Math.max(i,p)),e}function ci(e,t,n,r){const[o,a,i,s,l,c]=e;return e[0]=t,e[1]=t>a?t:a,e[2]=n,e[3]=n>s?n:s,e[4]=r,e[5]=r>c?r:c,o!==t||i!==n||l!==r}function ui(e,t,n,r){const[o,a,i,s,l,c]=e;return e[0]=t<o?t:o,e[1]=t,e[2]=n<i?n:i,e[3]=n,e[4]=r<l?r:l,e[5]=r,a!==t||s!==n||c!==r}function di(e,t){return null==t?function(e){const t=[0,0,0];let n=-1,r=0,o=0;for(let a=0;a<3;++a)o=e[2*a+1]-e[2*a],o>r&&(r=o,n=a),t[a]=o>0?1:0;if(n<0)return di(e,.5);for(let n=0;n<3;++n)if(!t[n]){const t=.005*r;e[2*n]-=t,e[2*n+1]+=t}return e}(e):(e[0]-=t,e[1]+=t,e[2]-=t,e[3]+=t,e[4]-=t,e[5]+=t,e)}function pi(e,t,n,r){return!!ri(e)&&(t>=0?(e[0]*=t,e[1]*=t):(e[0]=t*e[1],e[1]=t*e[0]),n>=0?(e[2]*=n,e[3]*=n):(e[2]=n*e[3],e[3]=n*e[2]),r>=0?(e[4]*=r,e[5]*=r):(e[4]=r*e[5],e[5]=r*e[4]),!0)}function fi(e){return[.5*(e[0]+e[1]),.5*(e[2]+e[3]),.5*(e[4]+e[5])]}function gi(e,t){return e[2*t+1]-e[2*t]}function mi(e){return[gi(e,0),gi(e,1),gi(e,2)]}function hi(e){return e.slice(0,2)}function vi(e){return e.slice(2,4)}function Ti(e){return e.slice(4,6)}function yi(e){const t=mi(e);return t[0]>t[1]?t[0]>t[2]?t[0]:t[2]:t[1]>t[2]?t[1]:t[2]}function bi(e){if(ri(e)){const t=mi(e);return t[0]*t[0]+t[1]*t[1]+t[2]*t[2]}return null}function xi(e){const t=bi(e);return null!==t?Math.sqrt(t):null}function Ci(e){return[e[0],e[2],e[4]]}function Si(e){return[e[1],e[3],e[5]]}function Ai(e,t){return e<=0&&t>=0||e>=0&&t<=0}function Ii(e,t){return t[0]=[e[0],e[2],e[4]],t[1]=[e[0],e[2],e[5]],t[2]=[e[0],e[3],e[4]],t[3]=[e[0],e[3],e[5]],t[4]=[e[1],e[2],e[4]],t[5]=[e[1],e[2],e[5]],t[6]=[e[1],e[3],e[4]],t[7]=[e[1],e[3],e[5]],t}function wi(e,t,n){return t[0]=e[0],t[1]=e[2],t[2]=e[4],n[0]=e[1],n[1]=e[3],n[2]=e[5],t}function Oi(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[];const r=Ii(e,[]);for(let e=0;e<r.length;++e)In(r[e],r[e],t);return ai(n),si(n,r)}function Pi(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return t[0]=.5*(e[1]-e[0]),t[1]=.5*(e[3]-e[2]),t[2]=.5*(e[5]-e[4]),t}function Ri(e,t,n,r){const o=[].concat(ti),a=e.getData();for(let e=0;e<a.length;e+=3){const i=[a[e],a[e+1],a[e+2]],s=Lo(i,t);o[0]=Math.min(s,o[0]),o[1]=Math.max(s,o[1]);const l=Lo(i,n);o[2]=Math.min(l,o[2]),o[3]=Math.max(l,o[3]);const c=Lo(i,r);o[4]=Math.min(c,o[4]),o[5]=Math.max(c,o[5])}return o}function Mi(e,t,n,r,o){let a=!0;const i=[];let s=0;const l=[],c=[0,0,0];for(let n=0;n<3;n++)t[n]<e[2*n]?(i[n]=1,c[n]=e[2*n],a=!1):t[n]>e[2*n+1]?(i[n]=0,c[n]=e[2*n+1],a=!1):i[n]=2;if(a)return r[0]=t[0],r[1]=t[1],r[2]=t[2],o[0]=0,1;for(let e=0;e<3;e++)2!==i[e]&&0!==n[e]?l[e]=(c[e]-t[e])/n[e]:l[e]=-1;for(let e=0;e<3;e++)l[s]<l[e]&&(s=e);if(l[s]>1||l[s]<0)return 0;o[0]=l[s];for(let o=0;o<3;o++)if(s!==o){if(r[o]=t[o]+l[s]*n[o],r[o]<e[2*o]||r[o]>e[2*o+1])return 0}else r[o]=c[o];return 1}function Ei(e,t,n){const r=[];let o=0,a=1,i=1;for(let s=4;s<=5;++s){r[2]=e[s];for(let s=2;s<=3;++s){r[1]=e[s];for(let s=0;s<=1;++s)if(r[0]=e[s],o=ei.evaluate(n,t,r),i&&(a=o>=0?1:-1,i=0),0===o||a>0&&o<0||a<0&&o>0)return 1}}return 0}function Vi(e,t){if(!ri(e)||!ri(t))return!1;const n=[0,0,0,0,0,0];let r;for(let o=0;o<3;o++)if(r=!1,t[2*o]>=e[2*o]&&t[2*o]<=e[2*o+1]?(r=!0,n[2*o]=t[2*o]):e[2*o]>=t[2*o]&&e[2*o]<=t[2*o+1]&&(r=!0,n[2*o]=e[2*o]),t[2*o+1]>=e[2*o]&&t[2*o+1]<=e[2*o+1]?(r=!0,n[2*o+1]=t[2*o+1]):e[2*o+1]>=t[2*o]&&e[2*o+1]<=t[2*o+1]&&(r=!0,n[2*o+1]=e[2*o+1]),!r)return!1;return e[0]=n[0],e[1]=n[1],e[2]=n[2],e[3]=n[3],e[4]=n[4],e[5]=n[5],!0}function Di(e,t){if(!ri(e)||!ri(t))return!1;for(let n=0;n<3;n++)if(!(t[2*n]>=e[2*n]&&t[2*n]<=e[2*n+1]||e[2*n]>=t[2*n]&&e[2*n]<=t[2*n+1]||t[2*n+1]>=e[2*n]&&t[2*n+1]<=e[2*n+1]||e[2*n+1]>=t[2*n]&&e[2*n+1]<=t[2*n+1]))return!1;return!0}function Li(e,t,n,r){return!(t<e[0]||t>e[1]||n<e[2]||n>e[3]||r<e[4]||r>e[5])}function Bi(e,t,n){const r=[[0,1,2,3,4,5,6,7],[0,1,4,5,2,3,6,7],[0,2,4,6,1,3,5,7]],o=[0,0,0,0,0,0,0,0];let a=0;for(let r=0;r<2;r++)for(let i=2;i<4;i++)for(let s=4;s<6;s++){const l=[e[r],e[i],e[s]];o[a++]=ei.evaluate(n,t,l)}let i=2;for(;i--&&!(Ai(o[r[i][0]],o[r[i][4]])&&Ai(o[r[i][1]],o[r[i][5]])&&Ai(o[r[i][2]],o[r[i][6]])&&Ai(o[r[i][3]],o[r[i][7]])););if(i<0)return!1;const s=Math.sign(n[i]),l=Math.abs((e[2*i+1]-e[2*i])*n[i]);let c=s>0?1:0;for(let e=0;e<4;e++){if(0===l)continue;const t=Math.abs(o[r[i][e]])/l;s>0&&t<c&&(c=t),s<0&&t>c&&(c=t)}const u=(1-c)*e[2*i]+c*e[2*i+1];return s>0?e[2*i]=u:e[2*i+1]=u,!0}function Ni(e,t){for(let e=0;e<3;++e)t[e]=t[e]<1?1:t[e];let n=t[0]*t[1]*t[2];for(;n>e;){for(let e=0;e<3;++e)t[e]=t[e]>1?t[e]-1:1;n=t[0]*t[1]*t[2]}}function Fi(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[];t=t<=0?1:t;let o=0;const a=[0,0,0];let i=-1,s=0;const l=mi(e),c=l[0]+l[1]+l[2],u=c*(.001/3);for(let e=0;e<3;++e)l[e]>s&&(i=e,s=l[e]),l[e]>u?(a[e]=1,o++):a[e]=0;const d=Ci(e),p=Si(e);if(o<1)return n[0]=1,n[1]=1,n[2]=1,r[0]=d[0]-.5,r[1]=p[0]+.5,r[2]=d[1]-.5,r[3]=p[1]+.5,r[4]=d[2]-.5,r[5]=p[2]+.5,1;let f=t;f/=a[0]?l[0]/c:1,f/=a[1]?l[1]/c:1,f/=a[2]?l[2]/c:1,f**=1/o;for(let e=0;e<3;++e)n[e]=a[e]?Math.floor(f*l[e]/c):1,n[e]=n[e]<1?1:n[e];Ni(t,n);const g=.5*l[i]/n[i];for(let e=0;e<3;++e)a[e]?(r[2*e]=d[e],r[2*e+1]=p[e]):(r[2*e]=d[e]-g,r[2*e+1]=p[e]+g);return n[0]*n[1]*n[2]}function _i(e,t){if(e[0]>=t[0]&&e[0]<=t[1]&&e[1]>=t[2]&&e[1]<=t[3]&&e[2]>=t[4]&&e[2]<=t[5])return 0;const n=[0,0,0];return e[0]<t[0]?n[0]=t[0]-e[0]:e[0]>t[1]&&(n[0]=e[0]-t[1]),e[1]<t[2]?n[1]=t[2]-e[1]:e[1]>t[3]&&(n[1]=e[1]-t[3]),e[2]<t[4]?n[2]=t[4]-e[2]:e[2]>t[5]&&(n[2]=e[2]-t[5]),Lo(n,n)}class ki{constructor(e){this.bounds=e,this.bounds||(this.bounds=new Float64Array(ti))}getBounds(){return this.bounds}equals(e){return ni(this.bounds,e)}isValid(){return ri(this.bounds)}setBounds(e){return oi(this.bounds,e)}reset(){return ai(this.bounds)}addPoint(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return ii(this.bounds,...t)}addPoints(e){return si(this.bounds,e)}addBounds(e,t,n,r,o,a){return li(this.bounds,e,t,n,r,o,a)}setMinPoint(e,t,n){return ci(this.bounds,e,t,n)}setMaxPoint(e,t,n){return ui(this.bounds,e,t,n)}inflate(e){return di(this.bounds,e)}scale(e,t,n){return pi(this.bounds,e,t,n)}getCenter(){return fi(this.bounds)}getLength(e){return gi(this.bounds,e)}getLengths(){return mi(this.bounds)}getMaxLength(){return yi(this.bounds)}getDiagonalLength(){return xi(this.bounds)}getDiagonalLength2(){return bi(this.bounds)}getMinPoint(){return Ci(this.bounds)}getMaxPoint(){return Si(this.bounds)}getXRange(){return hi(this.bounds)}getYRange(){return vi(this.bounds)}getZRange(){return Ti(this.bounds)}getCorners(e){return Ii(this.bounds,e)}computeCornerPoints(e,t){return wi(this.bounds,e,t)}computeLocalBounds(e,t,n){return Ri(this.bounds,e,t,n)}transformBounds(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return Oi(this.bounds,e,t)}computeScale3(e){return Pi(this.bounds,e)}cutWithPlane(e,t){return Bi(this.bounds,e,t)}intersectBox(e,t,n,r){return Mi(this.bounds,e,t,n,r)}intersectPlane(e,t){return Ei(this.bounds,e,t)}intersect(e){return Vi(this.bounds,e)}intersects(e){return Di(this.bounds,e)}containsPoint(e,t,n){return Li(this.bounds,e,t,n)}contains(e){return Di(this.bounds,e)}computeDivisions(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[];return Fi(this.bounds,e,t,n)}distance2ToBounds(e){return _i(e,this.bounds)}}var Gi={newInstance:function(e){const t=e&&e.bounds;return new ki(t)},equals:ni,isValid:ri,setBounds:oi,reset:ai,addPoint:ii,addPoints:si,addBounds:li,setMinPoint:ci,setMaxPoint:ui,inflate:di,scale:pi,scaleAboutCenter:function(e,t,n,r){if(!ri(e))return!1;const o=fi(e);return e[0]-=o[0],e[1]-=o[0],e[2]-=o[1],e[3]-=o[1],e[4]-=o[2],e[5]-=o[2],pi(e,t,n,r),e[0]+=o[0],e[1]+=o[0],e[2]+=o[1],e[3]+=o[1],e[4]+=o[2],e[5]+=o[2],!0},getCenter:fi,getLength:gi,getLengths:mi,getMaxLength:yi,getDiagonalLength:xi,getDiagonalLength2:bi,getMinPoint:Ci,getMaxPoint:Si,getXRange:hi,getYRange:vi,getZRange:Ti,getCorners:Ii,computeCornerPoints:wi,computeLocalBounds:Ri,transformBounds:Oi,computeScale3:Pi,cutWithPlane:Bi,intersectBox:Mi,intersectPlane:Ei,intersect:Vi,intersects:Di,containsPoint:Li,contains:function(e,t){return!!Di(e,t)&&!!Li(e,...Ci(t))&&!!Li(e,...Si(t))},computeDivisions:Fi,clampDivisions:Ni,distance2ToBounds:_i,INIT_BOUNDS:ti},Ui={CoordinateSystem:{DISPLAY:0,WORLD:1}};const{CoordinateSystem:zi}=Ui;function Wi(e){return()=>Wt.vtkErrorMacro(`vtkProp::${e} - NOT IMPLEMENTED`)}const Hi={allocatedRenderTime:10,coordinateSystem:zi.WORLD,dragable:!0,estimatedRenderTime:0,paths:null,pickable:!0,renderTimeMultiplier:1,savedEstimatedRenderTime:0,textures:[],useBounds:!0,visibility:!0};function ji(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Hi,n),Wt.obj(e,t),Wt.get(e,t,[&quot;estimatedRenderTime&quot;,&quot;allocatedRenderTime&quot;]),Wt.setGet(e,t,[&quot;_parentProp&quot;,&quot;coordinateSystem&quot;,&quot;dragable&quot;,&quot;pickable&quot;,&quot;renderTimeMultiplier&quot;,&quot;useBounds&quot;,&quot;visibility&quot;]),Wt.moveToProtected(e,t,[&quot;parentProp&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkProp&quot;),e.getMTime=()=>{let e=t.mtime;for(let n=0;n<t.textures.length;++n){const r=t.textures[n].getMTime();r>e&&(e=r)}return e},e.processSelectorPixelBuffers=(e,t)=>{},e.getNestedProps=()=>null,e.getActors=()=>[],e.getActors2D=()=>[],e.getVolumes=()=>[],e.pick=Wi(&quot;pick&quot;),e.hasKey=Wi(&quot;hasKey&quot;),e.getNestedVisibility=()=>t.visibility&&(!t._parentProp||t._parentProp.getNestedVisibility()),e.getNestedPickable=()=>t.pickable&&(!t._parentProp||t._parentProp.getNestedPickable()),e.getNestedDragable=()=>t.dragable&&(!t._parentProp||t._parentProp.getNestedDragable()),e.getRedrawMTime=()=>t.mtime,e.setEstimatedRenderTime=e=>{t.estimatedRenderTime=e,t.savedEstimatedRenderTime=e},e.restoreEstimatedRenderTime=()=>{t.estimatedRenderTime=t.savedEstimatedRenderTime},e.addEstimatedRenderTime=e=>{t.estimatedRenderTime+=e},e.setAllocatedRenderTime=e=>{t.allocatedRenderTime=e,t.savedEstimatedRenderTime=t.estimatedRenderTime,t.estimatedRenderTime=0},e.getSupportsSelection=()=>!1,e.getTextures=()=>t.textures,e.hasTexture=e=>-1!==t.textures.indexOf(e),e.addTexture=n=>{n&&!e.hasTexture(n)&&(t.textures=t.textures.concat(n),e.modified())},e.removeTexture=n=>{const r=t.textures.filter((e=>e!==n));t.textures.length!==r.length&&(t.textures=r,e.modified())},e.removeAllTextures=()=>{t.textures=[],e.modified()},e.setCoordinateSystemToWorld=()=>e.setCoordinateSystem(zi.WORLD),e.setCoordinateSystemToDisplay=()=>e.setCoordinateSystem(zi.DISPLAY)}(e,t)}var Ki={newInstance:Wt.newInstance(ji,&quot;vtkProp&quot;),extend:ji,...Ui};const $i={origin:[0,0,0],position:[0,0,0],orientation:[0,0,0],rotation:null,scale:[1,1,1],bounds:[...Gi.INIT_BOUNDS],properties:[],userMatrix:null,userMatrixMTime:null,cachedProp3D:null,isIdentity:!0,matrixMTime:null};function qi(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,$i,n),Ki.extend(e,t,n),t.matrixMTime={},Wt.obj(t.matrixMTime),Wt.get(e,t,[&quot;isIdentity&quot;]),Wt.getArray(e,t,[&quot;orientation&quot;]),Wt.setGetArray(e,t,[&quot;origin&quot;,&quot;position&quot;,&quot;scale&quot;],3),Wt.setGet(e,t,[&quot;properties&quot;]),t.matrix=m(new Float64Array(16)),t.rotation=m(new Float64Array(16)),t.userMatrix=m(new Float64Array(16)),t.transform=null,function(e,t){t.classHierarchy.push(&quot;vtkProp3D&quot;),e.addPosition=n=>{t.position=t.position.map(((e,t)=>e+n[t])),e.modified()},e.getOrientationWXYZ=()=>{const e=Ba();F(e,t.rotation);const n=new Float64Array(3),r=function(e,t){var n=2*Math.acos(t[3]),r=Math.sin(n/2);return r>i?(e[0]=t[0]/r,e[1]=t[1]/r,e[2]=t[2]/r):(e[0]=1,e[1]=0,e[2]=0),n}(n,e);return[To(r),n[0],n[1],n[2]]},e.getOrientationQuaternion=function(){return F(arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],t.rotation)},e.rotateX=n=>{0!==n&&(A(t.rotation,t.rotation,vo(n)),e.modified())},e.rotateY=n=>{0!==n&&(I(t.rotation,t.rotation,vo(n)),e.modified())},e.rotateZ=n=>{0!==n&&(w(t.rotation,t.rotation,vo(n)),e.modified())},e.rotateWXYZ=(n,r,o,a)=>{if(0===n||0===r&&0===o&&0===a)return;const i=vo(n),s=Ba();Na(s,[r,o,a],i);const l=new Float64Array(16);G(l,s),b(t.rotation,t.rotation,l),e.modified()},e.rotateQuaternion=n=>{if(Math.abs(n[3])>=.999999)return;const r=G(new Float64Array(16),n);b(t.rotation,t.rotation,r),e.modified()},e.setOrientation=(n,r,o)=>(n!==t.orientation[0]||r!==t.orientation[1]||o!==t.orientation[2])&&(t.orientation=[n,r,o],m(t.rotation),e.rotateZ(o),e.rotateX(n),e.rotateY(r),e.modified(),!0),e.setOrientationFromQuaternion=n=>{const r=u();return G(r,n),!Xo(r,t.rotation)&&(t.rotation=r,e.modified(),!0)},e.setUserMatrix=n=>!Xo(t.userMatrix,n)&&(p(t.userMatrix,n),e.modified(),!0),e.getMatrix=()=>(e.computeMatrix(),t.matrix),e.computeMatrix=()=>{if(e.getMTime()>t.matrixMTime.getMTime()){m(t.matrix),t.userMatrix&&b(t.matrix,t.matrix,t.userMatrix),x(t.matrix,t.matrix,t.origin),x(t.matrix,t.matrix,t.position),b(t.matrix,t.matrix,t.rotation),C(t.matrix,t.matrix,t.scale),x(t.matrix,t.matrix,[-t.origin[0],-t.origin[1],-t.origin[2]]),h(t.matrix,t.matrix),t.isIdentity=!0;for(let e=0;e<4;++e)for(let n=0;n<4;++n)(e===n?1:0)!==t.matrix[e+4*n]&&(t.isIdentity=!1);t.matrixMTime.modified()}},e.getBoundsByReference=()=>{if(null===t.mapper)return t.bounds;const n=t.mapper.getBounds();if(!n||6!==n.length)return n;if(n[0]>n[1])return t.mapperBounds=n,t.bounds=[...Gi.INIT_BOUNDS],t.boundsMTime.modified(),n;if(!t.mapperBounds||!n.every(((e,r)=>n[r]===t.mapperBounds[r]))||e.getMTime()>t.boundsMTime.getMTime()){Wt.vtkDebugMacro(&quot;Recomputing bounds...&quot;),t.mapperBounds=n,e.computeMatrix();const r=new Float64Array(16);h(r,t.matrix),Gi.transformBounds(n,r,t.bounds),t.boundsMTime.modified()}return t.bounds},e.getBounds=()=>{const t=e.getBoundsByReference();try{return[...t]}catch{return t}},e.getCenter=()=>Gi.getCenter(t.bounds),e.getLength=()=>Gi.getLength(t.bounds),e.getXRange=()=>Gi.getXRange(t.bounds),e.getYRange=()=>Gi.getYRange(t.bounds),e.getZRange=()=>Gi.getZRange(t.bounds),e.getUserMatrix=()=>t.userMatrix,e.onModified((function(){e.computeMatrix()})),e.getProperty=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return null==t.properties[n]&&(t.properties[n]=e.makeProperty?.()),t.properties[n]},e.getProperties=()=>(0===t.properties.length&&(t.properties[0]=e.makeProperty?.()),t.properties),e.setProperty=(e,n)=>{const r=Number.isInteger(e),[o,a]=r?[e,n]:[0,e];return t.properties[o]!==a&&(t.properties[o]=a,!0)},e.getMTime=()=>{let e=t.mtime;return t.properties.forEach((t=>{if(null!==t){const n=t.getMTime();e=n>e?n:e}})),e}}(e,t)}var Xi={newInstance:Wt.newInstance(qi,&quot;vtkProp3D&quot;),extend:qi};const Yi={FLAT:0,GOURAUD:1,PHONG:2},Zi={POINTS:0,WIREFRAME:1,SURFACE:2};var Qi={Shading:Yi,Representation:Zi,Interpolation:Yi};const{Representation:Ji,Interpolation:es}=Qi;function ts(e){return()=>Wt.vtkErrorMacro(`vtkProperty::${e} - NOT IMPLEMENTED`)}const ns={color:[1,1,1],ambientColor:[1,1,1],diffuseColor:[1,1,1],specularColor:[1,1,1],edgeColor:[0,0,0],ambient:0,diffuse:1,metallic:0,roughness:.6,normalStrength:1,emission:1,baseIOR:1.45,specular:0,specularPower:1,opacity:1,interpolation:es.GOURAUD,representation:Ji.SURFACE,edgeVisibility:!1,backfaceCulling:!1,frontfaceCulling:!1,pointSize:1,lineWidth:1,lighting:!0,shading:!1,materialName:null,ORMTexture:null,RMTexture:null};function rs(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ns,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;lighting&quot;,&quot;interpolation&quot;,&quot;ambient&quot;,&quot;diffuse&quot;,&quot;metallic&quot;,&quot;roughness&quot;,&quot;normalStrength&quot;,&quot;emission&quot;,&quot;baseIOR&quot;,&quot;specular&quot;,&quot;specularPower&quot;,&quot;opacity&quot;,&quot;edgeVisibility&quot;,&quot;lineWidth&quot;,&quot;pointSize&quot;,&quot;backfaceCulling&quot;,&quot;frontfaceCulling&quot;,&quot;representation&quot;,&quot;diffuseTexture&quot;,&quot;metallicTexture&quot;,&quot;roughnessTexture&quot;,&quot;normalTexture&quot;,&quot;ambientOcclusionTexture&quot;,&quot;emissionTexture&quot;,&quot;ORMTexture&quot;,&quot;RMTexture&quot;]),Wt.setGetArray(e,t,[&quot;ambientColor&quot;,&quot;specularColor&quot;,&quot;diffuseColor&quot;,&quot;edgeColor&quot;],3),function(e,t){t.classHierarchy.push(&quot;vtkProperty&quot;),e.setColor=(n,r,o)=>{Array.isArray(n)?t.color[0]===n[0]&&t.color[1]===n[1]&&t.color[2]===n[2]||(t.color[0]=n[0],t.color[1]=n[1],t.color[2]=n[2],e.modified()):t.color[0]===n&&t.color[1]===r&&t.color[2]===o||(t.color[0]=n,t.color[1]=r,t.color[2]=o,e.modified()),e.setDiffuseColor(t.color),e.setAmbientColor(t.color),e.setSpecularColor(t.color)},e.computeCompositeColor=ts(&quot;ComputeCompositeColor&quot;),e.getColor=()=>{let e=0;t.ambient+t.diffuse+t.specular>0&&(e=1/(t.ambient+t.diffuse+t.specular));for(let n=0;n<3;n++)t.color[n]=e*(t.ambient*t.ambientColor[n]+t.diffuse*t.diffuseColor[n]+t.specular*t.specularColor[n]);return[].concat(t.color)},e.setSpecularPower=n=>{const r=1/Math.max(1,n);t.roughness===r&&t.specularPower===n||(t.specularPower=n,t.roughness=r,e.modified())},e.addShaderVariable=ts(&quot;AddShaderVariable&quot;),e.setInterpolationToFlat=()=>e.setInterpolation(es.FLAT),e.setInterpolationToGouraud=()=>e.setInterpolation(es.GOURAUD),e.setInterpolationToPhong=()=>e.setInterpolation(es.PHONG),e.getInterpolationAsString=()=>Wt.enumToString(es,t.interpolation),e.setRepresentationToWireframe=()=>e.setRepresentation(Ji.WIREFRAME),e.setRepresentationToSurface=()=>e.setRepresentation(Ji.SURFACE),e.setRepresentationToPoints=()=>e.setRepresentation(Ji.POINTS),e.getRepresentationAsString=()=>Wt.enumToString(Ji,t.representation)}(e,t)}var os={newInstance:Wt.newInstance(rs,&quot;vtkProperty&quot;),extend:rs,...Qi};const as={mapper:null,backfaceProperty:null,forceOpaque:!1,forceTranslucent:!1};function is(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,as,n),Xi.extend(e,t,n),t.boundsMTime={},Wt.obj(t.boundsMTime),Wt.setGet(e,t,[&quot;backfaceProperty&quot;,&quot;forceOpaque&quot;,&quot;forceTranslucent&quot;,&quot;mapper&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkActor&quot;);const n={...e};e.getActors=()=>[e],e.getIsOpaque=()=>{if(t.forceOpaque)return!0;if(t.forceTranslucent)return!1;t.properties[0]||e.getProperty();let n=t.properties[0].getOpacity()>=1;return n=n&&(!t.texture||!t.texture.isTranslucent()),n=n&&(!t.mapper||t.mapper.getIsOpaque()),n},e.hasTranslucentPolygonalGeometry=()=>null!==t.mapper&&(t.properties[0]||e.getProperty(),!e.getIsOpaque()),e.makeProperty=os.newInstance,e.getMTime=()=>{let e=n.getMTime();if(null!==t.backfaceProperty){const n=t.backfaceProperty.getMTime();e=n>e?n:e}return e},e.getRedrawMTime=()=>{let e=t.mtime;if(null!==t.mapper){let n=t.mapper.getMTime();e=n>e?n:e,null!==t.mapper.getInput()&&(t.mapper.getInputAlgorithm().update(),n=t.mapper.getInput().getMTime(),e=n>e?n:e)}return e},e.getSupportsSelection=()=>!!t.mapper&&t.mapper.getSupportsSelection(),e.processSelectorPixelBuffers=(e,n)=>{t.mapper&&t.mapper.processSelectorPixelBuffers&&t.mapper.processSelectorPixelBuffers(e,n)}}(e,t)}var ss={newInstance:Wt.newInstance(is,&quot;vtkActor&quot;),extend:is};const ls={Int8Array:1,Uint8Array:1,Uint8ClampedArray:1,Int16Array:2,Uint16Array:2,Int32Array:4,Uint32Array:4,Float32Array:4,Float64Array:8},cs={VOID:&quot;&quot;,CHAR:&quot;Int8Array&quot;,SIGNED_CHAR:&quot;Int8Array&quot;,UNSIGNED_CHAR:&quot;Uint8Array&quot;,UNSIGNED_CHAR_CLAMPED:&quot;Uint8ClampedArray&quot;,SHORT:&quot;Int16Array&quot;,UNSIGNED_SHORT:&quot;Uint16Array&quot;,INT:&quot;Int32Array&quot;,UNSIGNED_INT:&quot;Uint32Array&quot;,FLOAT:&quot;Float32Array&quot;,DOUBLE:&quot;Float64Array&quot;};var us={DefaultDataType:cs.FLOAT,DataTypeByteSize:ls,VtkDataTypes:cs};const{vtkErrorMacro:ds}=Ht,{DefaultDataType:ps}=us;function fs(e,t,n){const r=e.length;let o,a,i=Number.MAX_VALUE,s=-Number.MAX_VALUE;for(a=t;a<r;a+=n)if(!Number.isNaN(e[a])){i=e[a],s=i;break}for(;a<r;a+=n)o=e[a],o<i?i=o:o>s&&(s=o);return{min:i,max:s}}function gs(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1;if(t<0&&n>1){const t=e.length/n,r=new Float64Array(t);for(let o=0,a=0;o<t;++o){for(let t=a+n;a<t;++a)r[o]+=e[a]*e[a];r[o]**=.5}return fs(r,0,1)}return fs(e,t<0?0:t,n)}function ms(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;const n=e||[];for(;n.length<=t;)n.push(null);return n}function hs(e){return Object.prototype.toString.call(e).slice(8,-1)}const vs={computeRange:gs,createRangeHelper:function(){let e=Number.MAX_VALUE,t=-Number.MAX_VALUE,n=0,r=0;return{add(o){e>o&&(e=o),t<o&&(t=o),n++,r+=o},get(){return{min:e,max:t,count:n,sum:r,mean:r/n}},getRange(){return{min:e,max:t}}}},fastComputeRange:fs,getDataType:hs,getMaxNorm:function(e){const t=e.getNumberOfComponents();let n=0;const r=new Array(t);for(let o=0;o<e.getNumberOfTuples();++o){e.getTuple(o,r);const a=No(r,t);a>n&&(n=a)}return n}},Ts={name:&quot;&quot;,numberOfComponents:1,dataType:ps,rangeTuple:[0,0]};function ys(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};if(Object.assign(t,Ts,n),Array.isArray(n.values)&&void 0===n.dataType&&console.warn(&quot;vtkDataArray.newInstance: no dataType provided, converting to Float32Array&quot;),!t.empty&&!t.values&&!t.size)throw new TypeError(&quot;Cannot create vtkDataArray object without: size > 0, values&quot;);if(t.values?Array.isArray(t.values)&&(t.values=it(t.dataType,t.values)):t.values=at(t.dataType,t.size),t.values&&(t.size=t.size??t.values.length,t.dataType=hs(t.values)),ht(e,t),xt(e,t,[&quot;name&quot;,&quot;numberOfComponents&quot;]),t.size%t.numberOfComponents!=0)throw new RangeError(&quot;model.size is not a multiple of model.numberOfComponents&quot;);!function(e,t){function n(n){if(n<0)return!1;const r=e.getNumberOfComponents(),o=t.values.length/(r>0?r:1);if(n===o)return!0;if(n>o){const e=t.values;return t.values=at(t.dataType,(n+o)*r),t.values.set(e),!0}return t.size>n*r&&(t.size=n*r,e.dataChange()),!0}t.classHierarchy.push(&quot;vtkDataArray&quot;),e.dataChange=()=>{t.ranges=null,e.modified()},e.allocate=t=>{n(e.getNumberOfTuples()+t)},e.resize=r=>{n(r);const o=r*e.getNumberOfComponents();return t.size!==o&&(t.size=o,e.dataChange(),!0)},e.initialize=()=>(e.resize(0),e),e.getElementComponentSize=()=>t.values.BYTES_PER_ELEMENT,e.getComponent=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;return t.values[e*t.numberOfComponents+n]},e.setComponent=(n,r,o)=>{o!==t.values[n*t.numberOfComponents+r]&&(t.values[n*t.numberOfComponents+r]=o,e.dataChange())},e.getValue=n=>{const r=n/t.numberOfComponents,o=n%t.numberOfComponents;return e.getComponent(r,o)},e.setValue=(n,r)=>{const o=n/t.numberOfComponents,a=n%t.numberOfComponents;e.setComponent(o,a,r)},e.getData=()=>t.size===t.values.length?t.values:t.values.subarray(0,t.size),e.getRange=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:-1,r=n;r<0&&(r=1===t.numberOfComponents?0:t.numberOfComponents);let o=null;return t.ranges||(t.ranges=ms(t.ranges,t.numberOfComponents)),o=t.ranges[r],o?(t.rangeTuple[0]=o.min,t.rangeTuple[1]=o.max,t.rangeTuple):(o=gs(e.getData(),n,t.numberOfComponents),t.ranges[r]=o,t.rangeTuple[0]=o.min,t.rangeTuple[1]=o.max,t.rangeTuple)},e.setRange=(e,n)=>{t.ranges||(t.ranges=ms(t.ranges,t.numberOfComponents));const r={min:e.min,max:e.max};return t.ranges[n]=r,t.rangeTuple[0]=r.min,t.rangeTuple[1]=r.max,t.rangeTuple},e.getRanges=function(){if(arguments.length>0&&void 0!==arguments[0]&&!arguments[0])return structuredClone(t.ranges);const n=[];for(let r=0;r<t.numberOfComponents;r++){const[t,o]=e.getRange(r),a={min:t,max:o};n.push(a)}if(t.numberOfComponents>1){const[t,r]=e.getRange(-1),o={min:t,max:r};n.push(o)}return n},e.setTuple=(e,n)=>{const r=e*t.numberOfComponents;for(let e=0;e<t.numberOfComponents;e++)t.values[r+e]=n[e]},e.setTuples=(e,n)=>{let r=e*t.numberOfComponents;const o=Math.min(n.length,t.size-r);for(let e=0;e<o;)t.values[r++]=n[e++]},e.insertTuple=(r,o)=>(t.size<=r*t.numberOfComponents&&(t.size=(r+1)*t.numberOfComponents,n(r+1)),e.setTuple(r,o),r),e.insertTuples=(r,o)=>{const a=r+o.length/t.numberOfComponents;return t.size<a*t.numberOfComponents&&(t.size=a*t.numberOfComponents,n(a)),e.setTuples(r,o),a},e.insertNextTuple=n=>{const r=t.size/t.numberOfComponents;return e.insertTuple(r,n)},e.insertNextTuples=n=>{const r=t.size/t.numberOfComponents;return e.insertTuples(r,n)},e.findTuple=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1e-6;for(let r=0;r<t.size;r+=t.numberOfComponents)if(Math.abs(e[0]-t.values[r])<=n){let o=!0;for(let a=1;a<t.numberOfComponents;++a)if(Math.abs(e[a]-t.values[r+a])>n){o=!1;break}if(o)return r/t.numberOfComponents}return-1},e.getTuple=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];const r=t.numberOfComponents||1,o=e*r;switch(r){case 4:n[3]=t.values[o+3];case 3:n[2]=t.values[o+2];case 2:n[1]=t.values[o+1];case 1:n[0]=t.values[o];break;default:for(let e=r-1;e>=0;--e)n[e]=t.values[o+e]}return n},e.getTuples=(n,r)=>{const o=(n??0)*t.numberOfComponents,a=(r??e.getNumberOfTuples())*t.numberOfComponents,i=e.getData().subarray(o,a);return i.length>0?i:null},e.getTupleLocation=function(){return(arguments.length>0&&void 0!==arguments[0]?arguments[0]:1)*t.numberOfComponents},e.getNumberOfComponents=()=>t.numberOfComponents,e.getNumberOfValues=()=>t.size,e.getNumberOfTuples=()=>t.size/t.numberOfComponents,e.getDataType=()=>t.dataType,e.newClone=()=>bs({empty:!0,name:t.name,dataType:t.dataType,numberOfComponents:t.numberOfComponents}),e.getName=()=>(t.name||(e.modified(),t.name=`vtkDataArray${e.getMTime()}`),t.name),e.setData=(n,r)=>{t.values=n,t.size=n.length,t.dataType=hs(n),r&&(t.numberOfComponents=r),t.size%t.numberOfComponents!=0&&(t.numberOfComponents=1),e.dataChange()},e.getState=()=>{if(t.deleted)return null;const n={...t,vtkClass:e.getClassName()};n.values=Array.from(n.values),delete n.buffer,Object.keys(n).forEach((e=>{n[e]||delete n[e]}));const r={};return Object.keys(n).sort().forEach((e=>{r[e]=n[e]})),r.mtime&&delete r.mtime,r},e.deepCopy=n=>{const r=e.getDataType(),o=t.values;e.shallowCopy(n),t.ranges=structuredClone(n.getRanges()),o?.length>=n.getNumberOfValues()&&r===n.getDataType()?(o.set(n.getData()),t.values=o,e.dataChange()):e.setData(n.getData().slice())},e.interpolateTuple=(n,r,o,a,i,s)=>{const l=t.numberOfComponents||1;l===r.getNumberOfComponents()&&l===a.getNumberOfComponents()||ds(&quot;numberOfComponents must match&quot;);const c=r.getTuple(o),u=a.getTuple(i),d=[];switch(d.length=l,l){case 4:d[3]=c[3]+(u[3]-c[3])*s;case 3:d[2]=c[2]+(u[2]-c[2])*s;case 2:d[1]=c[1]+(u[1]-c[1])*s;case 1:d[0]=c[0]+(u[0]-c[0])*s;break;default:for(let e=0;e<l;e++)d[e]=c[e]+(u[e]-c[e])*s}return e.insertTuple(n,d)}}(e,t)}const bs=Mt(ys,&quot;vtkDataArray&quot;);var xs={newInstance:bs,extend:ys,...vs,...us};const Cs={clippingPlanes:[]};var Ss=function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Cs,n),Wt.obj(e,t),Wt.algo(e,t,1,0),t.clippingPlanes||(t.clippingPlanes=[]),function(e,t){t.classHierarchy.push(&quot;vtkAbstractMapper&quot;),e.update=()=>{e.getInputData()},e.addClippingPlane=n=>!!n.isA(&quot;vtkPlane&quot;)&&!t.clippingPlanes.includes(n)&&(t.clippingPlanes.push(n),e.modified(),!0),e.getNumberOfClippingPlanes=()=>t.clippingPlanes.length,e.removeAllClippingPlanes=()=>0!==t.clippingPlanes.length&&(t.clippingPlanes.length=0,e.modified(),!0),e.removeClippingPlane=n=>{const r=t.clippingPlanes.indexOf(n);return-1!==r&&(t.clippingPlanes.splice(r,1),e.modified(),!0)},e.getClippingPlanes=()=>t.clippingPlanes,e.setClippingPlanes=t=>{if(t)if(Array.isArray(t)){const n=t.length;for(let r=0;r<n&&r<6;r++)e.addClippingPlane(t[r])}else e.addClippingPlane(t)},e.getClippingPlaneInDataCoords=(e,n,r)=>{const o=t.clippingPlanes,a=e;if(o){const e=o.length;if(n>=0&&n<e){const e=o[n],t=e.getNormal(),i=e.getOrigin(),s=t[0],l=t[1],c=t[2],u=-(s*i[0]+l*i[1]+c*i[2]);return r[0]=s*a[0]+l*a[4]+c*a[8]+u*a[12],r[1]=s*a[1]+l*a[5]+c*a[9]+u*a[13],r[2]=s*a[2]+l*a[6]+c*a[10]+u*a[14],void(r[3]=s*a[3]+l*a[7]+c*a[11]+u*a[15])}}Wt.vtkErrorMacro(`Clipping plane index ${n} is out of range.`)}}(e,t)},As=function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,(e=>({bounds:[...Gi.INIT_BOUNDS],center:[0,0,0],viewSpecificProperties:{},...e}))(n)),Ss(e,t,n),Wt.setGet(e,t,[&quot;viewSpecificProperties&quot;]),function(e,t){e.getBounds=()=>(Wt.vtkErrorMacro(&quot;vtkAbstractMapper3D.getBounds - NOT IMPLEMENTED&quot;),Pa()),e.getCenter=()=>{const n=e.getBounds();return t.center=Gi.isValid(n)?Gi.getCenter(n):null,t.center?.slice()},e.getLength=()=>{const t=e.getBounds();return Gi.getDiagonalLength(t)}}(e,t)};const{vtkErrorMacro:Is,vtkWarningMacro:ws}=Wt,Os={arrays:[],copyFieldFlags:[],doCopyAllOn:!0,doCopyAllOff:!1};function Ps(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Os,n),Wt.obj(e,t),function(e,t){t.classHierarchy.push(&quot;vtkFieldData&quot;);const n=e.getState;t.arrays&&(t.arrays=t.arrays.map((e=>({data:ze(e.data)})))),e.initialize=()=>{e.initializeFields(),e.copyAllOn(),e.clearFieldFlags()},e.initializeFields=()=>{t.arrays=[],t.copyFieldFlags={},e.modified()},e.copyStructure=n=>{e.initializeFields(),t.copyFieldFlags=n.getCopyFieldFlags().map((e=>e)),t.arrays=n.getArrays().map((e=>({data:e})))},e.getNumberOfArrays=()=>t.arrays.length,e.getNumberOfActiveArrays=()=>t.arrays.length,e.addArray=n=>{const r=n.getName(),{array:o,index:a}=e.getArrayWithIndex(r);return null!=o?(t.arrays[a]={data:n},a):(t.arrays=[].concat(t.arrays,{data:n}),t.arrays.length-1)},e.removeAllArrays=()=>{t.arrays=[]},e.removeArray=n=>{const r=t.arrays.findIndex((e=>e.data.getName()===n));return e.removeArrayByIndex(r)},e.removeArrayByIndex=e=>-1!==e&&e<t.arrays.length&&(t.arrays.splice(e,1),!0),e.getArrays=()=>t.arrays.map((e=>e.data)),e.getArray=t=>&quot;number&quot;==typeof t?e.getArrayByIndex(t):e.getArrayByName(t),e.getArrayByName=e=>t.arrays.reduce(((t,n,r)=>n.data.getName()===e?n.data:t),null),e.getArrayWithIndex=e=>{const n=t.arrays.findIndex((t=>t.data.getName()===e));return{array:-1!==n?t.arrays[n].data:null,index:n}},e.getArrayByIndex=e=>e>=0&&e<t.arrays.length?t.arrays[e].data:null,e.hasArray=t=>e.getArrayWithIndex(t).index>=0,e.getArrayName=e=>{const n=t.arrays[e];return n?n.data.getName():&quot;&quot;},e.getCopyFieldFlags=()=>t.copyFieldFlags,e.getFlag=e=>t.copyFieldFlags[e],e.passData=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:-1,o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:-1;n.getArrays().forEach((a=>{const i=e.getFlag(a.getName());if(!1!==i&&(!t.doCopyAllOff||!0===i)&&a){let t=e.getArrayByName(a.getName());if(t)if(a.getNumberOfComponents()===t.getNumberOfComponents())if(r>-1&&r<a.getNumberOfTuples()){const e=o>-1?o:r;t.insertTuple(e,a.getTuple(r))}else t.insertTuples(0,a.getTuples());else Is(&quot;Unhandled case in passData&quot;);else if(r<0||r>a.getNumberOfTuples())e.addArray(a),n.getAttributes(a).forEach((t=>{e.setAttribute(a,t)}));else{const i=a.getNumberOfComponents();let s=a.getNumberOfValues();const l=o>-1?o:r;s<=l*i&&(s=(l+1)*i),t=xs.newInstance({name:a.getName(),dataType:a.getDataType(),numberOfComponents:i,values:Wt.newTypedArray(a.getDataType(),s),size:0}),t.insertTuple(l,a.getTuple(r)),e.addArray(t),n.getAttributes(a).forEach((n=>{e.setAttribute(t,n)}))}}}))},e.interpolateData=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:-1,o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:-1,a=arguments.length>3&&void 0!==arguments[3]?arguments[3]:-1,i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:.5;n.getArrays().forEach((s=>{const l=e.getFlag(s.getName());if(!1!==l&&(!t.doCopyAllOff||!0===l)&&s){let t=e.getArrayByName(s.getName());if(t)if(s.getNumberOfComponents()===t.getNumberOfComponents())if(r>-1&&r<s.getNumberOfTuples()){const e=a>-1?a:r;t.interpolateTuple(e,s,r,s,o,i),ws(&quot;Unexpected case in interpolateData&quot;)}else t.insertTuples(s.getTuples());else Is(&quot;Unhandled case in interpolateData&quot;);else if(r<0||o<0||r>s.getNumberOfTuples())e.addArray(s),n.getAttributes(s).forEach((t=>{e.setAttribute(s,t)}));else{const l=s.getNumberOfComponents();let c=s.getNumberOfValues();const u=a>-1?a:r;c<=u*l&&(c=(u+1)*l),t=xs.newInstance({name:s.getName(),dataType:s.getDataType(),numberOfComponents:l,values:Wt.newTypedArray(s.getDataType(),c),size:0}),t.interpolateTuple(u,s,r,s,o,i),e.addArray(t),n.getAttributes(s).forEach((n=>{e.setAttribute(t,n)}))}}}))},e.copyFieldOn=e=>{t.copyFieldFlags[e]=!0},e.copyFieldOff=e=>{t.copyFieldFlags[e]=!1},e.copyAllOn=()=>{t.doCopyAllOn&&!t.doCopyAllOff||(t.doCopyAllOn=!0,t.doCopyAllOff=!1,e.modified())},e.copyAllOff=()=>{!t.doCopyAllOn&&t.doCopyAllOff||(t.doCopyAllOn=!1,t.doCopyAllOff=!0,e.modified())},e.clearFieldFlags=()=>{t.copyFieldFlags={}},e.deepCopy=e=>{t.arrays=e.getArrays().map((e=>{const t=e.newClone();return t.deepCopy(e),{data:t}}))},e.copyFlags=e=>e.getCopyFieldFlags().map((e=>e)),e.reset=()=>t.arrays.forEach((e=>e.data.reset())),e.getMTime=()=>t.arrays.reduce(((e,t)=>t.data.getMTime()>e?t.data.getMTime():e),t.mtime),e.getNumberOfComponents=()=>t.arrays.reduce(((e,t)=>e+t.data.getNumberOfComponents()),0),e.getNumberOfTuples=()=>t.arrays.length>0?t.arrays[0].getNumberOfTuples():0,e.getState=()=>{const e=n();return e&&(e.arrays=t.arrays.map((e=>({data:e.data.getState()})))),e}}(e,t)}var Rs={newInstance:Wt.newInstance(Ps,&quot;vtkFieldData&quot;),extend:Ps};const Ms={DEFAULT:0,SINGLE:1,DOUBLE:2};var Es={AttributeCopyOperations:{COPYTUPLE:0,INTERPOLATE:1,PASSDATA:2,ALLCOPY:3},AttributeLimitTypes:{MAX:0,EXACT:1,NOLIMIT:2},AttributeTypes:{SCALARS:0,VECTORS:1,NORMALS:2,TCOORDS:3,TENSORS:4,GLOBALIDS:5,PEDIGREEIDS:6,EDGEFLAG:7,NUM_ATTRIBUTES:8},CellGhostTypes:{DUPLICATECELL:1,HIGHCONNECTIVITYCELL:2,LOWCONNECTIVITYCELL:4,REFINEDCELL:8,EXTERIORCELL:16,HIDDENCELL:32},DesiredOutputPrecision:Ms,PointGhostTypes:{DUPLICATEPOINT:1,HIDDENPOINT:2},ghostArrayName:&quot;vtkGhostType&quot;};const{AttributeTypes:Vs,AttributeCopyOperations:Ds}=Es,{vtkWarningMacro:Ls}=Wt,Bs={activeScalars:-1,activeVectors:-1,activeTensors:-1,activeNormals:-1,activeTCoords:-1,activeGlobalIds:-1,activePedigreeIds:-1};function Ns(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Bs,n),Rs.extend(e,t,n),Wt.setGet(e,t,[&quot;activeScalars&quot;,&quot;activeNormals&quot;,&quot;activeTCoords&quot;,&quot;activeVectors&quot;,&quot;activeTensors&quot;,&quot;activeGlobalIds&quot;,&quot;activePedigreeIds&quot;]),t.arrays||(t.arrays={}),function(e,t){const n=[&quot;Scalars&quot;,&quot;Vectors&quot;,&quot;Normals&quot;,&quot;TCoords&quot;,&quot;Tensors&quot;,&quot;GlobalIds&quot;,&quot;PedigreeIds&quot;];function r(e){let t=n.find((t=>Vs[t.toUpperCase()]===e||&quot;number&quot;!=typeof e&&t.toLowerCase()===e.toLowerCase()));return void 0===t&&(t=null),t}t.classHierarchy.push(&quot;vtkDataSetAttributes&quot;);const o={...e};e.checkNumberOfComponents=e=>!0,e.setAttribute=(n,o)=>{const a=r(o);if(n&&&quot;PEDIGREEIDS&quot;===a.toUpperCase()&&!n.isA(&quot;vtkDataArray&quot;))return Ls(`Cannot set attribute ${a}. The attribute must be a vtkDataArray.`),-1;if(n&&!e.checkNumberOfComponents(n,a))return Ls(`Cannot set attribute ${a}. Incorrect number of components.`),-1;let i=t[`active${a}`];if(i>=0&&i<t.arrays.length){if(t.arrays[i]===n)return i;e.removeArrayByIndex(i)}return n?(i=e.addArray(n),t[`active${a}`]=i):t[`active${a}`]=-1,e.modified(),t[`active${a}`]},e.getAttributes=t=>n.filter((n=>e[`get${n}`]()===t)),e.setActiveAttributeByName=(t,n)=>e.setActiveAttributeByIndex(e.getArrayWithIndex(t).index,n),e.setActiveAttributeByIndex=(n,o)=>{const a=r(o);if(n>=0&&n<t.arrays.length){if(&quot;PEDIGREEIDS&quot;!==a.toUpperCase()){const t=e.getArrayByIndex(n);if(!t.isA(&quot;vtkDataArray&quot;))return Ls(`Cannot set attribute ${a}. Only vtkDataArray subclasses can be set as active attributes.`),-1;if(!e.checkNumberOfComponents(t,a))return Ls(`Cannot set attribute ${a}. Incorrect number of components.`),-1}return t[`active${a}`]=n,e.modified(),n}return-1===n&&(t[`active${a}`]=n,e.modified()),-1},e.getActiveAttribute=t=>{const n=r(t);return e[`get${n}`]()},e.removeAllArrays=()=>{n.forEach((e=>{t[`active${e}`]=-1})),o.removeAllArrays()},e.removeArrayByIndex=e=>(-1!==e&&n.forEach((n=>{e===t[`active${n}`]?t[`active${n}`]=-1:e<t[`active${n}`]&&(t[`active${n}`]-=1)})),o.removeArrayByIndex(e)),n.forEach((n=>{const r=`active${n}`;e[`get${n}`]=()=>e.getArrayByIndex(t[r]),e[`set${n}`]=t=>e.setAttribute(t,n),e[`setActive${n}`]=t=>e.setActiveAttributeByIndex(e.getArrayWithIndex(t).index,n),e[`copy${n}Off`]=()=>{const e=n.toUpperCase();t.copyAttributeFlags[Ds.PASSDATA][Vs[e]]=!1},e[`copy${n}On`]=()=>{const e=n.toUpperCase();t.copyAttributeFlags[Ds.PASSDATA][Vs[e]]=!0}})),e.initializeAttributeCopyFlags=()=>{t.copyAttributeFlags=[],Object.keys(Ds).filter((e=>&quot;ALLCOPY&quot;!==e)).forEach((e=>{t.copyAttributeFlags[Ds[e]]=Object.keys(Vs).filter((e=>&quot;NUM_ATTRIBUTES&quot;!==e)).reduce(((e,t)=>(e[Vs[t]]=!0,e)),[])})),t.copyAttributeFlags[Ds.COPYTUPLE][Vs.GLOBALIDS]=!1,t.copyAttributeFlags[Ds.INTERPOLATE][Vs.GLOBALIDS]=!1,t.copyAttributeFlags[Ds.COPYTUPLE][Vs.PEDIGREEIDS]=!1},e.initialize=Wt.chain(e.initialize,e.initializeAttributeCopyFlags),t.dataArrays&&Object.keys(t.dataArrays).length&&Object.keys(t.dataArrays).forEach((n=>{t.dataArrays[n].ref||&quot;vtkDataArray&quot;!==t.dataArrays[n].type||e.addArray(xs.newInstance(t.dataArrays[n]))}));const a=e.shallowCopy;e.shallowCopy=(e,n)=>{a(e,n),t.arrays=e.getArrays().map((e=>{const t=e.newClone();return t.shallowCopy(e,n),{data:t}}))},e.initializeAttributeCopyFlags()}(e,t)}var Fs={newInstance:Wt.newInstance(Ns,&quot;vtkDataSetAttributes&quot;),extend:Ns,...Es};const _s=[&quot;pointData&quot;,&quot;cellData&quot;,&quot;fieldData&quot;],ks={};function Gs(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ks,n),Wt.obj(e,t),Wt.setGet(e,t,_s),Wt.getArray(e,t,[&quot;bounds&quot;],6),function(e,t){t.classHierarchy.push(&quot;vtkDataSet&quot;),_s.forEach((e=>{t[e]?t[e]=ze(t[e]):t[e]=Fs.newInstance()})),e.computeBounds=()=>{if(t.modifiedTime&&t.computeTime&&t.modifiedTime>t.computeTime||!t.computeTime){const n=e.getPoints();n?.getNumberOfPoints()?Gi.setBounds(t.bounds,n.getBoundsByReference()):t.bounds=Da.createUninitializedBounds(),t.computeTime=Wt.getCurrentGlobalMTime()}},e.getLength2=()=>{const t=e.getBoundsByReference();return t&&6===t.length?Gi.getDiagonalLength2(t):0},e.getLength=()=>Math.sqrt(e.getLength2()),e.getCenter=()=>{const t=e.getBoundsByReference();return t&&6===t.length?Gi.getCenter(t):[0,0,0]},e.getCellBounds=t=>{const n=e.getCell(t);return n?n.getBounds():Da.createUninitializedBounds()},e.getBounds=Wt.chain((()=>e.computeBounds),e.getBounds),e.getBoundsByReference=Wt.chain((()=>e.computeBounds),e.getBoundsByReference);const n=e.shallowCopy;e.shallowCopy=function(e){n(e,arguments.length>1&&void 0!==arguments[1]&&arguments[1]),_s.forEach((n=>{t[n]=Fs.newInstance(),t[n].shallowCopy(e.getReferenceByName(n))}))};const r=e.getMTime;e.getMTime=()=>_s.reduce(((e,n)=>Math.max(e,t[n]?.getMTime()??e)),r()),e.initialize=()=>(_s.forEach((e=>t[e]?.initialize())),e)}(e,t)}var Us={newInstance:Wt.newInstance(Gs,&quot;vtkDataSet&quot;),extend:Gs,FieldDataTypes:{UNIFORM:0,DATA_OBJECT_FIELD:0,COORDINATE:1,POINT_DATA:1,POINT:2,POINT_FIELD_DATA:2,CELL:3,CELL_FIELD_DATA:3,VERTEX:4,VERTEX_FIELD_DATA:4,EDGE:5,EDGE_FIELD_DATA:5,ROW:6,ROW_DATA:6},FieldAssociations:{FIELD_ASSOCIATION_POINTS:0,FIELD_ASSOCIATION_CELLS:1,FIELD_ASSOCIATION_NONE:2,FIELD_ASSOCIATION_POINTS_THEN_CELLS:3,FIELD_ASSOCIATION_VERTICES:4,FIELD_ASSOCIATION_EDGES:5,FIELD_ASSOCIATION_ROWS:6,NUMBER_OF_ASSOCIATIONS:7}};const zs={UNCHANGED:0,SINGLE_POINT:1,X_LINE:2,Y_LINE:3,Z_LINE:4,XY_PLANE:5,YZ_PLANE:6,XZ_PLANE:7,XYZ_GRID:8,EMPTY:9};var Ws={StructuredType:zs};const{StructuredType:Hs}=Ws;var js={getDataDescriptionFromExtent:function(e){let t=0;for(let n=0;n<3;++n)e[2*n]<e[2*n+1]&&t++;return e[0]>e[1]||e[2]>e[3]||e[4]>e[5]?Hs.EMPTY:3===t?Hs.XYZ_GRID:2===t?e[0]===e[1]?Hs.YZ_PLANE:e[2]===e[3]?Hs.XZ_PLANE:Hs.XY_PLANE:1===t?e[0]<e[1]?Hs.X_LINE:e[2]<e[3]?Hs.Y_LINE:Hs.Z_LINE:Hs.SINGLE_POINT},...Ws};const{vtkErrorMacro:Ks}=Wt,$s={direction:null,indexToWorld:null,worldToIndex:null,spacing:[1,1,1],origin:[0,0,0],extent:[0,-1,0,-1,0,-1],dataDescription:zs.EMPTY};function qs(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,$s,n),Us.extend(e,t,n),t.direction?Array.isArray(t.direction)&&(t.direction=new Float64Array(t.direction.slice(0,9))):t.direction=fe(new Float64Array(9)),t.indexToWorld=new Float64Array(16),t.worldToIndex=new Float64Array(16),Wt.get(e,t,[&quot;indexToWorld&quot;,&quot;worldToIndex&quot;]),Wt.setGetArray(e,t,[&quot;origin&quot;,&quot;spacing&quot;],3),Wt.setGetArray(e,t,[&quot;direction&quot;],9),Wt.getArray(e,t,[&quot;extent&quot;],6),function(e,t){t.classHierarchy.push(&quot;vtkImageData&quot;),e.setExtent=function(){if(t.deleted)return Ks(&quot;instance deleted - cannot call any method&quot;),!1;for(var n=arguments.length,r=new Array(n),o=0;o<n;o++)r[o]=arguments[o];const a=1===r.length?r[0]:r;if(6!==a.length)return!1;const i=t.extent.some(((e,t)=>e!==a[t]));return i&&(t.extent=a.slice(),t.dataDescription=js.getDataDescriptionFromExtent(t.extent),e.modified()),i},e.setDimensions=function(){let n,r,o;if(t.deleted)Ks(&quot;instance deleted - cannot call any method&quot;);else{if(1===arguments.length){const e=arguments.length<=0?void 0:arguments[0];n=e[0],r=e[1],o=e[2]}else{if(3!==arguments.length)return void Ks(&quot;Bad dimension specification&quot;);n=arguments.length<=0?void 0:arguments[0],r=arguments.length<=1?void 0:arguments[1],o=arguments.length<=2?void 0:arguments[2]}e.setExtent(0,n-1,0,r-1,0,o-1)}},e.getDimensions=()=>[t.extent[1]-t.extent[0]+1,t.extent[3]-t.extent[2]+1,t.extent[5]-t.extent[4]+1],e.getNumberOfCells=()=>{const t=e.getDimensions();let n=1;for(let e=0;e<3;e++){if(0===t[e])return 0;t[e]>1&&(n*=t[e]-1)}return n},e.getNumberOfPoints=()=>{const t=e.getDimensions();return t[0]*t[1]*t[2]},e.getPoint=n=>{const r=e.getDimensions();if(0===r[0]||0===r[1]||0===r[2])return Ks(&quot;Requesting a point from an empty image.&quot;),null;const o=new Float64Array(3);switch(t.dataDescription){case zs.EMPTY:return null;case zs.SINGLE_POINT:break;case zs.X_LINE:o[0]=n;break;case zs.Y_LINE:o[1]=n;break;case zs.Z_LINE:o[2]=n;break;case zs.XY_PLANE:o[0]=n%r[0],o[1]=n/r[0];break;case zs.YZ_PLANE:o[1]=n%r[1],o[2]=n/r[1];break;case zs.XZ_PLANE:o[0]=n%r[0],o[2]=n/r[0];break;case zs.XYZ_GRID:o[0]=n%r[0],o[1]=n/r[0]%r[1],o[2]=n/(r[0]*r[1]);break;default:Ks(&quot;Invalid dataDescription&quot;)}const a=[0,0,0];return e.indexToWorld(o,a),a},e.getBounds=()=>e.extentToBounds(e.getSpatialExtent()),e.extentToBounds=e=>Gi.transformBounds(e,t.indexToWorld),e.getSpatialExtent=()=>Gi.inflate([...t.extent],.5),e.computeTransforms=()=>{O(t.indexToWorld,t.origin),t.indexToWorld[0]=t.direction[0],t.indexToWorld[1]=t.direction[1],t.indexToWorld[2]=t.direction[2],t.indexToWorld[4]=t.direction[3],t.indexToWorld[5]=t.direction[4],t.indexToWorld[6]=t.direction[5],t.indexToWorld[8]=t.direction[6],t.indexToWorld[9]=t.direction[7],t.indexToWorld[10]=t.direction[8],C(t.indexToWorld,t.indexToWorld,t.spacing),v(t.worldToIndex,t.indexToWorld)},e.indexToWorld=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return In(n,e,t.indexToWorld),n},e.indexToWorldVec3=e.indexToWorld,e.worldToIndex=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return In(n,e,t.worldToIndex),n},e.worldToIndexVec3=e.worldToIndex,e.indexToWorldBounds=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return Gi.transformBounds(e,t.indexToWorld,n)},e.worldToIndexBounds=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return Gi.transformBounds(e,t.worldToIndex,n)},t._onOriginChanged=e.computeTransforms,t._onDirectionChanged=e.computeTransforms,t._onSpacingChanged=e.computeTransforms,e.computeTransforms(),e.getCenter=()=>Gi.getCenter(e.getBounds()),e.computeHistogram=function(t){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;const r=[0,0,0,0,0,0];e.worldToIndexBounds(t,r);const o=[0,0,0],a=[0,0,0];Gi.computeCornerPoints(r,o,a),ea(o,o),ea(a,a);const i=e.getDimensions();xa(o,[0,0,0],[i[0]-1,i[1]-1,i[2]-1],o),xa(a,[0,0,0],[i[0]-1,i[1]-1,i[2]-1],a);const s=i[0],l=i[0]*i[1],c=e.getPointData().getScalars().getData();let u=-1/0,d=1/0,p=0,f=0,g=0;for(let e=o[2];e<=a[2];e++)for(let t=o[1];t<=a[1];t++){let i=o[0]+t*s+e*l;for(let s=o[0];s<=a[0];s++){if(!n||n([s,t,e],r)){const e=c[i];e>u&&(u=e),e<d&&(d=e),p+=e*e,f+=e,g+=1}++i}}const m=g>0?f/g:0,h=g?Math.abs(p/g-m*m):0;return{minimum:d,maximum:u,average:m,variance:h,sigma:Math.sqrt(h),count:g}},e.computeIncrements=function(e){const t=[];let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;for(let r=0;r<3;++r)t[r]=n,n*=e[2*r+1]-e[2*r]+1;return t},e.computeOffsetIndex=t=>{let[n,r,o]=t;const a=e.getExtent(),i=e.getPointData().getScalars().getNumberOfComponents(),s=e.computeIncrements(a,i);return Math.floor((Math.round(n)-a[0])*s[0]+(Math.round(r)-a[2])*s[1]+(Math.round(o)-a[4])*s[2])},e.getOffsetIndexFromWorld=t=>{const n=e.getExtent(),r=e.worldToIndex(t);for(let e=0;e<3;++e)if(r[e]<n[2*e]||r[e]>n[2*e+1])return Ks(`GetScalarPointer: Pixel ${r} is not in memory. Current extent = ${n}`),NaN;return e.computeOffsetIndex(r)},e.getScalarValueFromWorld=function(t){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;const r=e.getPointData().getScalars().getNumberOfComponents();if(n<0||n>=r)return Ks(`GetScalarPointer: Scalar Component ${n} is not within bounds. Current Scalar numberOfComponents: ${r}`),NaN;const o=e.getOffsetIndexFromWorld(t);return Number.isNaN(o)?o:e.getPointData().getScalars().getComponent(o,n)};const n=e.initialize;e.initialize=()=>(e.set({direction:fe(t.direction),spacing:[1,1,1],origin:[0,0,0],extent:[0,-1,0,-1,0,-1],dataDescription:zs.EMPTY}),n())}(e,t)}var Xs={newInstance:Wt.newInstance(qs,&quot;vtkImageData&quot;),extend:qs};const Ys={LUMINANCE:1,LUMINANCE_ALPHA:2,RGB:3,RGBA:4};var Zs={VectorMode:{MAGNITUDE:0,COMPONENT:1,RGBCOLORS:2},ScalarMappingTarget:Ys,Scale:{LINEAR:0,LOG10:1}},Qs={ColorMode:{DEFAULT:0,MAP_SCALARS:1,DIRECT_SCALARS:2},GetArray:{BY_ID:0,BY_NAME:1},ScalarMode:{DEFAULT:0,USE_POINT_DATA:1,USE_CELL_DATA:2,USE_POINT_FIELD_DATA:3,USE_CELL_FIELD_DATA:4,USE_FIELD_DATA:5}};const{ScalarMappingTarget:Js,Scale:el,VectorMode:tl}=Zs,{VtkDataTypes:nl}=xs,{ColorMode:rl}=Qs,{vtkErrorMacro:ol}=Wt;function al(e){return e}function il(e){return Math.floor(255*e+.5)}const sl={alpha:1,vectorComponent:0,vectorSize:-1,vectorMode:tl.COMPONENT,mappingRange:null,annotationArray:null,annotatedValueMap:null,indexedLookup:!1,scale:el.LINEAR};function ll(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,sl,n),Wt.obj(e,t),t.mappingRange=[0,255],t.annotationArray=[],t.annotatedValueMap=[],Wt.setGet(e,t,[&quot;vectorSize&quot;,&quot;vectorComponent&quot;,&quot;vectorMode&quot;,&quot;alpha&quot;,&quot;indexedLookup&quot;]),Wt.setArray(e,t,[&quot;mappingRange&quot;],2),Wt.getArray(e,t,[&quot;mappingRange&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkScalarsToColors&quot;),e.setVectorModeToMagnitude=()=>e.setVectorMode(tl.MAGNITUDE),e.setVectorModeToComponent=()=>e.setVectorMode(tl.COMPONENT),e.setVectorModeToRGBColors=()=>e.setVectorMode(tl.RGBCOLORS),e.build=()=>{},e.isOpaque=()=>!0,e.setAnnotations=(n,r)=>{if(!(n&&!r||!n&&r))if(n&&r&&n.length!==r.length)ol(&quot;Values and annotations do not have the same number of tuples so ignoring&quot;);else{if(t.annotationArray=[],r&&n){const e=r.length;for(let o=0;o<e;o++)t.annotationArray.push({value:n[o],annotation:String(r[o])})}e.updateAnnotatedValueMap(),e.modified()}},e.setAnnotation=(n,r)=>{let o=e.checkForAnnotatedValue(n),a=!1;return o>=0?t.annotationArray[o].annotation!==r&&(t.annotationArray[o].annotation=r,a=!0):(t.annotationArray.push({value:n,annotation:r}),o=t.annotationArray.length-1,a=!0),a&&(e.updateAnnotatedValueMap(),e.modified()),o},e.getNumberOfAnnotatedValues=()=>t.annotationArray.length,e.getAnnotatedValue=e=>e<0||e>=t.annotationArray.length?null:t.annotationArray[e].value,e.getAnnotation=e=>void 0===t.annotationArray[e]?null:t.annotationArray[e].annotation,e.getAnnotatedValueIndex=n=>t.annotationArray.length?e.checkForAnnotatedValue(n):-1,e.removeAnnotation=n=>{const r=e.checkForAnnotatedValue(n),o=r>=0;return o&&(t.annotationArray.splice(r,1),e.updateAnnotatedValueMap(),e.modified()),o},e.resetAnnotations=()=>{t.annotationArray=[],t.annotatedValueMap=[],e.modified()},e.getAnnotationColor=(n,r)=>{if(t.indexedLookup){const t=e.getAnnotatedValueIndex(n);e.getIndexedColor(t,r)}else e.getColor(parseFloat(n),r),r[3]=1},e.checkForAnnotatedValue=t=>e.getAnnotatedValueIndexInternal(t),e.getAnnotatedValueIndexInternal=e=>{if(void 0!==t.annotatedValueMap[e]){const n=t.annotationArray.length;return t.annotatedValueMap[e]%n}return-1},e.getIndexedColor=(e,t)=>{t[0]=0,t[1]=0,t[2]=0,t[3]=0},e.updateAnnotatedValueMap=()=>{t.annotatedValueMap=[];const e=t.annotationArray.length;for(let n=0;n<e;n++)t.annotatedValueMap[t.annotationArray[n].value]=n},e.mapScalars=(t,n,r)=>{const o=t.getNumberOfComponents();let a=null;if(n===rl.DEFAULT&&(t.getDataType()===nl.UNSIGNED_CHAR||t.getDataType()===nl.UNSIGNED_CHAR_CLAMPED)||n===rl.DIRECT_SCALARS&&t)a=e.convertToRGBA(t,o,t.getNumberOfTuples());else{const n={type:&quot;vtkDataArray&quot;,name:&quot;temp&quot;,numberOfComponents:4,dataType:nl.UNSIGNED_CHAR},i=Wt.newTypedArray(n.dataType,4*t.getNumberOfTuples());n.values=i,n.size=i.length,a=xs.newInstance(n);let s=r;s<0&&o>1?e.mapVectorsThroughTable(t,a,Js.RGBA,-1,-1):(s<0&&(s=0),s>=o&&(s=o-1),e.mapScalarsThroughTable(t,a,Js.RGBA,s))}return a},e.mapVectorsToMagnitude=(e,t,n)=>{const r=e.getNumberOfTuples(),o=e.getNumberOfComponents(),a=t.getData(),i=e.getData();for(let e=0;e<r;e++){let t=0;for(let r=0;r<n;r++)t+=i[e*o+r]*i[e*o+r];a[e]=Math.sqrt(t)}},e.mapVectorsThroughTable=(t,n,r,o,a)=>{let i=e.getVectorMode(),s=a,l=o;const c=t.getNumberOfComponents();i===tl.COMPONENT?(-1===l&&(l=e.getVectorComponent()),l<0&&(l=0),l>=c&&(l=c-1)):(-1===s&&(s=e.getVectorSize()),s<=0?(l=0,s=c):(l<0&&(l=0),l>=c&&(l=c-1),l+s>c&&(s=c-l)),i!==tl.MAGNITUDE||1!==c&&1!==s||(i=tl.COMPONENT));let u=0;switch(l>0&&(u=l),i){case tl.COMPONENT:e.mapScalarsThroughTable(t,n,r,u);break;case tl.RGBCOLORS:break;case tl.MAGNITUDE:default:{const o=xs.newInstance({numberOfComponents:1,values:new Float32Array(t.getNumberOfTuples())});e.mapVectorsToMagnitude(t,o,s),e.mapScalarsThroughTable(o,n,r,0);break}}},e.luminanceToRGBA=(e,t,n,r)=>{const o=r(n),a=t.getData(),i=e.getData(),s=a.length;let l=0;for(let e=0;e<s;e+=1){const t=r(a[e]);i[4*l]=t,i[4*l+1]=t,i[4*l+2]=t,i[4*l+3]=o,l++}},e.luminanceAlphaToRGBA=(e,t,n,r)=>{const o=t.getData(),a=e.getData(),i=o.length;let s=0;for(let e=0;e<i;e+=2){const t=r(o[e]);a[s]=t,a[s+1]=t,a[s+2]=t,a[s+3]=r(o[e+1])*n,s+=4}},e.rGBToRGBA=(e,t,n,r)=>{const o=il(n),a=t.getData(),i=e.getData(),s=a.length;let l=0;for(let e=0;e<s;e+=3)i[4*l]=r(a[e]),i[4*l+1]=r(a[e+1]),i[4*l+2]=r(a[e+2]),i[4*l+3]=o,l++},e.rGBAToRGBA=(e,t,n,r)=>{const o=t.getData(),a=e.getData(),i=o.length;let s=0;for(let e=0;e<i;e+=4)a[4*s]=r(o[e]),a[4*s+1]=r(o[e+1]),a[4*s+2]=r(o[e+2]),a[4*s+3]=r(o[e+3])*n,s++},e.convertToRGBA=(n,r,o)=>{let{alpha:a}=t;if(4===r&&a>=1&&n.getDataType()===nl.UNSIGNED_CHAR)return n;const i=xs.newInstance({numberOfComponents:4,empty:!0,size:4*o,dataType:nl.UNSIGNED_CHAR});if(o<=0)return i;a=a>0?a:0,a=a<1?a:1;let s=al;switch(n.getDataType()!==nl.FLOAT&&n.getDataType()!==nl.DOUBLE||(s=il),r){case 1:e.luminanceToRGBA(i,n,a,s);break;case 2:e.luminanceAlphaToRGBA(i,n,s);break;case 3:e.rGBToRGBA(i,n,a,s);break;case 4:e.rGBAToRGBA(i,n,a,s);break;default:return ol(&quot;Cannot convert colors&quot;),null}return i},e.usingLogScale=()=>!1,e.getNumberOfAvailableColors=()=>16777216,e.setRange=(t,n)=>e.setMappingRange(t,n),e.getRange=()=>e.getMappingRange(),e.areScalarsOpaque=(n,r,o)=>{if(!n)return e.isOpaque();const a=n.getNumberOfComponents();return(r!==rl.DEFAULT||n.getDataType()!==nl.UNSIGNED_CHAR)&&r!==rl.DIRECT_SCALARS||(3===a||1===a?t.alpha>=1:255===n.getRange(a-1)[0])}}(e,t)}var cl={newInstance:Wt.newInstance(ll,&quot;vtkScalarsToColors&quot;),extend:ll,...Zs};const{vtkErrorMacro:ul}=Wt,dl={numberOfColors:256,hueRange:[0,.66667],saturationRange:[1,1],valueRange:[1,1],alphaRange:[1,1],nanColor:[.5,0,0,1],belowRangeColor:[0,0,0,1],aboveRangeColor:[1,1,1,1],useAboveRangeColor:!1,useBelowRangeColor:!1,alpha:1};function pl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,dl,n),cl.extend(e,t,n),t.table||(t.table=[]),t.buildTime={},Wt.obj(t.buildTime),t.opaqueFlagBuildTime={},Wt.obj(t.opaqueFlagBuildTime,{mtime:0}),t.insertTime={},Wt.obj(t.insertTime,{mtime:0}),Wt.get(e,t,[&quot;buildTime&quot;]),Wt.setGet(e,t,[&quot;numberOfColors&quot;,&quot;useAboveRangeColor&quot;,&quot;useBelowRangeColor&quot;]),Wt.setArray(e,t,[&quot;alphaRange&quot;,&quot;hueRange&quot;,&quot;saturationRange&quot;,&quot;valueRange&quot;],2),Wt.setArray(e,t,[&quot;nanColor&quot;,&quot;belowRangeColor&quot;,&quot;aboveRangeColor&quot;],4),Wt.getArray(e,t,[&quot;hueRange&quot;,&quot;saturationRange&quot;,&quot;valueRange&quot;,&quot;alphaRange&quot;,&quot;nanColor&quot;,&quot;belowRangeColor&quot;,&quot;aboveRangeColor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkLookupTable&quot;),e.isOpaque=()=>{if(t.opaqueFlagBuildTime.getMTime()<e.getMTime()){let e=!0;t.nanColor[3]<1&&(e=0),t.useBelowRangeColor&&t.belowRangeColor[3]<1&&(e=0),t.useAboveRangeColor&&t.aboveRangeColor[3]<1&&(e=0);for(let n=3;n<t.table.length&&e;n+=4)t.table[n]<255&&(e=!1);t.opaqueFlag=e,t.opaqueFlagBuildTime.modified()}return t.opaqueFlag},e.usingLogScale=()=>!1,e.getNumberOfAvailableColors=()=>t.table.length/4-3,e.linearIndexLookup=(e,t)=>{let n=0;const r=Number(e);return r<t.range[0]?n=t.maxIndex+0+1.5:r>t.range[1]?n=t.maxIndex+1+1.5:(n=(r+t.shift)*t.scale,n=n<t.maxIndex?n:t.maxIndex),Math.floor(n)},e.linearLookup=(t,n,r)=>{let o=0;o=Oa(t)?Math.floor(r.maxIndex+1.5+2):e.linearIndexLookup(t,r);const a=4*o;return n.slice(a,a+4)},e.indexedLookupFunction=(n,r,o)=>{let a=e.getAnnotatedValueIndexInternal(n);-1===a&&(a=t.numberOfColors+2);const i=4*a;return[r[i],r[i+1],r[i+2],r[i+3]]},e.lookupShiftAndScale=(e,t)=>{t.shift=-e[0],t.scale=Number.MAX_VALUE,e[1]>e[0]&&(t.scale=(t.maxIndex+1)/(e[1]-e[0]))},e.mapScalarsThroughTable=(n,r,o,a)=>{let i=e.linearLookup;t.indexedLookup&&(i=e.indexedLookupFunction);const s=e.getMappingRange(),l={maxIndex:e.getNumberOfColors()-1,range:s,shift:0,scale:0};e.lookupShiftAndScale(s,l);const c=e.getAlpha(),u=n.getNumberOfTuples(),d=n.getNumberOfComponents(),p=r.getData(),f=n.getData();if(c>=1){if(o===Ys.RGBA)for(let e=0;e<u;e++){const n=i(f[e*d+a],t.table,l);p[4*e]=n[0],p[4*e+1]=n[1],p[4*e+2]=n[2],p[4*e+3]=n[3]}}else if(o===Ys.RGBA)for(let e=0;e<u;e++){const n=i(f[e*d+a],t.table,l);p[4*e]=n[0],p[4*e+1]=n[1],p[4*e+2]=n[2],p[4*e+3]=Math.floor(n[3]*c+.5)}},e.forceBuild=()=>{let n=0,r=0,o=0,a=0;const i=t.numberOfColors-1;i&&(n=(t.hueRange[1]-t.hueRange[0])/i,r=(t.saturationRange[1]-t.saturationRange[0])/i,o=(t.valueRange[1]-t.valueRange[0])/i,a=(t.alphaRange[1]-t.alphaRange[0])/i),t.table.length=4*i+16;const s=[],l=[];for(let e=0;e<=i;e++)s[0]=t.hueRange[0]+e*n,s[1]=t.saturationRange[0]+e*r,s[2]=t.valueRange[0]+e*o,da(s,l),l[3]=t.alphaRange[0]+e*a,t.table[4*e]=255*l[0]+.5,t.table[4*e+1]=255*l[1]+.5,t.table[4*e+2]=255*l[2]+.5,t.table[4*e+3]=255*l[3]+.5;e.buildSpecialColors(),t.buildTime.modified()},e.setTable=n=>{if(Array.isArray(n)){const r=n[0].length;t.numberOfColors=n.length;const o=4-r;let a=0;for(let e=0;e<t.numberOfColors;e++)t.table[4*e]=255,t.table[4*e+1]=255,t.table[4*e+2]=255,t.table[4*e+3]=255;for(let e=0;e<n.length;e++){const i=n[e];for(let e=0;e<r;e++)t.table[a++]=i[e];a+=o}return e.buildSpecialColors(),t.insertTime.modified(),e.modified(),!0}if(4!==n.getNumberOfComponents())return ul(&quot;Expected 4 components for RGBA colors&quot;),!1;if(n.getDataType()!==cs.UNSIGNED_CHAR)return ul(&quot;Expected unsigned char values for RGBA colors&quot;),!1;t.numberOfColors=n.getNumberOfTuples();const r=n.getData();t.table.length=r.length;for(let e=0;e<r.length;e++)t.table[e]=r[e];return e.buildSpecialColors(),t.insertTime.modified(),e.modified(),!0},e.buildSpecialColors=()=>{const{numberOfColors:e}=t,n=t.table;let r=4*(e+0);t.useBelowRangeColor||0===e?(n[r]=255*t.belowRangeColor[0]+.5,n[r+1]=255*t.belowRangeColor[1]+.5,n[r+2]=255*t.belowRangeColor[2]+.5,n[r+3]=255*t.belowRangeColor[3]+.5):(n[r]=n[0],n[r+1]=n[1],n[r+2]=n[2],n[r+3]=n[3]),r=4*(e+1),t.useAboveRangeColor||0===e?(n[r]=255*t.aboveRangeColor[0]+.5,n[r+1]=255*t.aboveRangeColor[1]+.5,n[r+2]=255*t.aboveRangeColor[2]+.5,n[r+3]=255*t.aboveRangeColor[3]+.5):(n[r]=n[4*(e-1)+0],n[r+1]=n[4*(e-1)+1],n[r+2]=n[4*(e-1)+2],n[r+3]=n[4*(e-1)+3]),r=4*(e+2),n[r]=255*t.nanColor[0]+.5,n[r+1]=255*t.nanColor[1]+.5,n[r+2]=255*t.nanColor[2]+.5,n[r+3]=255*t.nanColor[3]+.5},e.build=()=>{(t.table.length<1||e.getMTime()>t.buildTime.getMTime()&&t.insertTime.getMTime()<=t.buildTime.getMTime())&&e.forceBuild()},t.table.length>0&&(e.buildSpecialColors(),t.insertTime.modified())}(e,t)}var fl={newInstance:Wt.newInstance(pl,&quot;vtkLookupTable&quot;),extend:pl};const gl={Off:0,PolygonOffset:1};let ml=gl.PolygonOffset,hl=gl.Off;const vl=[&quot;VTK_RESOLVE_OFF&quot;,&quot;VTK_RESOLVE_POLYGON_OFFSET&quot;];function Tl(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;const t=hl===e;return hl=e,t}var yl={Resolve:gl,getResolveCoincidentTopologyAsString:function(){return vl[hl]},getResolveCoincidentTopologyPolygonOffsetFaces:function(){return ml},getResolveCoincidentTopology:function(){return hl},setResolveCoincidentTopology:Tl,setResolveCoincidentTopologyPolygonOffsetFaces:function(e){const t=ml===e;return ml=e,t},setResolveCoincidentTopologyToDefault:function(){return Tl(gl.Off)},setResolveCoincidentTopologyToOff:function(){return Tl(gl.Off)},setResolveCoincidentTopologyToPolygonOffset:function(){return Tl(gl.PolygonOffset)}};function bl(e,t,n){n.forEach((n=>{e[`get${n.method}`]=()=>t[n.key],e[`set${n.method}`]=Wt.objectSetterMap.object(e,t,{name:n.key,params:[&quot;factor&quot;,&quot;offset&quot;]})}))}const xl=[&quot;Polygon&quot;,&quot;Line&quot;,&quot;Point&quot;],Cl={modified:()=>{}};bl(Cl,{Polygon:{factor:2,offset:0},Line:{factor:1,offset:-1},Point:{factor:0,offset:-2}},xl.map((e=>({key:e,method:`ResolveCoincidentTopology${e}OffsetParameters`}))));var Sl={implementCoincidentTopologyMethods:function(e,t){void 0===t.resolveCoincidentTopology&&(t.resolveCoincidentTopology=!1),Wt.setGet(e,t,[&quot;resolveCoincidentTopology&quot;]),t.topologyOffset={Polygon:{factor:0,offset:0},Line:{factor:0,offset:0},Point:{factor:0,offset:0}},Object.keys(yl).forEach((t=>{e[t]=yl[t]})),Object.keys(Cl).filter((e=>&quot;modified&quot;!==e)).forEach((t=>{e[t]=Cl[t]})),bl(e,t.topologyOffset,xl.map((e=>({key:e,method:`RelativeCoincidentTopology${e}OffsetParameters`})))),e.getCoincidentTopologyPolygonOffsetParameters=()=>{const t=Cl.getResolveCoincidentTopologyPolygonOffsetParameters(),n=e.getRelativeCoincidentTopologyPolygonOffsetParameters();return{factor:t.factor+n.factor,offset:t.offset+n.offset}},e.getCoincidentTopologyLineOffsetParameters=()=>{const t=Cl.getResolveCoincidentTopologyLineOffsetParameters(),n=e.getRelativeCoincidentTopologyLineOffsetParameters();return{factor:t.factor+n.factor,offset:t.offset+n.offset}},e.getCoincidentTopologyPointOffsetParameter=()=>{const t=Cl.getResolveCoincidentTopologyPointOffsetParameters(),n=e.getRelativeCoincidentTopologyPointOffsetParameters();return{factor:t.factor+n.factor,offset:t.offset+n.offset}}},staticOffsetAPI:Cl,otherStaticMethods:yl,CATEGORIES:xl,Resolve:gl};const Al={MIN_KNOWN_PASS:0,ACTOR_PASS:0,COMPOSITE_INDEX_PASS:1,ID_LOW24:2,ID_HIGH24:3,MAX_KNOWN_PASS:3};var Il={PassTypes:Al};const{FieldAssociations:wl}=Us,{staticOffsetAPI:Ol,otherStaticMethods:Pl}=Sl,{ColorMode:Rl,ScalarMode:Ml,GetArray:El}=Qs,{VectorMode:Vl}=Zs,{VtkDataTypes:Dl}=xs;function Ll(e){return()=>Wt.vtkErrorMacro(`vtkMapper::${e} - NOT IMPLEMENTED`)}function Bl(e,t){const n=e[1]%2==0?1:-1;if(e[0]+=n,e[0]>=t[0]||e[0]<0){const r=e[2]%2==0?1:-1;e[0]-=n,e[1]+=r,(e[1]>=t[1]||e[1]<0)&&(e[1]-=r,e[2]++)}}function Nl(e,t,n){const r=Math.floor(t),o=r%(2*n[0]);let a,i;o<n[0]?(e[0]=o,a=1,i=e[0]===n[0]-1):(e[0]=2*n[0]-1-o,a=-1,i=0===e[0]);const s=Math.floor(r/n[0]),l=s%(2*n[1]);let c,u;l<n[1]?(e[1]=l,c=1,u=e[1]===n[1]-1):(e[1]=2*n[1]-1-l,c=-1,u=0===e[1]),e[2]=Math.floor(s/n[1]);const d=t-r;i?u?e[2]+=d:e[1]+=c*d:e[0]+=a*d,e[0]=(e[0]+.5)/n[0],e[1]=(e[1]+.5)/n[1],e[2]=(e[2]+.5)/n[2]}const Fl=new WeakMap;const _l={colorMapColors:null,areScalarsMappedFromCells:!1,static:!1,lookupTable:null,scalarVisibility:!0,scalarRange:[0,1],useLookupTableScalarRange:!1,colorMode:0,scalarMode:0,arrayAccessMode:1,renderTime:0,colorByArrayName:null,fieldDataTupleId:-1,populateSelectionSettings:!0,selectionWebGLIdsToVTKIds:null,interpolateScalarsBeforeMapping:!1,colorCoordinates:null,colorTextureMap:null,numberOfColorsInRange:0,forceCompileOnly:0,useInvertibleColors:!1,invertibleScalars:null,customShaderAttributes:[]};function kl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,_l,n),As(e,t,n),Wt.get(e,t,[&quot;areScalarsMappedFromCells&quot;,&quot;colorCoordinates&quot;,&quot;colorMapColors&quot;,&quot;colorTextureMap&quot;,&quot;numberOfColorsInRange&quot;,&quot;selectionWebGLIdsToVTKIds&quot;]),Wt.setGet(e,t,[&quot;colorByArrayName&quot;,&quot;arrayAccessMode&quot;,&quot;colorMode&quot;,&quot;fieldDataTupleId&quot;,&quot;interpolateScalarsBeforeMapping&quot;,&quot;lookupTable&quot;,&quot;populateSelectionSettings&quot;,&quot;renderTime&quot;,&quot;scalarMode&quot;,&quot;scalarVisibility&quot;,&quot;static&quot;,&quot;useLookupTableScalarRange&quot;,&quot;customShaderAttributes&quot;]),Wt.setGetArray(e,t,[&quot;scalarRange&quot;],2),Sl.implementCoincidentTopologyMethods(e,t),function(e,t){t.classHierarchy.push(&quot;vtkMapper&quot;),e.getBounds=()=>{const n=e.getInputData();return n?(t.static||e.update(),t.bounds=n.getBounds()):t.bounds=Pa(),t.bounds},e.setForceCompileOnly=e=>{t.forceCompileOnly=e},e.setSelectionWebGLIdsToVTKIds=e=>{t.selectionWebGLIdsToVTKIds=e},e.createDefaultLookupTable=()=>{t.lookupTable=fl.newInstance()},e.getColorModeAsString=()=>Wt.enumToString(Rl,t.colorMode),e.setColorModeToDefault=()=>e.setColorMode(0),e.setColorModeToMapScalars=()=>e.setColorMode(1),e.setColorModeToDirectScalars=()=>e.setColorMode(2),e.getScalarModeAsString=()=>Wt.enumToString(Ml,t.scalarMode),e.setScalarModeToDefault=()=>e.setScalarMode(0),e.setScalarModeToUsePointData=()=>e.setScalarMode(1),e.setScalarModeToUseCellData=()=>e.setScalarMode(2),e.setScalarModeToUsePointFieldData=()=>e.setScalarMode(3),e.setScalarModeToUseCellFieldData=()=>e.setScalarMode(4),e.setScalarModeToUseFieldData=()=>e.setScalarMode(5),e.getAbstractScalars=(e,n,r,o,a)=>{if(!e||!t.scalarVisibility)return{scalars:null,cellFlag:!1};let i=null,s=!1;if(n===Ml.DEFAULT)i=e.getPointData().getScalars(),i||(i=e.getCellData().getScalars(),s=!0);else if(n===Ml.USE_POINT_DATA)i=e.getPointData().getScalars();else if(n===Ml.USE_CELL_DATA)i=e.getCellData().getScalars(),s=!0;else if(n===Ml.USE_POINT_FIELD_DATA){const t=e.getPointData();i=r===El.BY_ID?t.getArrayByIndex(o):t.getArrayByName(a)}else if(n===Ml.USE_CELL_FIELD_DATA){const t=e.getCellData();s=!0,i=r===El.BY_ID?t.getArrayByIndex(o):t.getArrayByName(a)}else if(n===Ml.USE_FIELD_DATA){const t=e.getFieldData();i=r===El.BY_ID?t.getArrayByIndex(o):t.getArrayByName(a)}return{scalars:i,cellFlag:s}},e.mapScalars=(n,r)=>{const{scalars:o,cellFlag:a}=e.getAbstractScalars(n,t.scalarMode,t.arrayAccessMode,t.arrayId,t.colorByArrayName);if(t.areScalarsMappedFromCells=a,!o)return t.colorCoordinates=null,t.colorTextureMap=null,void(t.colorMapColors=null);const i=`${e.getMTime()}${o.getMTime()}${r}`;if(t.colorBuildString!==i){if(t.useLookupTableScalarRange||e.getLookupTable().setRange(t.scalarRange[0],t.scalarRange[1]),e.canUseTextureMapForColoring(o,a))t.mapScalarsToTexture(o,a,r);else{t.colorCoordinates=null,t.colorTextureMap=null;const n=e.getLookupTable();n&&(n.build(),t.colorMapColors=n.mapScalars(o,t.colorMode,t.fieldDataTupleId))}t.colorBuildString=`${e.getMTime()}${o.getMTime()}${r}`}},t.mapScalarsToTexture=(n,r,o)=>{const a=t.lookupTable.getRange(),i=t.lookupTable.usingLogScale(),s=t.lookupTable.getAlpha(),l=i?[Math.log10(a[0]),Math.log10(a[1])]:a;if(t.colorMapColors=null,null==t.colorTextureMap||e.getMTime()>t.colorTextureMap.getMTime()||t.lookupTable.getMTime()>t.colorTextureMap.getMTime()||t.lookupTable.getAlpha()!==o){t.lookupTable.setAlpha(o),t.colorTextureMap=null,t.lookupTable.build();const e=t.lookupTable.getNumberOfAvailableColors(),n=2048,a=2,d=r?n**3-3:4094;t.numberOfColorsInRange=Math.min(Math.max(e,a),d);const p=t.numberOfColorsInRange+3,f=t.numberOfColorsInRange+2,g=r?[Math.min(Math.ceil(p/n**0),n),Math.min(Math.ceil(p/n**1),n),Math.min(Math.ceil(p/n**2),n)]:[f,2,1],m=g[0]*g[1]*g[2],h=new Float64Array(m);h.fill(NaN);const v=t.numberOfColorsInRange,T=v+2,y=[0,0,0],b=l[0],x=l[1]-l[0];for(let e=0;e<T;++e){const t=b+x*(e-1)/(v-1),n=i?10**t:t;h[(u=g,(c=y)[0]+u[0]*(c[1]+u[1]*c[2]))]=n,Bl(y,g)}const C=xs.newInstance({numberOfComponents:1,values:h}),S=t.lookupTable.mapScalars(C,t.colorMode,0);t.colorTextureMap=Xs.newInstance(),t.colorTextureMap.setDimensions(g),t.colorTextureMap.getPointData().setScalars(S),t.lookupTable.setAlpha(s)}var c,u;const d=t.lookupTable.getVectorMode()===Vl.MAGNITUDE&&n.getNumberOfComponents()>1?-1:t.lookupTable.getVectorComponent();t.colorCoordinates=function(e,t,n,r,o,a,i){const s=new Array(arguments.length);for(let e=0;e<arguments.length;++e){const t=arguments[e];s[e]=t.getMTime?.()??t}const l=s.join(&quot;/&quot;),c=Fl.get(e);if(c&&c.stringHash===l)return c.textureCoordinates;const u=(n[1]-n[0])/(o-1),[d,p]=[n[0]-u,n[1]+u],f=d-.5*u,g=1/(p-d+u),m=d,h=(o+1)/(p-d),v=e.getData(),T=e.getNumberOfTuples(),y=e.getNumberOfComponents(),b=t<0||t>=y,x=a[2]<=1?2:3,C=xs.newInstance({numberOfComponents:x,values:new Float32Array(T*x)}),S=C.getData(),A=[0,0,0];Nl(A,o+2,a);let I=0,w=0;const O=[.5,.5,.5];for(let e=0;e<T;++e){let e;if(b){let t=0;for(let e=0;e<y;++e){const n=Number(v[I+e]);t+=n*n}e=Math.sqrt(t)}else e=Number(v[I+t]);if(r&&(e=Math.log10(e)),I+=y,Oa(e))O[0]=A[0],O[1]=A[1],O[2]=A[2];else if(i){let t=(e-m)*h;t<1?t=0:t>o&&(t=o+1),Nl(O,t,a)}else{O[1]=.49;const t=(e-f)*g;O[0]=t>1e3?1e3:t<-1e3?-1e3:t}for(let e=0;e<x;++e)S[w++]=O[e]}return Fl.set(e,{stringHash:l,textureCoordinates:C}),C}(n,d,l,i,t.numberOfColorsInRange,t.colorTextureMap.getDimensions(),r)},e.getIsOpaque=()=>{const n=e.getInputData(),r=e.getAbstractScalars(n,t.scalarMode,t.arrayAccessMode,t.arrayId,t.colorByArrayName).scalars;if(!t.scalarVisibility||null==r)return!0;const o=e.getLookupTable();return!o||(o.build(),o.areScalarsOpaque(r,t.colorMode,-1))},e.canUseTextureMapForColoring=(e,n)=>!((!n||t.colorMode===Rl.DIRECT_SCALARS)&&(!t.interpolateScalarsBeforeMapping||t.lookupTable&&t.lookupTable.getIndexedLookup()||!e||t.colorMode===Rl.DEFAULT&&e.getDataType()===Dl.UNSIGNED_CHAR||t.colorMode===Rl.DIRECT_SCALARS)),e.clearColorArrays=()=>{t.colorMapColors=null,t.colorCoordinates=null,t.colorTextureMap=null},e.getLookupTable=()=>(t.lookupTable||e.createDefaultLookupTable(),t.lookupTable),e.getMTime=()=>{let e=t.mtime;if(null!==t.lookupTable){const n=t.lookupTable.getMTime();e=n>e?n:e}return e},e.getPrimitiveCount=()=>{const t=e.getInputData();return{points:t.getPoints().getNumberOfValues()/3,verts:t.getVerts().getNumberOfValues()-t.getVerts().getNumberOfCells(),lines:t.getLines().getNumberOfValues()-2*t.getLines().getNumberOfCells(),triangles:t.getPolys().getNumberOfValues()-3*t.getPolys().getNumberOfCells()}},e.acquireInvertibleLookupTable=Ll(&quot;AcquireInvertibleLookupTable&quot;),e.valueToColor=Ll(&quot;ValueToColor&quot;),e.colorToValue=Ll(&quot;ColorToValue&quot;),e.useInvertibleColorFor=Ll(&quot;UseInvertibleColorFor&quot;),e.clearInvertibleColor=Ll(&quot;ClearInvertibleColor&quot;),e.processSelectorPixelBuffers=(e,n)=>{if(!e||!t.selectionWebGLIdsToVTKIds||!t.populateSelectionSettings)return;const r=e.getRawPixelBuffer(Al.ID_LOW24),o=e.getRawPixelBuffer(Al.ID_HIGH24),a=e.getCurrentPass(),i=e.getFieldAssociation();let s=null;i===wl.FIELD_ASSOCIATION_POINTS?s=t.selectionWebGLIdsToVTKIds.points:i===wl.FIELD_ASSOCIATION_CELLS&&(s=t.selectionWebGLIdsToVTKIds.cells),s&&n.forEach((t=>{if(a===Al.ID_LOW24){let n=0;o&&(n+=o[t],n*=256),n+=r[t+2],n*=256,n+=r[t+1],n*=256,n+=r[t];const a=s[n],i=e.getPixelBuffer(Al.ID_LOW24);i[t]=255&a,i[t+1]=(65280&a)>>8,i[t+2]=(16711680&a)>>16}else if(a===Al.ID_HIGH24&&o){let n=0;n+=o[t],n*=256,n+=r[t+2],n*=256,n+=r[t+1],n*=256,n+=r[t];const a=s[n];e.getPixelBuffer(Al.ID_HIGH24)[t]=(4278190080&a)>>24}}))}}(e,t)}var Gl={newInstance:Wt.newInstance(kl,&quot;vtkMapper&quot;),extend:kl,...Ol,...Pl,...Qs};const{isVtkObject:Ul}=Wt;function zl(e){let t=0;return e.filter(((e,n)=>n===t&&(t+=e+1,!0)))}function Wl(e){let t=0;for(let n=0;n<e.length;)n+=e[n]+1,t++;return t}const Hl={extractCellSizes:zl,getNumberOfCells:Wl};function jl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};xs.extend(e,t,function(e){return{empty:!0,numberOfComponents:1,dataType:cs.UNSIGNED_INT,...e}}(n)),function(e,t){t.classHierarchy.push(&quot;vtkCellArray&quot;);const n={...e};e.getNumberOfCells=n=>void 0===t.numberOfCells||n?(t.cellSizes?t.numberOfCells=t.cellSizes.length:t.numberOfCells=Wl(e.getData()),t.numberOfCells):t.numberOfCells,e.getCellSizes=n=>void 0===t.cellSizes||n?(t.cellSizes=zl(e.getData()),t.cellSizes):t.cellSizes,e.resize=r=>{const o=e.getNumberOfTuples();n.resize(r);const a=e.getNumberOfTuples();a<o&&(0===a?(t.numberOfCells=0,t.cellSizes=[]):(t.numberOfCells=void 0,t.cellSizes=void 0))},e.setData=e=>{n.setData(e,1),t.numberOfCells=void 0,t.cellSizes=void 0},e.getCell=e=>{let n=e;const r=t.values[n++];return t.values.subarray(n,n+r)},e.insertNextCell=n=>{let r;r=Ul(n)?n.getPointsIds():n;const o=e.getNumberOfCells();return e.insertNextTuples([r.length,...r]),++t.numberOfCells,null!=t.cellSizes&&t.cellSizes.push(r.length),o},e.getMaxCellSize=()=>e.getCellSizes().reduce(((e,t)=>Math.max(e,t)),0)}(e,t)}var Kl={newInstance:Wt.newInstance(jl,&quot;vtkCellArray&quot;),extend:jl,...Hl};const{vtkErrorMacro:$l}=Wt,ql={empty:!0,numberOfComponents:3,dataType:cs.FLOAT,bounds:[1,-1,1,-1,1,-1]};function Xl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ql,n),xs.extend(e,t,n),Wt.getArray(e,t,[&quot;bounds&quot;],6),function(e,t){let n=0;t.classHierarchy.push(&quot;vtkPoints&quot;),e.getNumberOfPoints=e.getNumberOfTuples,e.setNumberOfPoints=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:3;e.getNumberOfPoints()!==n&&(t.size=n*r,t.values=Wt.newTypedArray(t.dataType,t.size),e.setNumberOfComponents(r),e.modified())},e.setPoint=function(t){for(var n=arguments.length,r=new Array(n>1?n-1:0),o=1;o<n;o++)r[o-1]=arguments[o];e.setTuple(t,r)},e.getPoint=e.getTuple,e.findPoint=e.findTuple,e.insertNextPoint=(t,n,r)=>e.insertNextTuple([t,n,r]),e.insertPoint=(t,n)=>e.insertTuple(t,n);const r=e.getBounds;e.getBounds=()=>(n<t.mtime&&e.computeBounds(),r());const o=e.getBoundsByReference;e.getBoundsByReference=()=>(n<t.mtime&&e.computeBounds(),o()),e.computeBounds=()=>{if(3===e.getNumberOfComponents()){const n=e.getRange(0);t.bounds[0]=n[0],t.bounds[1]=n[1];const r=e.getRange(1);t.bounds[2]=r[0],t.bounds[3]=r[1];const o=e.getRange(2);t.bounds[4]=o[0],t.bounds[5]=o[1]}else if(2===e.getNumberOfComponents()){const n=e.getRange(0);t.bounds[0]=n[0],t.bounds[1]=n[1];const r=e.getRange(1);t.bounds[2]=r[0],t.bounds[3]=r[1],t.bounds[4]=0,t.bounds[5]=0}else $l(`getBounds called on an array with components of ${e.getNumberOfComponents()}`),Ta(t.bounds);n=Wt.getCurrentGlobalMTime()},e.setNumberOfComponents(t.numberOfComponents<2?3:t.numberOfComponents)}(e,t)}var Yl={newInstance:Wt.newInstance(Xl,&quot;vtkPoints&quot;),extend:Xl};const Zl={bounds:[-1,-1,-1,-1,-1,-1],pointsIds:[]};function Ql(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Zl,n),Wt.obj(e,t),t.points||(t.points=Yl.newInstance()),Wt.get(e,t,[&quot;points&quot;,&quot;pointsIds&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkCell&quot;),e.initialize=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(n){t.pointsIds=n;let r=t.points.getData();r.length!==3*t.pointsIds.length&&(r=Wt.newTypedArray(e.getDataType(),3*t.pointsIds.length));const o=e.getData();t.pointsIds.forEach(((e,t)=>{let n=3*e,a=3*t;r[a]=o[n],r[++a]=o[++n],r[++a]=o[++n]})),t.points.setData(r)}else{t.points=e,t.pointsIds=new Array(e.getNumberOfPoints());for(let n=e.getNumberOfPoints()-1;n>=0;--n)t.pointsIds[n]=n}},e.getBounds=()=>t.points.getBounds(),e.getLength2=()=>{const t=Gi.getLengths(e.getBounds());return t[0]*t[0]+t[1]*t[1]+t[2]*t[2]},e.getParametricDistance=e=>{let t,n=0;for(let r=0;r<3;r++)t=e[r]<0?-e[r]:e[r]>1?e[r]-1:0,t>n&&(n=t);return n},e.getNumberOfPoints=()=>t.points.getNumberOfPoints(),e.deepCopy=e=>{e.initialize(t.points,t.pointsIds)},e.getCellDimension=()=>{},e.intersectWithLine=(e,t,n,r,o,a,i)=>{},e.evaluatePosition=(e,t,n,r,o,a)=>{Wt.vtkErrorMacro(&quot;vtkCell.evaluatePosition is not implemented.&quot;)}}(e,t)}var Jl={newInstance:Wt.newInstance(Ql,&quot;vtkCell&quot;),extend:Ql};const ec={array:null,maxId:0,extend:0};function tc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ec,n),Wt.obj(e,t),function(e,t){t.classHierarchy.push(&quot;vtkCellLinks&quot;),e.buildLinks=n=>{const r=n.getPoints().getNumberOfPoints(),o=n.getNumberOfCells(),a=new Uint32Array(r);if(n.isA(&quot;vtkPolyData&quot;)){for(let t=0;t<o;++t){const{cellPointIds:r}=n.getCellPoints(t);r.forEach((t=>{e.incrementLinkCount(t)}))}e.allocateLinks(r),t.maxId=r-1;for(let t=0;t<o;++t){const{cellPointIds:r}=n.getCellPoints(t);r.forEach((n=>{e.insertCellReference(n,a[n]++,t)}))}}else{for(let t=0;t<o;t++)Jl.newInstance().getPointsIds().forEach((t=>{e.incrementLinkCount(t)}));e.allocateLinks(r),t.maxId=r-1;for(let t=0;t<o;++t)Jl.newInstance().getPointsIds().forEach((n=>{e.insertCellReference(n,a[n]++,t)}))}},e.allocate=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1e3;t.array=Array(e).fill().map((()=>({ncells:0,cells:null}))),t.extend=n,t.maxId=-1},e.initialize=()=>{t.array=null},e.getLink=e=>t.array[e],e.getNcells=e=>t.array[e].ncells,e.getCells=e=>t.array[e].cells,e.insertNextPoint=e=>{t.array.push({ncells:e,cells:Array(e)}),++t.maxId},e.insertNextCellReference=(e,n)=>{t.array[e].cells[t.array[e].ncells++]=n},e.deletePoint=e=>{t.array[e].ncells=0,t.array[e].cells=null},e.removeCellReference=(e,n)=>{t.array[n].cells=t.array[n].cells.filter((t=>t!==e)),t.array[n].ncells=t.array[n].cells.length},e.addCellReference=(e,n)=>{t.array[n].cells[t.array[n].ncells++]=e},e.resizeCellList=(e,n)=>{t.array[e].cells.length=n},e.squeeze=()=>{!function(e,t){let n=t;for(t>=e.array.length&&(n+=e.array.length);n>e.array.length;)e.array.push({ncells:0,cells:null});e.array.length=n}(t,t.maxId+1)},e.reset=()=>{t.maxId=-1},e.deepCopy=e=>{t.array=[...e.array],t.extend=e.extend,t.maxId=e.maxId},e.incrementLinkCount=e=>{++t.array[e].ncells},e.allocateLinks=e=>{for(let n=0;n<e;++n)t.array[n].cells=new Array(t.array[n].ncells)},e.insertCellReference=(e,n,r)=>{t.array[e].cells[n]=r}}(e,t)}var nc={newInstance:Wt.newInstance(tc,&quot;vtkCellLinks&quot;),extend:tc};const rc=0,oc=1,ac=2,ic=3,sc=4,lc=5,cc=6,uc=7,dc=9,pc=21,fc=41,gc=42,mc=[&quot;vtkEmptyCell&quot;,&quot;vtkVertex&quot;,&quot;vtkPolyVertex&quot;,&quot;vtkLine&quot;,&quot;vtkPolyLine&quot;,&quot;vtkTriangle&quot;,&quot;vtkTriangleStrip&quot;,&quot;vtkPolygon&quot;,&quot;vtkPixel&quot;,&quot;vtkQuad&quot;,&quot;vtkTetra&quot;,&quot;vtkVoxel&quot;,&quot;vtkHexahedron&quot;,&quot;vtkWedge&quot;,&quot;vtkPyramid&quot;,&quot;vtkPentagonalPrism&quot;,&quot;vtkHexagonalPrism&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;vtkQuadraticEdge&quot;,&quot;vtkQuadraticTriangle&quot;,&quot;vtkQuadraticQuad&quot;,&quot;vtkQuadraticTetra&quot;,&quot;vtkQuadraticHexahedron&quot;,&quot;vtkQuadraticWedge&quot;,&quot;vtkQuadraticPyramid&quot;,&quot;vtkBiQuadraticQuad&quot;,&quot;vtkTriQuadraticHexahedron&quot;,&quot;vtkQuadraticLinearQuad&quot;,&quot;vtkQuadraticLinearWedge&quot;,&quot;vtkBiQuadraticQuadraticWedge&quot;,&quot;vtkBiQuadraticQuadraticHexahedron&quot;,&quot;vtkBiQuadraticTriangle&quot;,&quot;vtkCubicLine&quot;,&quot;vtkQuadraticPolygon&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;vtkConvexPointSet&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;vtkParametricCurve&quot;,&quot;vtkParametricSurface&quot;,&quot;vtkParametricTriSurface&quot;,&quot;vtkParametricQuadSurface&quot;,&quot;vtkParametricTetraRegion&quot;,&quot;vtkParametricHexRegion&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;vtkHigherOrderEdge&quot;,&quot;vtkHigherOrderTriangle&quot;,&quot;vtkHigherOrderQuad&quot;,&quot;vtkHigherOrderPolygon&quot;,&quot;vtkHigherOrderTetrahedron&quot;,&quot;vtkHigherOrderWedge&quot;,&quot;vtkHigherOrderPyramid&quot;,&quot;vtkHigherOrderHexahedron&quot;],hc={getClassNameFromTypeId:function(e){return e<mc.length?mc[e]:&quot;UnknownClass&quot;},getTypeIdFromClassName:function(e){return mc.findIndex(e)},isLinear:function(e){return e<pc||e===fc||e===gc},hasSubCells:function(e){return e===cc||e===sc||e===ac}},vc={size:0,maxId:-1,extend:1e3};function Tc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,vc,n),Wt.obj(e,t),Wt.get(e,t,[&quot;size&quot;,&quot;maxId&quot;,&quot;extend&quot;]),Wt.getArray(e,t,[&quot;typeArray&quot;,&quot;locationArray&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkCellTypes&quot;),e.allocate=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:512,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1e3;t.size=e>0?e:1,t.extend=n>0?n:1,t.maxId=-1,t.typeArray=new Uint8Array(e),t.locationArray=new Uint32Array(e)},e.insertCell=(e,n,r)=>{t.typeArray[e]=n,t.locationArray[e]=r,e>t.maxId&&(t.maxId=e)},e.insertNextCell=(n,r)=>(e.insertCell(++t.maxId,n,r),t.maxId),e.setCellTypes=(e,n,r)=>{t.size=e,t.typeArray=n,t.locationArray=r,t.maxId=e-1},e.getCellLocation=e=>t.locationArray[e],e.deleteCell=e=>{t.typeArray[e]=rc},e.getNumberOfTypes=()=>t.maxId+1,e.isType=t=>{const n=e.getNumberOfTypes();for(let r=0;r<n;++r)if(t===e.getCellType(r))return!0;return!1},e.insertNextType=t=>e.insertNextCell(t,-1),e.getCellType=e=>t.typeArray[e],e.reset=()=>{t.maxId=-1},e.deepCopy=n=>{e.allocate(n.getSize(),n.getExtend()),t.typeArray.set(n.getTypeArray()),t.locationArray.set(n.getLocationArray()),t.maxId=n.getMaxId()}}(e,t)}var yc={newInstance:Wt.newInstance(Tc,&quot;vtkCellTypes&quot;),extend:Tc,...hc};const bc={NO_INTERSECTION:0,YES_INTERSECTION:1,ON_LINE:2};var xc={IntersectionState:bc};const{IntersectionState:Cc}=xc;function Sc(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:null;const o={t:Number.MIN_VALUE,distance:0},a=[];let i;a[0]=n[0]-t[0],a[1]=n[1]-t[1],a[2]=n[2]-t[2];const s=a[0]*(e[0]-t[0])+a[1]*(e[1]-t[1])+a[2]*(e[2]-t[2]),l=Lo(a,a);let c=1e-5*s;return 0!==l&&(o.t=s/l),c<0&&(c=-c),-c<l&&l<c||l<=0||o.t<0?i=t:o.t>1?i=n:(i=a,a[0]=t[0]+o.t*a[0],a[1]=t[1]+o.t*a[1],a[2]=t[2]+o.t*a[2]),r&&(r[0]=i[0],r[1]=i[1],r[2]=i[2]),o.distance=Go(i,e),o}function Ac(e,t,n,r,o,a){const i=[],s=[],l=[];o[0]=0,a[0]=0,Mo(t,e,i),Mo(r,n,s),Mo(n,e,l);const c=[Lo(i,i),-Lo(i,s),-Lo(i,s),Lo(s,s)],u=[];if(u[0]=Lo(i,l),u[1]=-Lo(s,l),0===sa(c,u,2)){let i=Number.MAX_VALUE;const s=[e,t,n,r],l=[n,n,e,e],c=[r,r,t,t];let u;a[0],a[0],o[0],o[0],o[0],o[0],a[0],a[0];for(let e=0;e<4;e++)u=Sc(s[e],l[e],c[e]),u.distance<i&&(i=u.distance,u.t);return Cc.ON_LINE}return o[0]=u[0],a[0]=u[1],o[0]>=0&&o[0]<=1&&a[0]>=0&&a[0]<=1?Cc.YES_INTERSECTION:Cc.NO_INTERSECTION}const Ic={distanceToLine:Sc,intersection:Ac},wc={orientations:null};function Oc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,wc,n),Jl.extend(e,t,n),Wt.setGet(e,t,[&quot;orientations&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkLine&quot;),e.getCellDimension=()=>1,e.intersectWithLine=(e,n,r,o,a)=>{const i={intersect:0,t:Number.MAX_VALUE,subId:0,betweenPoints:null};a[1]=0,a[2]=0;const s=[],l=[],c=[];t.points.getPoint(0,l),t.points.getPoint(1,c);const u=[],d=[],p=Ac(e,n,l,c,u,d);var f;if(i.t=u[0],i.betweenPoints=(f=i.t)>=0&&f<=1,a[0]=d[0],p===Cc.YES_INTERSECTION){for(let t=0;t<3;t++)o[t]=l[t]+a[0]*(c[t]-l[t]),s[t]=e[t]+i.t*(n[t]-e[t]);if(Go(o,s)<=r*r)return i.intersect=1,i}else{let t;if(i.t<0)return t=Sc(e,l,c,o),t.distance<=r*r?(i.t=0,i.intersect=1,i.betweenPoints=!0,i):i;if(i.t>1)return t=Sc(n,l,c,o),t.distance<=r*r?(i.t=1,i.intersect=1,i.betweenPoints=!0,i):i;if(a[0]<0)return a[0]=0,t=Sc(l,e,n,o),i.t=t.t,t.distance<=r*r?(i.intersect=1,i):i;if(a[0]>1)return a[0]=1,t=Sc(c,e,n,o),i.t=t.t,t.distance<=r*r?(i.intersect=1,i):i}return i},e.evaluateLocation=(e,n,r)=>{const o=[],a=[];t.points.getPoint(0,o),t.points.getPoint(1,a);for(let t=0;t<3;t++)n[t]=o[t]+e[0]*(a[t]-o[t]);r[0]=1-e[0],r[1]=e[0]},e.evaluateOrientation=(e,n,r)=>!!t.orientations&&(function(e,t,n,r){var o,a,s,l,c,u=t[0],d=t[1],p=t[2],f=t[3],g=n[0],m=n[1],h=n[2],v=n[3];(a=u*g+d*m+p*h+f*v)<0&&(a=-a,g=-g,m=-m,h=-h,v=-v),1-a>i?(o=Math.acos(a),s=Math.sin(o),l=Math.sin((1-r)*o)/s,c=Math.sin(r*o)/s):(l=1-r,c=r),e[0]=l*u+c*g,e[1]=l*d+c*m,e[2]=l*p+c*h,e[3]=l*f+c*v}(n,t.orientations[0],t.orientations[1],e[0]),r[0]=1-e[0],r[1]=e[0],!0)}(e,t)}var Pc={newInstance:Wt.newInstance(Oc,&quot;vtkLine&quot;),extend:Oc,...Ic,...xc};const Rc={};function Mc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Rc,n),Us.extend(e,t,n),Wt.setGet(e,t,[&quot;points&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkPointSet&quot;),t.points?t.points=ze(t.points):t.points=Yl.newInstance(),e.getNumberOfPoints=()=>t.points.getNumberOfPoints(),e.getBounds=()=>t.points.getBounds(),e.computeBounds=()=>{e.getBounds()};const n=e.shallowCopy;e.shallowCopy=function(e){n(e,arguments.length>1&&void 0!==arguments[1]&&arguments[1]),t.points=Yl.newInstance(),t.points.shallowCopy(e.getPoints())};const r=e.getMTime;e.getMTime=()=>{const e=r();return Math.max(e,t.points?.getMTime()??e)};const o=e.initialize;e.initialize=()=>(t.points?.initialize(),o())}(e,t)}var Ec={newInstance:Wt.newInstance(Mc,&quot;vtkPointSet&quot;),extend:Mc};const Vc={orientations:null,distanceFunction:function(e,t){var n=t[0]-e[0],r=t[1]-e[1],o=t[2]-e[2];return Math.hypot(n,r,o)}};function Dc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Vc,n),Jl.extend(e,t,n),Wt.setGet(e,t,[&quot;orientations&quot;,&quot;distanceFunction&quot;]),t.distancesTime={},Wt.obj(t.distancesTime,{mtime:0}),function(e,t){t.classHierarchy.push(&quot;vtkPolyLine&quot;);const n=Pc.newInstance();n.getPoints().setNumberOfPoints(2),e.getCellDimension=()=>1,e.intersectWithLine=(r,o,a,i,s,l,c)=>{const u={intersect:0,t:Number.MAX_VALUE,subId:0,betweenPoints:null},d=e.getNumberOfPoints()-1;let p=Number.MAX_VALUE;for(let e=0;e<d;e++){const d=[0,0,0];n.getPoints().getData().set(t.points.getData().subarray(3*e,3*(e+2)));const f=n.intersectWithLine(a,i,s,l,c);if(1===f.intersect&&f.t<=u.t+s&&f.t>=r&&f.t<=o){u.intersect=1;const t=n.getParametricDistance(d);if(t<p||t===p&&f.t<u.t){u.subId=e,u.t=f.t,p=t;for(let e=0;e<3;e++)l[e],d[e]}}}return u},e.evaluateLocation=(e,r,o,a)=>(n.getPoints().getData().set(t.points.getData().subarray(3*e,3*(e+2))),n.evaluateLocation(r,o,a)),e.evaluateOrientation=(e,r,o,a)=>(t.orientations?n.setOrientations([t.orientations[e],t.orientations[e+1]]):n.setOrientations(null),n.evaluateOrientation(r,o,a)),e.getDistancesToFirstPoint=()=>{const n=t.distancesTime.getMTime();if(n<t.points.getMTime()||n<e.getMTime()){const n=e.getNumberOfPoints();if(t.distances?t.distances.length=n:t.distances=new Array(n),n>0){const e=new Array(3),a=new Array(3);let i=0;t.distances[0]=i,t.points.getPoint(0,e);for(let s=1;s<n;++s)t.points.getPoint(s,a),i+=t.distanceFunction(e,a),t.distances[s]=i,o=a,(r=e)[0]=o[0],r[1]=o[1],r[2]=o[2]}t.distancesTime.modified()}var r,o;return t.distances},e.findPointIdAtDistanceFromFirstPoint=t=>{const n=e.getDistancesToFirstPoint();if(n.length<2)return-1;let r=0,o=n.length-1;if(t<n[r]||t>n[o]||0===n[o])return-1;for(;o-r>1;){const e=Math.floor((r+o)/2);n[e]<=t?r=e:o=e}return r}}(e,t)}var Lc={newInstance:Wt.newInstance(Dc,&quot;vtkPolyLine&quot;),extend:Dc};const Bc={elements:[]};function Nc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Bc,n),Wt.obj(e,t),function(e,t){t.classHierarchy.push(&quot;vtkPriorityQueue&quot;),e.push=(e,n)=>{const r=t.elements.findIndex((t=>t.priority>e));t.elements.splice(r,0,{priority:e,element:n})},e.pop=()=>t.elements.length>0?t.elements.shift().element:null,e.deleteById=e=>{t.elements=t.elements.filter((t=>{let{element:n}=t;return n.id!==e}))},e.length=()=>t.elements.length}(e,t)}var Fc={newInstance:Wt.newInstance(Nc,&quot;vtkPriorityQueue&quot;),extend:Nc};const _c=1e-6,kc=1.1920929e-7,Gc={FAILURE:-1,OUTSIDE:0,INSIDE:1,INTERSECTION:2,ON_LINE:3};function Uc(e,t,n,r,o){return(r[e]-n[e])*(o[t]-n[t])-(o[e]-n[e])*(r[t]-n[t])}const zc={PolygonWithPointIntersectionState:Gc,pointInPolygon:function(e,t,n,r){if(e[0]<n[0]||e[0]>n[1]||e[1]<n[2]||e[1]>n[3]||e[2]<n[4]||e[2]>n[5])return Gc.OUTSIDE;if(Fo(r)<=kc)return Gc.FAILURE;let o=1e-8*((n[1]-n[0])*(n[1]-n[0])+(n[3]-n[2])*(n[3]-n[2])+(n[5]-n[4])*(n[5]-n[4]));o*=o,o=0===o?kc:o;const a=[],i=[];for(let n=0;n<t.length;){if(a[0]=t[n++],a[1]=t[n++],a[2]=t[n++],Go(e,a)<=o)return Gc.INSIDE;const{distance:r,t:s}=Pc.distanceToLine(e,a,i);if(r<=o&&s>0&&s<1)return Gc.INSIDE}let s,l;Math.abs(r[0])>Math.abs(r[1])?Math.abs(r[0])>Math.abs(r[2])?(s=1,l=2):(s=0,l=1):Math.abs(r[1])>Math.abs(r[2])?(s=0,l=2):(s=0,l=1);let c=0;for(let n=0;n<t.length;)a[0]=t[n++],a[1]=t[n++],a[2]=t[n++],n<t.length?(i[0]=t[n],i[1]=t[n+1],i[2]=t[n+2]):(i[0]=t[0],i[1]=t[1],i[2]=t[2]),a[l]<=e[l]?i[l]>e[l]&&Uc(s,l,a,i,e)>0&&++c:i[l]<=e[l]&&Uc(s,l,a,i,e)<0&&--c;return 0===c?Gc.OUTSIDE:Gc.INSIDE},getBounds:function(e,t,n){const r=e.length,o=[];t.getPoint(e[0],o),n[0]=o[0],n[1]=o[0],n[2]=o[1],n[3]=o[1],n[4]=o[2],n[5]=o[2];for(let a=1;a<r;a++)t.getPoint(e[a],o),Gi.addPoint(n,...o);const a=Gi.getLengths(n);return Lo(a,a)},getNormal:function(e,t,n){n.length=3,n[0]=0,n[1]=0,n[2]=0;const r=[];let o=[],a=[];const i=[],s=[];t.getPoint(e[0],r),t.getPoint(e[1],o);for(let l=2;l<e.length;l++){t.getPoint(e[l],a),Mo(a,o,i),Mo(r,o,s);const c=[0,0,0];Bo(i,s,c),Ro(n,c,n),[o,a]=[a,o]}return Fo(n)},computeCentroid:function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[0,0,0];n[0]=0,n[1]=0,n[2]=0;const r=e.length,o=[];for(let a=0;a<r;a++)t.getPoint(e[a],o),n[0]+=o[0],n[1]+=o[1],n[2]+=o[2];return n[0]/=r,n[1]/=r,n[2]/=r,n}};function Wc(e,t){function n(e){const n=[0,0,0],r=[0,0,0],o=[0,0,0],a=[0,0,0];Mo(e.point,e.previous.point,n),Mo(e.next.point,e.point,r),Mo(e.previous.point,e.next.point,o),Bo(n,r,a);const i=Lo(a,t.normal);if(i<=0)return-1;const s=No(n)+No(r)+No(o);return s*s/i}function r(e){if(t.pointCount<=3)return!0;const n=e.previous,r=e.next,o=[0,0,0];Mo(r.point,n.point,o);const a=[0,0,0];if(Bo(o,t.normal,a),Fo(a),0===No(a))return!1;let i=ei.evaluate(a,n.point,r.next.point),s=i>_c?1:i<-1e-6?-1:0,l=s<0?1:0;for(let e=r.next.next;e.id!==n.id;e=e.next){const t=e.previous;i=ei.evaluate(a,n.point,e.point);const o=i>_c?1:i<-1e-6?-1:0;if(o!==s){if(l||(l=o<=0?1:0),Pc.intersection(n.point,r.point,e.point,t.point,[0],[0])===bc.YES_INTERSECTION)return!1;s=o}}return 1===l}function o(e,r){t.pointCount-=1;const o=e.previous,a=e.next;t.tris=t.tris.concat(e.point),t.tris=t.tris.concat(a.point),t.tris=t.tris.concat(o.point),o.next=a,a.previous=o,r.deleteById(o.id),r.deleteById(a.id);const i=n(o);i>0&&r.push(i,o);const s=n(a);s>0&&r.push(s,a),e.id===t.firstPoint.id&&(t.firstPoint=a)}t.classHierarchy.push(&quot;vtkPolygon&quot;),e.triangulate=()=>t.firstPoint?function(){!function(){const e=[0,0,0],n=[0,0,0];t.normal=[0,0,0];const r=[...t.firstPoint.point];let o=t.firstPoint;for(let a=0;a<t.pointCount;a++){Mo(o.point,r,e),Mo(o.next.point,r,n);const a=[0,0,0];Bo(e,n,a),Ro(t.normal,a,t.normal),o=o.next}Fo(t.normal)}();const e=Fc.newInstance();let a=t.firstPoint;for(let r=0;r<t.pointCount;r++){const t=n(a);t>0&&e.push(t,a),a=a.next}for(;t.pointCount>2&&e.length()>0;)if(t.pointCount===e.length())o(e.pop(),e);else{const t=e.pop();r(t)&&o(t,e)}return t.pointCount<=2}():null,e.setPoints=e=>{t.pointCount=e.length,t.firstPoint={id:0,point:e[0],next:null,previous:null};let n=t.firstPoint;for(let r=1;r<t.pointCount;r++)n.next={id:r,point:e[r],next:null,previous:n},n=n.next;t.firstPoint.previous=n,n.next=t.firstPoint},e.getPointArray=()=>t.tris}const Hc={firstPoint:null,pointCount:0,tris:[]};function jc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Hc,n),Wt.obj(e,t),Wc(e,t)}var Kc={newInstance:Wt.newInstance(jc,&quot;vtkPolygon&quot;),extend:jc,...zc};function $c(e,t,n,r){const o=n[0]-t[0],a=n[1]-t[1],i=n[2]-t[2],s=e[0]-t[0],l=e[1]-t[1],c=e[2]-t[2];r[0]=a*c-i*l,r[1]=i*s-o*c,r[2]=o*l-a*s}function qc(e,t,n,r){$c(e,t,n,r);const o=Math.sqrt(r[0]*r[0]+r[1]*r[1]+r[2]*r[2]);0!==o&&(r[0]/=o,r[1]/=o,r[2]/=o)}function Xc(e){e[0]=-1,e[1]=1,e[2]=0,e[3]=-1,e[4]=0,e[5]=1}const Yc={computeNormalDirection:$c,computeNormal:qc,interpolationDerivs:Xc,intersectWithTriangle:function(e,t,n,r,o,a){let i=arguments.length>6&&void 0!==arguments[6]?arguments[6]:1e-6,s=!1;const l=[],c=[],u=[],d=[],p=[];qc(e,t,n,d),qc(r,o,a,p);const f=-Lo(d,e),g=-Lo(p,r),m=[Lo(p,e)+g,Lo(p,t)+g,Lo(p,n)+g];if(m[0]*m[1]>i&&m[0]*m[2]>i)return{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};const h=[Lo(d,r)+f,Lo(d,o)+f,Lo(d,a)+f];if(h[0]*h[1]>i&&h[0]*h[2]>i)return{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};if(Math.abs(d[0]-p[0])<1e-9&&Math.abs(d[1]-p[1])<1e-9&&Math.abs(d[2]-p[2])<1e-9&&Math.abs(f-g)<1e-9)return s=!0,{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};const v=[e,t,n],T=[r,o,a],y=Lo(d,p),b=(f-g*y)/(y*y-1),x=(g-f*y)/(y*y-1),C=[b*d[0]+x*p[0],b*d[1]+x*p[1],b*d[2]+x*p[2]],S=Bo(d,p,[]);Fo(S);let A=0,I=0;const w=[],O=[];let P,R,M=50,E=50;for(let t=0;t<3;t++){const n=t,o=(t+1)%3,a=ei.intersectWithLine(v[n],v[o],r,p);a.intersection&&a.t>0-i&&a.t<1+i&&(a.t<1+i&&a.t>1-i&&(M=A),w[A++]=Lo(a.x,S)-Lo(C,S));const s=ei.intersectWithLine(T[n],T[o],e,d);s.intersection&&s.t>0-i&&s.t<1+i&&(s.t<1+i&&s.t>1-i&&(E=I),O[I++]=Lo(s.x,S)-Lo(C,S))}if(A>2){A--;const e=w[2];w[2]=w[M],w[M]=e}if(I>2){I--;const e=O[2];O[2]=O[E],O[E]=e}if(2!==A||2!==I)return{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};if(Number.isNaN(w[0])||Number.isNaN(w[1])||Number.isNaN(O[0])||Number.isNaN(O[1]))return{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};if(w[0]>w[1]){const e=w[1];w[1]=w[0],w[0]=e}if(O[0]>O[1]){const e=O[1];O[1]=O[0],O[0]=e}return w[1]<O[0]||O[1]<w[0]?{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u}:(w[0]<O[0]?w[1]<O[1]?(u[0]=2,u[1]=1,P=O[0],R=w[1]):(u[0]=2,u[1]=2,P=O[0],R=O[1]):w[1]<O[1]?(u[0]=1,u[1]=1,P=w[0],R=w[1]):(u[0]=1,u[1]=2,P=w[0],R=O[1]),Do(C,S,P,l),Do(C,S,R,c),{intersect:!0,coplanar:s,pt1:l,pt2:c,surfaceId:u})}},Zc={};function Qc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Zc,n),Jl.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkTriangle&quot;),e.getCellDimension=()=>2,e.intersectWithLine=(n,r,o,a,i)=>{const s={subId:0,t:Number.MAX_VALUE,intersect:0,betweenPoints:!1};i[2]=0;const l=[],c=o*o,u=[],d=[],p=[];t.points.getPoint(0,u),t.points.getPoint(1,d),t.points.getPoint(2,p);const f=[],g=[];if(qc(u,d,p,f),0!==f[0]||0!==f[1]||0!==f[2]){const t=ei.intersectWithLine(n,r,u,f);if(s.betweenPoints=t.betweenPoints,s.t=t.t,a[0]=t.x[0],a[1]=t.x[1],a[2]=t.x[2],!t.intersection)return i[0]=0,i[1]=0,s.intersect=0,s;const o=e.evaluatePosition(a,l,i,g);if(o.evaluation>=0)return o.dist2<=c?(s.intersect=1,s):(s.intersect=o.evaluation,s)}const m=Go(u,d),h=Go(d,p),v=Go(p,u);t.line||(t.line=Pc.newInstance()),m>h&&m>v?(t.line.getPoints().setPoint(0,u),t.line.getPoints().setPoint(1,d)):h>v&&h>m?(t.line.getPoints().setPoint(0,d),t.line.getPoints().setPoint(1,p)):(t.line.getPoints().setPoint(0,p),t.line.getPoints().setPoint(1,u));const T=t.line.intersectWithLine(n,r,o,a,i);if(s.betweenPoints=T.betweenPoints,s.t=T.t,T.intersect){const e=[],t=[],n=[];for(let r=0;r<3;r++)e[r]=u[r]-p[r],t[r]=d[r]-p[r],n[r]=a[r]-p[r];return i[0]=Lo(n,e)/v,i[1]=Lo(n,t)/h,s.intersect=1,s}return i[0]=0,i[1]=0,s.intersect=0,s},e.evaluatePosition=(e,n,r,o)=>{const a={subId:0,dist2:0,evaluation:-1};let i,s;const l=[],c=[],u=[],d=[];let p;const f=[],g=[],m=[];let h=0,v=0;const T=[];let y,b,x,C=[];const S=[],A=[],I=[];a.subId=0,r[2]=0,t.points.getPoint(1,l),t.points.getPoint(2,c),t.points.getPoint(0,u),$c(l,c,u,d),ei.generalizedProjectPoint(e,l,d,I);let w=0;for(i=0;i<3;i++)p=d[i]<0?-d[i]:d[i],p>w&&(w=p,v=i);for(s=0,i=0;i<3;i++)i!==v&&(T[s++]=i);for(i=0;i<2;i++)f[i]=I[T[i]]-u[T[i]],g[i]=l[T[i]]-u[T[i]],m[i]=c[T[i]]-u[T[i]];if(h=Wo(g,m),0===h)return r[0]=0,r[1]=0,a.evaluation=-1,a;if(r[0]=Wo(f,m)/h,r[1]=Wo(g,f)/h,o[0]=1-(r[0]+r[1]),o[1]=r[0],o[2]=r[1],o[0]>=0&&o[0]<=1&&o[1]>=0&&o[1]<=1&&o[2]>=0&&o[2]<=1)n&&(a.dist2=Go(I,e),n[0]=I[0],n[1]=I[1],n[2]=I[2]),a.evaluation=1;else{let t;if(n)if(o[1]<0&&o[2]<0)for(y=Go(e,u),b=Pc.distanceToLine(e,l,u,t,S),x=Pc.distanceToLine(e,u,c,t,A),y<b?(a.dist2=y,C=u):(a.dist2=b,C=S),x<a.dist2&&(a.dist2=x,C=A),i=0;i<3;i++)n[i]=C[i];else if(o[2]<0&&o[0]<0)for(y=Go(e,l),b=Pc.distanceToLine(e,l,u,t,S),x=Pc.distanceToLine(e,l,c,t,A),y<b?(a.dist2=y,C=l):(a.dist2=b,C=S),x<a.dist2&&(a.dist2=x,C=A),i=0;i<3;i++)n[i]=C[i];else if(o[1]<0&&o[0]<0)for(y=Go(e,c),b=Pc.distanceToLine(e,c,u,t,S),x=Pc.distanceToLine(e,l,c,t,A),y<b?(a.dist2=y,C=c):(a.dist2=b,C=S),x<a.dist2&&(a.dist2=x,C=A),i=0;i<3;i++)n[i]=C[i];else if(o[0]<0){const t=Pc.distanceToLine(e,l,c,n);a.dist2=t.distance}else if(o[1]<0){const t=Pc.distanceToLine(e,c,u,n);a.dist2=t.distance}else if(o[2]<0){const t=Pc.distanceToLine(e,l,u,n);a.dist2=t.distance}a.evaluation=0}return a},e.evaluateLocation=(e,n,r)=>{const o=[],a=[],i=[];t.points.getPoint(0,o),t.points.getPoint(1,a),t.points.getPoint(2,i);const s=1-e[0]-e[1];for(let t=0;t<3;t++)n[t]=o[t]*s+a[t]*e[0]+i[t]*e[1];r[0]=s,r[1]=e[0],r[2]=e[1]},e.getParametricDistance=e=>{let t,n=0;const r=[];r[0]=e[0],r[1]=e[1],r[2]=1-e[0]-e[1];for(let e=0;e<3;e++)t=r[e]<0?-r[e]:r[e]>1?r[e]-1:0,t>n&&(n=t);return n},e.derivatives=(e,n,r,o,a)=>{const i=t.points.getPoint(0),s=t.points.getPoint(1),l=t.points.getPoint(2),c=[],u=[],d=[],p=[];qc(i,s,l,c),Mo(s,i,u),Mo(l,i,p),Bo(c,u,d);const f=Fo(u);if(f<=0||Fo(d)<=0){for(let e=0;e<o;e++)for(let t=0;t<3;t++)a[e*o+t]=0;return}const g=[0,0],m=[f,0],h=[Lo(p,u),Lo(p,d)],v=new Array(6);Xc(v);const T=[m[0]-g[0],m[1]-g[1],h[0]-g[0],h[1]-g[1]],y=Wt.newTypedArray(ot.Float64Array,4);la(T,y,2);for(let e=0;e<o;e++){let t=0,n=0;for(let a=0;a<3;a++)t+=v[a]*r[o*a+e],n+=v[3+a]*r[o*a+e];const i=t*y[0]+n*y[1],s=t*y[2]+n*y[3];a[3*e]=i*u[0]+s*d[0],a[3*e+1]=i*u[1]+s*d[1],a[3*e+2]=i*u[2]+s*d[2]}},e.cellBoundary=(e,n,r)=>{const o=n[0]-n[1],a=.5*(1-n[0])-n[1],i=2*n[0]+n[1]-1;return o>=0&&a>=0?(r[0]=t.pointsIds[0],r[1]=t.pointsIds[1]):a<0&&i>=0?(r[0]=t.pointsIds[1],r[1]=t.pointsIds[2]):(r[0]=t.pointsIds[2],r[1]=t.pointsIds[0]),!(n[0]<0||n[1]<0||n[0]>1||n[1]>1||1-n[0]-n[1]<0)}}(e,t)}var Jc={newInstance:Wt.newInstance(Qc,&quot;vtkTriangle&quot;),extend:Qc,...Yc};const eu={};function tu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,eu,n),Jl.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkQuad&quot;),e.getCellDimension=()=>2,e.getCellType=()=>dc,e.getNumberOfEdges=()=>4,e.getNumberOfFaces=()=>0,e.intersectWithLine=(e,n,r,o,a)=>{let i,s={subId:0,t:Number.MAX_VALUE,intersect:0,betweenPoints:!1};const l=t.points.getPoint(0,[]),c=t.points.getPoint(1,[]),u=t.points.getPoint(2,[]),d=t.points.getPoint(3,[]),p=Go(l,u),f=Go(c,d);if(p===f){let e,n=0,r=0;for(let o=0;o<4;o++)e=t.pointsIds[o],e>n&&(n=e,r=o);i=0===r||2===r?0:1}else i=p<f?0:1;let g,m=null;t.triangle?m=t.triangle.getPoints():(t.triangle=Jc.newInstance(),m=Yl.newInstance(),m.setNumberOfPoints(3),t.triangle.initialize(m));const h=[0,0,0],v=[0,0,0];let T;const y=[0,0,0],b=[0,0,0];let x,C;switch(i){case 0:m.setPoint(0,...l),m.setPoint(1,...c),m.setPoint(2,...u),g=t.triangle.intersectWithLine(e,n,r,h,v),m.setPoint(0,...u),m.setPoint(1,...d),m.setPoint(2,...l),T=t.triangle.intersectWithLine(e,n,r,y,b),x=g.intersect&&T.intersect?g.t<=T.t:g.intersect,C=g.intersect&&T.intersect?T.t<g.t:T.intersect,x?(s=g,o[0]=h[0],o[1]=h[1],o[2]=h[2],a[0]=v[0]+v[1],a[1]=v[1],a[2]=v[2]):C&&(s=T,o[0]=y[0],o[1]=y[1],o[2]=y[2],a[0]=1-(b[0]+b[1]),a[1]=1-b[1],a[2]=b[2]);break;case 1:m.setPoint(0,...l),m.setPoint(1,...c),m.setPoint(2,...d),g=t.triangle.intersectWithLine(e,n,r,h,v),m.setPoint(0,...u),m.setPoint(1,...d),m.setPoint(2,...c),T=t.triangle.intersectWithLine(e,n,r,y,b),x=g.intersect&&T.intersect?g.t<=T.t:g.intersect,C=g.intersect&&T.intersect?T.t<g.t:T.intersect,x?(s=g,o[0]=h[0],o[1]=h[1],o[2]=h[2],a[0]=v[0],a[1]=v[1],a[2]=v[2]):C&&(s=T,o[0]=y[0],o[1]=y[1],o[2]=y[2],a[0]=1-b[0],a[1]=1-b[1],a[2]=b[2])}return s},e.interpolationFunctions=(e,t)=>{const n=1-e[0],r=1-e[1];t[0]=n*r,t[1]=e[0]*r,t[2]=e[0]*e[1],t[3]=n*e[1]},e.evaluateLocation=(n,r,o)=>{const a=[];e.interpolationFunctions(n,o),r[0]=0,r[1]=0,r[2]=0;for(let e=0;e<4;e++){t.points.getPoint(e,a);for(let t=0;t<3;t++)r[t]+=a[t]*o[e]}}}(e,t)}var nu={newInstance:Wt.newInstance(tu,&quot;vtkQuad&quot;),extend:tu};const{vtkErrorMacro:ru}=Wt;function ou(e){return()=>ru(`vtkTriangleStrip.${e} - NOT IMPLEMENTED`)}const au={decomposeStrip:function(e,t){if(!Array.isArray(e)||e.length<3)return void ru(&quot;decomposeStrip - Invalid points array&quot;);let n=e[0],r=e[1];for(let o=0;o<e.length-2;o++){const a=e[o+2];o%2?t.insertNextCell([r,n,a]):t.insertNextCell([n,r,a]),n=r,r=a}}},iu={line:null,triangle:null,tris:null};function su(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,iu,n),Jl.extend(e,t,n),t.line||(t.line=Pc.newInstance()),t.triangle||(t.triangle=Jc.newInstance()),function(e,t){t.classHierarchy.push(&quot;vtkTriangleStrip&quot;);const n=e.initialize;e.initialize=(e,r)=>{t.triangle.initialize(e,r),n(e,r)},e.getCellType=()=>cc,e.getCellDimension=()=>2,e.getNumberOfEdges=()=>t.pointsIds.length,e.getNumberOfFaces=()=>0,e.evaluatePosition=(e,n,r,o,a)=>{const i=[0,0,0];let s=Number.MAX_VALUE,l=0;const c=[],u=[],d=[];r[2]=0,u[0]=0,u[1]=0,u[2]=0;const p=t.triangle.getPoints();p.setNumberOfPoints(3);const f=t.triangle.getPointsIds().length;for(let e=0;e<f;e++)a[e]=0;for(let o=0;o<f-2;o++){const a=[];p.getPoint(o,a);const f=[];p.getPoint(o+1,f);const g=[];p.getPoint(o+2,g),p.setData(Float32Array.from([...a,...f,...g]),3);const m=t.triangle.evaluatePosition(e,d,i,c),h=m.dist2;m.evaluation>=0&&(h<s||h===s&&0===l)&&(l=m,n&&(n[0]=d[0],n[1]=d[1],n[2]=d[2]),r[0]=i[0],r[1]=i[1],s=h,u[0]=c[0],u[1]=c[1],u[2]=c[2])}return o[0]=s,a[0]=u[0],a[1]=u[1],a[2]=u[2],l},e.evaluateLocation=(e,n,r,o)=>{const a=[[0,1,2],[1,0,2]],i=e%2,s=t.pointsIds.length;for(let e=0;e<s;e++)o[e]=0;const l=1-n[0]-n[1];o[e]=l,o[e+1]=n[0],o[e+2]=n[1];const c=[];t.points.getPoint(e+a[i][0],c);const u=[];t.points.getPoint(e+a[i][1],u);const d=[];t.points.getPoint(e+a[i][2],d);for(let t=0;t<3;t++)r[t]=c[t]*o[e]+u[t]*o[e+1]+d[t]*o[e+2]},e.cellBoundary=(e,n,r)=>{const o=[[0,1,2],[1,0,2]],a=e%2,i=t.triangle.getPointsIds();return i[0]=t.pointsIds[o[a][0]],i[1]=t.pointsIds[o[a][1]],i[2]=t.pointsIds[o[a][2]],t.triangle.cellBoundary(0,n,r)},e.getEdge=e=>{let n,r;const o=t.pointsIds.length;return 0===e?(n=0,r=1):e===o-1?(n=e-1,r=e):(n=e-1,r=e+1),t.line.getPointsIds()[0]=t.pointsIds[n],t.line.getPointsIds()[1]=t.pointsIds[r],t.line.getPoints().setPoint(0,t.points.getPoint(n)),t.line.getPoints().setPoint(1,t.points.getPoint(r)),t.line},e.intersectWithLine=(e,n,r,o,a)=>{const i=t.pointsIds.length-2,s=t.triangle.getPoints();s.setNumberOfPoints(3);for(let l=0;l<i;l++){const i=[];t.points.getPoint(t.pointsIds[l],i);const c=[];t.points.getPoint(t.pointsIds[l+1],c);const u=[];t.points.getPoint(t.pointsIds[l+2],u),s.setData(Float32Array.from([...i,...c,...u]),3);const d=t.triangle.intersectWithLine(e,n,r,o,a);if(d.intersect)return d}return!1},e.triangulate=()=>{const e=t.points.getNumberOfPoints()-2;t.tris=new Array(3*e);const n=[[0,1,2],[1,0,2]];for(let r=0;r<e;r++){const e=r%2;for(let o=0;o<3;o++)t.tris[3*r+o]=r+n[e][o]}return!0},e.getPointArray=()=>t.tris,e.derivatives=(e,n,r,o,a)=>{const i=[];t.points.getPoint(e,i);const s=[];t.points.getPoint(e+1,s);const l=[];t.points.getPoint(e+2,l);const c=t.triangle.getPoints();c.setPoint(0,...i),c.setPoint(1,...s),c.setPoint(2,...l),t.triangle.derivatives(0,n,r,o,a)},e.getParametricCenter=e=>(e[0]=.333333,e[1]=.333333,e[2]=0,Math.floor((t.pointsIds.length-2)/2)),e.contour=(e,t,n,r,o,a,i,s,l,c,u)=>ou(&quot;contour&quot;)(),e.clip=(e,t,n,r,o,a,i,s,l,c)=>ou(&quot;clip&quot;)()}(e,t)}var lu={newInstance:Wt.newInstance(su,&quot;vtkTriangleStrip&quot;),extend:su,...au};const cu=[&quot;verts&quot;,&quot;lines&quot;,&quot;polys&quot;,&quot;strips&quot;],{vtkWarningMacro:uu}=Wt,du={[ic]:Pc,[dc]:nu,[sc]:Pc,[lc]:Jc,[cc]:lu,[sc]:Lc,[uc]:Kc},pu={};function fu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,pu,n),Ec.extend(e,t,n),Wt.get(e,t,[&quot;cells&quot;,&quot;links&quot;]),Wt.setGet(e,t,[&quot;verts&quot;,&quot;lines&quot;,&quot;polys&quot;,&quot;strips&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkPolyData&quot;),cu.forEach((n=>{e[`getNumberOf${function(e){return e.replace(/(?:^\\w|[A-Z]|\\b\\w)/g,(e=>e.toUpperCase())).replace(/\\s+/g,&quot;&quot;)}(n)}`]=()=>t[n].getNumberOfCells(),t[n]?t[n]=ze(t[n]):t[n]=Kl.newInstance()})),e.getNumberOfCells=()=>cu.reduce(((e,n)=>e+t[n].getNumberOfCells()),0);const n=e.shallowCopy;e.shallowCopy=function(e){n(e,arguments.length>1&&void 0!==arguments[1]&&arguments[1]),cu.forEach((n=>{t[n]=Kl.newInstance(),t[n].shallowCopy(e.getReferenceByName(n))}))};const r=e.getMTime;e.getMTime=()=>cu.reduce(((e,n)=>Math.max(e,t[n]?.getMTime()??e)),r());const o=e.initialize;e.initialize=()=>(cu.forEach((e=>t[e]?.initialize())),o()),e.buildCells=()=>{const n=e.getNumberOfVerts(),r=e.getNumberOfLines(),o=e.getNumberOfPolys(),a=e.getNumberOfStrips(),i=n+r+o+a,s=new Uint8Array(i);let l=s;const c=new Uint32Array(i);let u=c;if(n){let e=0;t.verts.getCellSizes().forEach(((t,n)=>{u[n]=e,l[n]=t>1?ac:oc,e+=t+1})),u=u.subarray(n),l=l.subarray(n)}if(r){let e=0;t.lines.getCellSizes().forEach(((t,n)=>{u[n]=e,l[n]=t>2?sc:ic,1===t&&uu(&quot;Building VTK_LINE &quot;,n,&quot; with only one point, but VTK_LINE needs at least two points. Check the input.&quot;),e+=t+1})),u=u.subarray(r),l=l.subarray(r)}if(o){let e=0;t.polys.getCellSizes().forEach(((t,n)=>{switch(u[n]=e,t){case 3:l[n]=lc;break;case 4:l[n]=dc;break;default:l[n]=uc}t<3&&uu(&quot;Building VTK_TRIANGLE &quot;,n,&quot; with less than three points, but VTK_TRIANGLE needs at least three points. Check the input.&quot;),e+=t+1})),u+=u.subarray(o),l+=l.subarray(o)}if(a){let e=0;l.fill(cc,0,a),t.strips.getCellSizes().forEach(((t,n)=>{u[n]=e,e+=t+1}))}t.cells=yc.newInstance(),t.cells.setCellTypes(i,s,c)},e.buildLinks=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;void 0===t.cells&&e.buildCells(),t.links=nc.newInstance(),n>0?t.links.allocate(n):t.links.allocate(e.getPoints().getNumberOfPoints()),t.links.buildLinks(e)},e.getCellType=e=>t.cells.getCellType(e),e.getCellPoints=n=>{const r=e.getCellType(n);let o=null;switch(r){case oc:case ac:o=t.verts;break;case ic:case sc:o=t.lines;break;case lc:case dc:case uc:o=t.polys;break;case cc:o=t.strips;break;default:return o=null,{type:0,cellPointIds:null}}const a=t.cells.getCellLocation(n);return{cellType:r,cellPointIds:o.getCell(a)}},e.getPointCells=e=>t.links.getCells(e),e.getCellEdgeNeighbors=(e,n,r)=>{const o=t.links.getLink(n),a=t.links.getLink(r);return o.cells.filter((t=>t!==e&&-1!==a.cells.indexOf(t)))},e.getCell=function(t){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;const r=e.getCellPoints(t),o=n||du[r.cellType].newInstance();return o.initialize(e.getPoints(),r.cellPointIds),o},e.getMaxCellSize=()=>cu.reduce(((e,n)=>Math.max(e,t[n]?.getMaxCellSize?.()??0)),0)}(e,t)}var gu={newInstance:Wt.newInstance(fu,&quot;vtkPolyData&quot;),extend:fu};const mu={image:null,canvas:null,jsImageData:null,imageBitmap:null,imageLoaded:!1,repeat:!1,interpolate:!1,edgeClamp:!1,mipLevel:0,resizable:!1};function hu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,mu,n),Wt.obj(e,t),Wt.algo(e,t,6,0),Wt.get(e,t,[&quot;canvas&quot;,&quot;image&quot;,&quot;jsImageData&quot;,&quot;imageBitmap&quot;,&quot;imageLoaded&quot;,&quot;resizable&quot;]),Wt.setGet(e,t,[&quot;repeat&quot;,&quot;edgeClamp&quot;,&quot;interpolate&quot;,&quot;mipLevel&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkTexture&quot;),e.imageLoaded=()=>{t.image.removeEventListener(&quot;load&quot;,e.imageLoaded),t.imageLoaded=!0,e.modified()},e.setJsImageData=n=>{t.jsImageData!==n&&(null!==n&&(e.setInputData(null),e.setInputConnection(null),t.image=null,t.canvas=null,t.imageBitmap=null),t.jsImageData=n,t.imageLoaded=!0,e.modified())},e.setImageBitmap=n=>{t.imageBitmap!==n&&(null!==n&&(e.setInputData(null),e.setInputConnection(null),t.image=null,t.canvas=null,t.jsImageData=null),t.imageBitmap=n,t.imageLoaded=!0,e.modified())},e.setCanvas=n=>{t.canvas!==n&&(null!==n&&(e.setInputData(null),e.setInputConnection(null),t.image=null,t.imageBitmap=null,t.jsImageData=null),t.canvas=n,e.modified())},e.setImage=n=>{t.image!==n&&(null!==n&&(e.setInputData(null),e.setInputConnection(null),t.canvas=null,t.jsImageData=null,t.imageBitmap=null),t.image=n,t.imageLoaded=!1,n.complete?e.imageLoaded():n.addEventListener(&quot;load&quot;,e.imageLoaded),e.modified())},e.getDimensionality=()=>{let n=0,r=0,o=1;if(e.getInputData()){const t=e.getInputData();n=t.getDimensions()[0],r=t.getDimensions()[1],o=t.getDimensions()[2]}return t.jsImageData&&(n=t.jsImageData.width,r=t.jsImageData.height),t.canvas&&(n=t.canvas.width,r=t.canvas.height),t.image&&(n=t.image.width,r=t.image.height),t.imageBitmap&&(n=t.imageBitmap.width,r=t.imageBitmap.height),(n>1)+(r>1)+(o>1)},e.getInputAsJsImageData=()=>{if(!t.imageLoaded||e.getInputData())return null;if(t.jsImageData)return t.jsImageData;if(t.imageBitmap)return t.imageBitmap;if(t.canvas)return t.canvas.getContext(&quot;2d&quot;).getImageData(0,0,t.canvas.width,t.canvas.height);if(t.image){const e=t.image.width,n=t.image.height,r=new OffscreenCanvas(e,n).getContext(&quot;2d&quot;);return r.translate(0,n),r.scale(1,-1),r.drawImage(t.image,0,0,e,n),r.getImageData(0,0,e,n)}return null}}(e,t)}var vu={newInstance:Wt.newInstance(hu,&quot;vtkTexture&quot;),extend:hu,generateMipmaps:(e,t,n)=>{const r=e.createShaderModule({code:&quot;\\n    @group(0) @binding(0) var inputTexture: texture_2d<f32>;\\n    @group(0) @binding(1) var outputTexture: texture_storage_2d<rgba8unorm, write>;\\n\\n    @compute @workgroup_size(8, 8)\\n    fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {\\n      let texelCoord = vec2<i32>(global_id.xy);\\n      let outputSize = textureDimensions(outputTexture);\\n\\n      if (texelCoord.x >= i32(outputSize.x) || texelCoord.y >= i32(outputSize.y)) {\\n        return;\\n      }\\n\\n      let inputSize = textureDimensions(inputTexture);\\n      let scale = vec2<f32>(inputSize) / vec2<f32>(outputSize);\\n\\n      // Compute the floating-point source coordinate\\n      let srcCoord = (vec2<f32>(texelCoord) + 0.5) * scale - 0.5;\\n\\n      // Get integer coordinates for the four surrounding texels\\n      let x0 = i32(floor(srcCoord.x));\\n      let x1 = min(x0 + 1, i32(inputSize.x) - 1);\\n      let y0 = i32(floor(srcCoord.y));\\n      let y1 = min(y0 + 1, i32(inputSize.y) - 1);\\n\\n      // Compute the weights\\n      let wx = srcCoord.x - f32(x0);\\n      let wy = srcCoord.y - f32(y0);\\n\\n      // Fetch the four texels\\n      let c00 = textureLoad(inputTexture, vec2<i32>(x0, y0), 0);\\n      let c10 = textureLoad(inputTexture, vec2<i32>(x1, y0), 0);\\n      let c01 = textureLoad(inputTexture, vec2<i32>(x0, y1), 0);\\n      let c11 = textureLoad(inputTexture, vec2<i32>(x1, y1), 0);\\n\\n      // Bilinear interpolation\\n      let color = mix(\\n        mix(c00, c10, wx),\\n        mix(c01, c11, wx),\\n        wy\\n      );\\n\\n      textureStore(outputTexture, texelCoord, color);\\n    }\\n  &quot;}),o=e.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.COMPUTE,texture:{sampleType:&quot;float&quot;}},{binding:1,visibility:GPUShaderStage.COMPUTE,storageTexture:{format:&quot;rgba8unorm&quot;,access:&quot;write-only&quot;}},{binding:2,visibility:GPUShaderStage.COMPUTE,sampler:{type:&quot;filtering&quot;}}]}),a=e.createPipelineLayout({bindGroupLayouts:[o]}),i=e.createComputePipeline({label:&quot;ComputeMipmapPipeline&quot;,layout:a,compute:{module:r,entryPoint:&quot;main&quot;}}),s=e.createSampler({magFilter:&quot;linear&quot;,minFilter:&quot;linear&quot;});for(let r=1;r<n;r++){const n=t.createView({baseMipLevel:r-1,mipLevelCount:1}),o=t.createView({baseMipLevel:r,mipLevelCount:1}),a=e.createBindGroup({layout:i.getBindGroupLayout(0),entries:[{binding:0,resource:n},{binding:1,resource:o},{binding:2,resource:s}]}),l=e.createCommandEncoder({label:&quot;MipmapGenerateCommandEncoder&quot;}),c=l.beginComputePass();c.setPipeline(i),c.setBindGroup(0,a);const u=Math.max(1,t.width>>r),d=Math.max(1,t.height>>r),p=Math.ceil(u/8),f=Math.ceil(d/8);c.dispatchWorkgroups(p,f),c.end(),e.queue.submit([l.finish()])}}};const Tu=[[-1,0,0],[1,0,0],[0,-1,0],[0,1,0],[0,0,-1],[0,0,1]],yu=[[8,7,11,3],[9,1,10,5],[4,9,0,8],[2,11,6,10],[0,3,2,1],[4,5,6,7]],bu=[[0,1],[1,3],[2,3],[0,2],[4,5],[5,7],[6,7],[4,6],[0,4],[1,5],[3,7],[2,6]],xu=[0,1,0,1,0,1,0,1,2,2,2,2],Cu=[[1,2],[1,2],[0,2],[0,2],[0,1],[0,1]],Su=new Float64Array(3),Au=new Float64Array(3),Iu=new Float64Array(3),wu=new Float64Array(3),Ou=new Float64Array(3),Pu=new Float64Array(3),Ru=new Float64Array(16);function Mu(e,t){e.strokeStyle=t.strokeColor,e.lineWidth=t.strokeSize,e.fillStyle=t.fontColor,e.font=`${t.fontStyle} ${t.fontSize}px ${t.fontFamily}`}function Eu(e){const t=[],n=[];for(let r=0;r<3;r++){const o=ro().domain([e[2*r],e[2*r+1]]);t[r]=o.ticks(5);const a=o.tickFormat(5);n[r]=t[r].map(a)}return{ticks:t,tickStrings:n}}const Vu=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{renderable:null};Object.assign(t,{},n),Wt.obj(e,t),t.tmPolyData=gu.newInstance(),t.tmMapper=Gl.newInstance(),t.tmMapper.setInputData(t.tmPolyData),t.tmActor=ss.newInstance({parentProp:e}),t.tmActor.setMapper(t.tmMapper),Wt.setGet(e,t,[&quot;renderable&quot;]),Wt.get(e,t,[&quot;lastSize&quot;,&quot;lastAspectRatio&quot;,&quot;axisTextStyle&quot;,&quot;tickTextStyle&quot;,&quot;tmActor&quot;,&quot;ticks&quot;]),t.forceUpdate=!1,t.lastRedrawTime={},Wt.obj(t.lastRedrawTime,{mtime:0}),t.lastRebuildTime={},Wt.obj(t.lastRebuildTime,{mtime:0}),t.lastSize=[-1,-1],t.lastTickBounds=[],function(e,t){t.classHierarchy.push(&quot;vtkCubeAxesActorHelper&quot;),e.setRenderable=n=>{t.renderable!==n&&(t.renderable=n,t.tmActor.addTexture(t.renderable.getTmTexture()),t.tmActor.setProperty(n.getProperty()),t.tmActor.setParentProp(n),e.modified())},e.createPolyDataForOneLabel=(e,n,r,o,a,i,s)=>{const l=t.renderable.get_tmAtlas().get(e);if(!l)return;const c=t.renderable.getTextPolyData().getPoints().getData(),u=t.lastSize;Su[0]=c[3*n],Su[1]=c[3*n+1],Su[2]=c[3*n+2],In(Iu,Su,r),Iu[0]+=.1,In(Au,Iu,o),Tn(Ou,Au,Su),Iu[0]-=.1,Iu[1]+=.1,In(Au,Iu,o),Tn(Pu,Au,Su);for(let e=0;e<3;e++)Ou[e]/=.05*u[0],Pu[e]/=.05*u[1];let d=s.ptIdx,p=s.cellIdx;Su[0]=c[3*n],Su[1]=c[3*n+1],Su[2]=c[3*n+2],a[0]<-.5?bn(Iu,Ou,a[0]*i-l.width):a[0]>.5?bn(Iu,Ou,a[0]*i):bn(Iu,Ou,a[0]*i-l.width/2),vn(Su,Su,Iu),bn(Iu,Pu,a[1]*i-l.height/2),vn(Su,Su,Iu),s.points[3*d]=Su[0],s.points[3*d+1]=Su[1],s.points[3*d+2]=Su[2],s.tcoords[2*d]=l.tcoords[0],s.tcoords[2*d+1]=l.tcoords[1],d++,bn(Iu,Ou,l.width),vn(Su,Su,Iu),s.points[3*d]=Su[0],s.points[3*d+1]=Su[1],s.points[3*d+2]=Su[2],s.tcoords[2*d]=l.tcoords[2],s.tcoords[2*d+1]=l.tcoords[3],d++,bn(Iu,Pu,l.height),vn(Su,Su,Iu),s.points[3*d]=Su[0],s.points[3*d+1]=Su[1],s.points[3*d+2]=Su[2],s.tcoords[2*d]=l.tcoords[4],s.tcoords[2*d+1]=l.tcoords[5],d++,bn(Iu,Ou,l.width),Tn(Su,Su,Iu),s.points[3*d]=Su[0],s.points[3*d+1]=Su[1],s.points[3*d+2]=Su[2],s.tcoords[2*d]=l.tcoords[6],s.tcoords[2*d+1]=l.tcoords[7],d++,s.polys[4*p]=3,s.polys[4*p+1]=d-4,s.polys[4*p+2]=d-3,s.polys[4*p+3]=d-2,p++,s.polys[4*p]=3,s.polys[4*p+1]=d-4,s.polys[4*p+2]=d-2,s.polys[4*p+3]=d-1,s.ptIdx+=4,s.cellIdx+=2},e.updateTexturePolyData=()=>{const n=t.camera.getCompositeProjectionMatrix(t.lastAspectRatio,-1,1);h(n,n);const r=t.renderable.getTextValues().length,o=4*r,a=2*r,i=new Float64Array(3*o),s=new Uint16Array(4*a),l=new Float32Array(2*o);v(Ru,n);const c={ptIdx:0,cellIdx:0,polys:s,points:i,tcoords:l};let u=0,d=0,p=0;const f=t.renderable.getTextPolyData().getPoints().getData(),g=t.renderable.getTextValues();for(;u<f.length/3;){Su[0]=f[3*u],Su[1]=f[3*u+1],Su[2]=f[3*u+2],In(Iu,Su,n),Su[0]=f[3*u+3],Su[1]=f[3*u+4],Su[2]=f[3*u+5],In(wu,Su,n),Tn(Iu,Iu,wu);const r=[Iu[0],Iu[1]];zo(r),e.createPolyDataForOneLabel(g[d],u,n,Ru,r,t.renderable.getAxisTitlePixelOffset(),c),u+=2,d++;for(let o=0;o<t.renderable.getTickCounts()[p];o++)e.createPolyDataForOneLabel(g[d],u,n,Ru,r,t.renderable.getTickLabelPixelOffset(),c),u++,d++;p++}const m=xs.newInstance({numberOfComponents:2,values:l,name:&quot;TextureCoordinates&quot;});t.tmPolyData.getPointData().setTCoords(m),t.tmPolyData.getPoints().setData(i,3),t.tmPolyData.getPoints().modified(),t.tmPolyData.getPolys().setData(s,1),t.tmPolyData.getPolys().modified(),t.tmPolyData.modified()},e.updateAPISpecificData=(n,r,o)=>{t.lastSize[0]===n[0]&&t.lastSize[1]===n[1]||(t.lastSize[0]=n[0],t.lastSize[1]=n[1],t.lastAspectRatio=n[0]/n[1],t.forceUpdate=!0),t.camera=r,e.updateTexturePolyData()}}(e,t)}),&quot;vtkCubeAxesActorHelper&quot;);function Du(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};ss.extend(e,t,function(e,t,n){return{boundsScaleFactor:1.3,camera:null,dataBounds:[...Gi.INIT_BOUNDS],faceVisibilityAngle:8,gridLines:!0,axisLabels:null,axisTitlePixelOffset:35,tickLabelPixelOffset:12,generateTicks:Eu,...n,axisTextStyle:{fontColor:&quot;white&quot;,fontStyle:&quot;normal&quot;,fontSize:18,fontFamily:&quot;serif&quot;,...n?.axisTextStyle},tickTextStyle:{fontColor:&quot;white&quot;,fontStyle:&quot;normal&quot;,fontSize:14,fontFamily:&quot;serif&quot;,...n?.tickTextStyle}}}(0,0,n)),t.lastFacesToDraw=[!1,!1,!1,!1,!1,!1],t.axisLabels=[&quot;X-Axis&quot;,&quot;Y-Axis&quot;,&quot;Z-Axis&quot;],t.tickCounts=[],t.textValues=[],t.lastTickBounds=[],t.tmCanvas=document.createElement(&quot;canvas&quot;),t.tmContext=t.tmCanvas.getContext(&quot;2d&quot;),t._tmAtlas=new Map,t.tmTexture=vu.newInstance({resizable:!0}),t.tmTexture.setInterpolate(!1),e.getProperty().setDiffuse(0),e.getProperty().setAmbient(1),t.gridMapper=Gl.newInstance(),t.polyData=gu.newInstance(),t.gridMapper.setInputData(t.polyData),t.gridActor=ss.newInstance(),t.gridActor.setMapper(t.gridMapper),t.gridActor.setProperty(e.getProperty()),t.gridActor.setParentProp(e),t.textPolyData=gu.newInstance(),Wt.setGet(e,t,[&quot;axisTitlePixelOffset&quot;,&quot;boundsScaleFactor&quot;,&quot;faceVisibilityAngle&quot;,&quot;gridLines&quot;,&quot;tickLabelPixelOffset&quot;,&quot;generateTicks&quot;]),Wt.setGetArray(e,t,[&quot;dataBounds&quot;],6),Wt.setGetArray(e,t,[&quot;axisLabels&quot;],3),Wt.get(e,t,[&quot;axisTextStyle&quot;,&quot;tickTextStyle&quot;,&quot;camera&quot;,&quot;tmTexture&quot;,&quot;textValues&quot;,&quot;textPolyData&quot;,&quot;tickCounts&quot;,&quot;gridActor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkCubeAxesActor&quot;),e.setCamera=n=>{t.camera!==n&&(t.cameraModifiedSub&&(t.cameraModifiedSub.unsubscribe(),t.cameraModifiedSub=null),t.camera=n,n&&(t.cameraModifiedSub=n.onModified(e.update)),e.update(),e.modified())},e.computeFacesToDraw=()=>{const e=t.camera.getViewMatrix();h(e,e);let n=!1;const r=Gi.getDiagonalLength(t.dataBounds),o=Math.sin(t.faceVisibilityAngle*Math.PI/180);for(let a=0;a<6;a++){let i=!1;const s=Math.floor(a/2),l=(s+1)%3,c=(s+2)%3;t.dataBounds[2*l]!==t.dataBounds[2*l+1]&&t.dataBounds[2*c]!==t.dataBounds[2*c+1]&&(Su[s]=t.dataBounds[a]-.1*r*Tu[a][s],Su[l]=.5*(t.dataBounds[2*l]+t.dataBounds[2*l+1]),Su[c]=.5*(t.dataBounds[2*c]+t.dataBounds[2*c+1]),In(Iu,Su,e),Su[s]=t.dataBounds[a],In(wu,Su,e),Tn(Iu,wu,Iu),Cn(Iu,Iu),i=Iu[2]>o,t.camera.getParallelProjection()||(Cn(wu,wu),i=Sn(wu,Iu)>o)),i!==t.lastFacesToDraw[a]&&(t.lastFacesToDraw[a]=i,n=!0)}return n},e.updatePolyData=(e,n,r)=>{let o=0,a=0;o+=8;let i=0;for(let e=0;e<12;e++)n[e]>0&&i++;if(a+=i,t.gridLines)for(let t=0;t<6;t++)e[t]&&(o+=2*r[Cu[t][0]].length+2*r[Cu[t][1]].length,a+=r[Cu[t][0]].length+r[Cu[t][1]].length);const s=new Float64Array(3*o),l=new Uint32Array(3*a);let c=0,u=0;for(let e=0;e<2;e++)for(let n=0;n<2;n++)for(let r=0;r<2;r++)s[3*c]=t.dataBounds[r],s[3*c+1]=t.dataBounds[2+n],s[3*c+2]=t.dataBounds[4+e],c++;for(let e=0;e<12;e++)n[e]>0&&(l[3*u]=2,l[3*u+1]=bu[e][0],l[3*u+2]=bu[e][1],u++);if(t.gridLines)for(let n=0;n<6;n++)if(e[n]){const e=Math.floor(n/2);let o=r[Cu[n][0]];for(let r=0;r<o.length;r++)s[3*c+e]=t.dataBounds[n],s[3*c+Cu[n][0]]=o[r],s[3*c+Cu[n][1]]=t.dataBounds[2*Cu[n][1]],c++,s[3*c+e]=t.dataBounds[n],s[3*c+Cu[n][0]]=o[r],s[3*c+Cu[n][1]]=t.dataBounds[2*Cu[n][1]+1],c++,l[3*u]=2,l[3*u+1]=c-2,l[3*u+2]=c-1,u++;o=r[Cu[n][1]];for(let r=0;r<o.length;r++)s[3*c+e]=t.dataBounds[n],s[3*c+Cu[n][1]]=o[r],s[3*c+Cu[n][0]]=t.dataBounds[2*Cu[n][0]],c++,s[3*c+e]=t.dataBounds[n],s[3*c+Cu[n][1]]=o[r],s[3*c+Cu[n][0]]=t.dataBounds[2*Cu[n][0]+1],c++,l[3*u]=2,l[3*u+1]=c-2,l[3*u+2]=c-1,u++}t.polyData.getPoints().setData(s,3),t.polyData.getPoints().modified(),t.polyData.getLines().setData(l,1),t.polyData.getLines().modified(),t.polyData.modified()},e.updateTextData=(e,n,r,o)=>{let a=0;for(let e=0;e<12;e++)1===n[e]&&(a+=2,a+=r[xu[e]].length);const i=t.polyData.getPoints().getData(),s=new Float64Array(3*a);let l=0,c=0,u=0;for(let a=0;a<6;a++)if(e[a])for(let e=0;e<4;e++){const d=yu[a][e];if(1===n[d]){const e=xu[d],n=3*bu[d][0],p=3*bu[d][1];s[3*l]=.5*(i[n]+i[p]),s[3*l+1]=.5*(i[n+1]+i[p+1]),s[3*l+2]=.5*(i[n+2]+i[p+2]),l++,s[3*l+Math.floor(a/2)]=t.dataBounds[a],s[3*l+Cu[a][0]]=.5*(t.dataBounds[2*Cu[a][0]]+t.dataBounds[2*Cu[a][0]+1]),s[3*l+Cu[a][1]]=.5*(t.dataBounds[2*Cu[a][1]]+t.dataBounds[2*Cu[a][1]+1]),l++,t.textValues[c]=t.axisLabels[e],c++;const f=(e+1)%3,g=(e+2)%3,m=r[e],h=o[e];t.tickCounts[u]=m.length;for(let r=0;r<m.length;r++)s[3*l+e]=m[r],s[3*l+f]=i[n+f],s[3*l+g]=i[n+g],l++,t.textValues[c]=h[r],c++;u++}}t.textPolyData.getPoints().setData(s,3),t.textPolyData.modified()},e.update=()=>{if(!t.camera)return;const n=e.computeFacesToDraw(),r=t.lastFacesToDraw;let o=!1;for(let e=0;e<6;e++)t.dataBounds[e]!==t.lastTickBounds[e]&&(o=!0,t.lastTickBounds[e]=t.dataBounds[e]);if(n||o||t.forceUpdate){const n=new Array(12).fill(0);for(let e=0;e<6;e++)if(r[e])for(let t=0;t<4;t++)n[yu[e][t]]++;const a=t.generateTicks(t.dataBounds);e.updatePolyData(r,n,a.ticks),e.updateTextData(r,n,a.ticks,a.tickStrings),(o||t.forceUpdate)&&e.updateTextureAtlas(a.tickStrings)}t.forceUpdate=!1},e.updateTextureAtlas=e=>{t.tmContext.textBaseline=&quot;bottom&quot;,t.tmContext.textAlign=&quot;left&quot;,t._tmAtlas.clear();let n=0,r=1;for(let o=0;o<3;o++){if(!t._tmAtlas.has(t.axisLabels[o])){Mu(t.tmContext,t.axisTextStyle);const e=t.tmContext.measureText(t.axisLabels[o]),a={height:e.actualBoundingBoxAscent+2,startingHeight:r,width:e.width+2,textStyle:t.axisTextStyle};t._tmAtlas.set(t.axisLabels[o],a),r+=a.height,n<a.width&&(n=a.width)}Mu(t.tmContext,t.tickTextStyle);for(let a=0;a<e[o].length;a++)if(!t._tmAtlas.has(e[o][a])){const i=t.tmContext.measureText(e[o][a]),s={height:i.actualBoundingBoxAscent+2,startingHeight:r,width:i.width+2,textStyle:t.tickTextStyle};t._tmAtlas.set(e[o][a],s),r+=s.height,n<s.width&&(n=s.width)}}n=wo(n),r=wo(r),t._tmAtlas.forEach((e=>{e.tcoords=[0,(r-e.startingHeight-e.height)/r,e.width/n,(r-e.startingHeight-e.height)/r,e.width/n,(r-e.startingHeight)/r,0,(r-e.startingHeight)/r]})),t.tmCanvas.width=n,t.tmCanvas.height=r,t.tmContext.textBaseline=&quot;bottom&quot;,t.tmContext.textAlign=&quot;left&quot;,t.tmContext.clearRect(0,0,n,r),t._tmAtlas.forEach(((e,n)=>{Mu(t.tmContext,e.textStyle),t.tmContext.fillText(n,1,e.startingHeight+e.height-1)})),t.tmTexture.setCanvas(t.tmCanvas),t.tmTexture.modified()},e.onModified((()=>{t.forceUpdate=!0,e.update()})),e.setTickTextStyle=n=>{t.tickTextStyle={...t.tickTextStyle,...n},e.modified()},e.setAxisTextStyle=n=>{t.axisTextStyle={...t.axisTextStyle,...n},e.modified()},e.get_tmAtlas=()=>t._tmAtlas,e.getBounds=()=>(e.update(),Gi.setBounds(t.bounds,t.gridActor.getBounds()),Gi.scaleAboutCenter(t.bounds,t.boundsScaleFactor,t.boundsScaleFactor,t.boundsScaleFactor),t.bounds);const n=Wt.chain(e.setProperty,t.gridActor.setProperty);e.setProperty=e=>n(e)[0]}(e,t)}var Lu={newInstance:Wt.newInstance(Du,&quot;vtkCubeAxesActor&quot;),extend:Du,newCubeAxesActorHelper:Vu,defaultGenerateTicks:Eu};const Bu={};const Nu=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Bu,n),qt.extend(e,t,n),t.CubeAxesActorHelper=Lu.newCubeAxesActorHelper(),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLCubeAxesActor&quot;),e.buildPass=n=>{n&&(t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getParent(),t.CubeAxesActorHelper.getRenderable()||t.CubeAxesActorHelper.setRenderable(t.renderable),e.prepareNodes(),e.addMissingNode(t.CubeAxesActorHelper.getTmActor()),e.addMissingNode(t.renderable.getGridActor()),e.removeUnusedNodes())},e.opaquePass=(e,n)=>{if(e){const e=t._openGLRenderer?t._openGLRenderer.getRenderable().getActiveCamera():null,n=t._openGLRenderer.getTiledSizeAndOrigin();t.CubeAxesActorHelper.updateAPISpecificData([n.usize,n.vsize],e,t._openGLRenderWindow.getRenderable())}}}(e,t)}),&quot;vtkOpenGLCubeAxesActor&quot;);Jt(&quot;vtkCubeAxesActor&quot;,Nu);const Fu={ARRAY_BUFFER:0,ELEMENT_ARRAY_BUFFER:1,TEXTURE_BUFFER:2};var _u={ObjectType:Fu};const{ObjectType:ku}=_u,Gu={objectType:ku.ARRAY_BUFFER,context:null,allocatedGPUMemoryInBytes:0};function Uu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Gu,n),Wt.obj(e,t),Wt.get(e,t,[&quot;_openGLRenderWindow&quot;,&quot;allocatedGPUMemoryInBytes&quot;]),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){function n(e){switch(e){case ku.ELEMENT_ARRAY_BUFFER:return t.context.ELEMENT_ARRAY_BUFFER;case ku.TEXTURE_BUFFER:if(&quot;TEXTURE_BUFFER&quot;in t.context)return t.context.TEXTURE_BUFFER;case ku.ARRAY_BUFFER:default:return t.context.ARRAY_BUFFER}}t.classHierarchy.push(&quot;vtkOpenGLBufferObject&quot;);let r=null,o=null,a=!0,i=&quot;&quot;;e.getType=()=>r,e.setType=e=>{r=e},e.getHandle=()=>o,e.isReady=()=>!1===a,e.generateBuffer=e=>{const a=n(e);return null===o&&(o=t.context.createBuffer(),r=e),n(r)===a},e.upload=(s,l)=>e.generateBuffer(l)?(t.context.bindBuffer(n(r),o),t.context.bufferData(n(r),s,t.context.STATIC_DRAW),t.allocatedGPUMemoryInBytes=s.length*s.BYTES_PER_ELEMENT,a=!1,!0):(i=&quot;Trying to upload array buffer to incompatible buffer.&quot;,!1),e.bind=()=>!!o&&(t.context.bindBuffer(n(r),o),!0),e.release=()=>!!o&&(t.context.bindBuffer(n(r),null),!0),e.releaseGraphicsResources=()=>{null!==o&&(t.context.bindBuffer(n(r),null),t.context.deleteBuffer(o),o=null,t.allocatedGPUMemoryInBytes=0)},e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))},e.getError=()=>i}(e,t)}var zu={newInstance:Wt.newInstance(Uu),extend:Uu,..._u};function Wu(e){let t=0,n=0;for(let r=0;r<3;++r){const o=e.getRange(r),a=o[1]-o[0];t+=a*a;const i=.5*(o[1]+o[0]);n+=i*i}const r=t>0&&(Math.abs(n)/t>1e6||Math.abs(Math.log10(t))>3||0===t&&n>1e6);if(r){const t=new Float64Array(3),n=new Float64Array(3);for(let r=0;r<3;++r){const o=e.getRange(r),a=o[1]-o[0];t[r]=.5*(o[1]+o[0]),n[r]=a>0?1/a:1}return{useShiftAndScale:r,coordShift:t,coordScale:n}}return{useShiftAndScale:r,coordShift:new Float32Array([0,0,0]),coordScale:new Float32Array([1,1,1])}}const{vtkErrorMacro:Hu}=Wt;const ju={elementCount:0,stride:0,colorBOStride:0,vertexOffset:0,normalOffset:0,tCoordOffset:0,tCoordComponents:0,colorOffset:0,colorComponents:0,tcoordBO:null,customData:[],coordShift:null,coordScale:null,coordShiftAndScaleEnabled:!1,inverseShiftAndScaleMatrix:null};function Ku(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ju,n),zu.extend(e,t,n),Wt.setGet(e,t,[&quot;colorBO&quot;,&quot;elementCount&quot;,&quot;stride&quot;,&quot;colorBOStride&quot;,&quot;vertexOffset&quot;,&quot;normalOffset&quot;,&quot;tCoordOffset&quot;,&quot;tCoordComponents&quot;,&quot;colorOffset&quot;,&quot;colorComponents&quot;,&quot;customData&quot;]),Wt.get(e,t,[&quot;coordShift&quot;,&quot;coordScale&quot;,&quot;coordShiftAndScaleEnabled&quot;,&quot;inverseShiftAndScaleMatrix&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLCellArrayBufferObject&quot;),e.setType(Fu.ARRAY_BUFFER),e.createVBO=function(n,r,o,a){let i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null;if(!n.getData()||!n.getData().length)return t.elementCount=0,0;t.blockSize=3,t.vertexOffset=0,t.normalOffset=0,t.tCoordOffset=0,t.tCoordComponents=0,t.colorComponents=0,t.colorOffset=0,t.customData=[];const s=a.points.getData();let l=null,c=null,u=null;const d=a.colors?a.colors.getNumberOfComponents():0,p=a.tcoords?a.tcoords.getNumberOfComponents():0;a.normals&&(t.normalOffset=4*t.blockSize,t.blockSize+=3,l=a.normals.getData()),a.customAttributes&&a.customAttributes.forEach((e=>{e&&(t.customData.push({data:e.getData(),offset:4*t.blockSize,components:e.getNumberOfComponents(),name:e.getName()}),t.blockSize+=e.getNumberOfComponents())})),a.tcoords&&(t.tCoordOffset=4*t.blockSize,t.tCoordComponents=p,t.blockSize+=p,c=a.tcoords.getData()),a.colors?(t.colorComponents=a.colors.getNumberOfComponents(),t.colorOffset=0,u=a.colors.getData(),t.colorBO||(t.colorBO=zu.newInstance()),t.colorBO.setOpenGLRenderWindow(t._openGLRenderWindow)):t.colorBO=null,t.stride=4*t.blockSize;let f,g=0,m=0,h=0,v=0,T=0,y=0;const b={anythingToPoints(e,t,n,r){for(let o=0;o<e;++o)f(t[n+o],r)},linesToWireframe(e,t,n,r){for(let o=0;o<e-1;++o)f(t[n+o],r),f(t[n+o+1],r)},polysToWireframe(e,t,n,r){if(e>2)for(let o=0;o<e;++o)f(t[n+o],r),f(t[n+(o+1)%e],r)},stripsToWireframe(e,t,n,r){if(e>2){for(let o=0;o<e-1;++o)f(t[n+o],r),f(t[n+o+1],r);for(let o=0;o<e-2;o++)f(t[n+o],r),f(t[n+o+2],r)}},polysToSurface(e,t,n,r){for(let o=0;o<e-2;o++)f(t[n+0],r),f(t[n+o+1],r),f(t[n+o+2],r)},stripsToSurface(e,t,n,r){for(let o=0;o<e-2;o++)f(t[n+o],r),f(t[n+o+1+o%2],r),f(t[n+o+1+(o+1)%2],r)}},x={anythingToPoints(e,t){return e},linesToWireframe(e,t){return e>1?2*(e-1):0},polysToWireframe(e,t){return e>2?2*e:0},stripsToWireframe(e,t){return e>2?4*e-6:0},polysToSurface(e,t){return e>2?3*(e-2):0},stripsToSurface(e,t,n){return e>2?3*(e-2):0}};let C=null,S=null;o===Zi.POINTS||&quot;verts&quot;===r?(C=b.anythingToPoints,S=x.anythingToPoints):o===Zi.WIREFRAME||&quot;lines&quot;===r?(C=b[`${r}ToWireframe`],S=x[`${r}ToWireframe`]):(C=b[`${r}ToSurface`],S=x[`${r}ToSurface`]);const A=n.getData(),I=A.length;let w=0;for(let e=0;e<I;)w+=S(A[e],A),e+=A[e]+1;let O=null;const P=new Float32Array(w*t.blockSize);u&&(O=new Uint8Array(4*w));let R=0,M=0;const{useShiftAndScale:E,coordShift:V,coordScale:D}=Wu(a.points);if(E?e.setCoordShiftAndScale(V,D):!0===t.coordShiftAndScaleEnabled&&e.setCoordShiftAndScale(null,null),i)if(i.points||i.cells){const e=new Int32Array(w+i.points.length);e.set(i.points),i.points=e;const t=new Int32Array(w+i.cells.length);t.set(i.cells),i.cells=t}else i.points=new Int32Array(w),i.cells=new Int32Array(w);let L=a.vertexOffset;f=function(e,n){if(i&&(i.points[L]=e,i.cells[L]=y+a.cellOffset),++L,g=3*e,t.coordShiftAndScaleEnabled?(P[R++]=(s[g++]-t.coordShift[0])*t.coordScale[0],P[R++]=(s[g++]-t.coordShift[1])*t.coordScale[1],P[R++]=(s[g++]-t.coordShift[2])*t.coordScale[2]):(P[R++]=s[g++],P[R++]=s[g++],P[R++]=s[g++]),null!==l&&(m=a.haveCellNormals?3*(y+a.cellOffset):3*e,P[R++]=l[m++],P[R++]=l[m++],P[R++]=l[m++]),t.customData.forEach((t=>{T=e*t.components;for(let e=0;e<t.components;++e)P[R++]=t.data[T++]})),null!==c){h=a.useTCoordsPerCell?n*p:e*p;for(let e=0;e<p;++e)P[R++]=c[h++]}null!==u&&(v=a.haveCellScalars?(y+a.cellOffset)*d:e*d,O[M++]=u[v++],O[M++]=u[v++],O[M++]=u[v++],O[M++]=4===d?u[v++]:255)};for(let e=0;e<I;e+=A[e]+1,y++)C(A[e],A,e+1,y+a.cellOffset);return t.elementCount=w,e.upload(P,Fu.ARRAY_BUFFER),t.colorBO&&(t.colorBOStride=4,t.colorBO.upload(O,Fu.ARRAY_BUFFER)),y},e.setCoordShiftAndScale=(e,n)=>{null===e||e.constructor===Float64Array&&3===e.length?null===n||n.constructor===Float64Array&&3===n.length?(null!==t.coordShift&&null!==e&&Pn(e,t.coordShift)||(t.coordShift=e),null!==t.coordScale&&null!==n&&Pn(n,t.coordScale)||(t.coordScale=n),t.coordShiftAndScaleEnabled=function(e,t){return null!==e&&null!==t&&!(On(e,[0,0,0])&&On(t,[1,1,1]))}(t.coordShift,t.coordScale),t.coordShiftAndScaleEnabled?t.inverseShiftAndScaleMatrix=function(e,t){const n=new Float64Array(3);xn(n,t);const r=new Float64Array(16);return _(r,Ba(),e,n),r}(t.coordShift,t.coordScale):t.inverseShiftAndScaleMatrix=null):Hu(&quot;Wrong type for coordScale, expected vec3 or null&quot;):Hu(&quot;Wrong type for coordShift, expected vec3 or null&quot;)}}(e,t)}var $u={newInstance:Wt.newInstance(Ku),extend:Ku};const{vtkErrorMacro:qu}=Wt,Xu={shaderType:&quot;Unknown&quot;,source:&quot;&quot;,error:&quot;&quot;,handle:0,dirty:!1,context:null};function Yu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Xu,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;shaderType&quot;,&quot;source&quot;,&quot;error&quot;,&quot;handle&quot;,&quot;context&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkShader&quot;),e.compile=()=>{let e=t.context.VERTEX_SHADER;if(!t.source||!t.source.length||&quot;Unknown&quot;===t.shaderType)return!1;if(0!==t.handle&&(t.context.deleteShader(t.handle),t.handle=0),e=&quot;Fragment&quot;===t.shaderType?t.context.FRAGMENT_SHADER:t.context.VERTEX_SHADER,t.handle=t.context.createShader(e),t.context.shaderSource(t.handle,t.source),t.context.compileShader(t.handle),!t.context.getShaderParameter(t.handle,t.context.COMPILE_STATUS)){const e=t.context.getShaderInfoLog(t.handle);return qu(`Error compiling shader '${t.source}': ${e}`),t.context.deleteShader(t.handle),t.handle=0,!1}return!0},e.cleanup=()=>{&quot;Unknown&quot;!==t.shaderType&&0!==t.handle&&(t.context.deleteShader(t.handle),t.handle=0,t.dirty=!0)}}(e,t)}var Zu={newInstance:Wt.newInstance(Yu,&quot;vtkShader&quot;),extend:Yu};const{vtkErrorMacro:Qu}=Wt,Ju={vertexShaderHandle:0,fragmentShaderHandle:0,geometryShaderHandle:0,vertexShader:null,fragmentShader:null,geometryShader:null,linked:!1,bound:!1,compiled:!1,error:&quot;&quot;,handle:0,numberOfOutputs:0,attributesLocs:null,uniformLocs:null,md5Hash:0,context:null,lastCameraMTime:null};function ed(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ju,n),t.attributesLocs={},t.uniformLocs={},t.vertexShader=Zu.newInstance(),t.vertexShader.setShaderType(&quot;Vertex&quot;),t.fragmentShader=Zu.newInstance(),t.fragmentShader.setShaderType(&quot;Fragment&quot;),t.geometryShader=Zu.newInstance(),t.geometryShader.setShaderType(&quot;Geometry&quot;),Wt.obj(e,t),Wt.get(e,t,[&quot;lastCameraMTime&quot;]),Wt.setGet(e,t,[&quot;error&quot;,&quot;handle&quot;,&quot;compiled&quot;,&quot;bound&quot;,&quot;md5Hash&quot;,&quot;vertexShader&quot;,&quot;fragmentShader&quot;,&quot;geometryShader&quot;,&quot;linked&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkShaderProgram&quot;),e.compileShader=()=>t.vertexShader.compile()?t.fragmentShader.compile()?e.attachShader(t.vertexShader)&&e.attachShader(t.fragmentShader)?e.link()?(e.setCompiled(!0),1):(Qu(`Links failed: ${t.error}`),0):(Qu(t.error),0):(Qu(t.fragmentShader.getSource().split(&quot;\\n&quot;).map(((e,t)=>`${t}: ${e}`)).join(&quot;\\n&quot;)),Qu(t.fragmentShader.getError()),0):(Qu(t.vertexShader.getSource().split(&quot;\\n&quot;).map(((e,t)=>`${t}: ${e}`)).join(&quot;\\n&quot;)),Qu(t.vertexShader.getError()),0),e.cleanup=()=>{&quot;Unknown&quot;!==t.shaderType&&0!==t.handle&&(e.release(),0!==t.vertexShaderHandle&&(t.context.detachShader(t.handle,t.vertexShaderHandle),t.vertexShaderHandle=0),0!==t.fragmentShaderHandle&&(t.context.detachShader(t.handle,t.fragmentShaderHandle),t.fragmentShaderHandle=0),t.context.deleteProgram(t.handle),t.handle=0,e.setCompiled(!1))},e.bind=()=>!(!t.linked&&!e.link()||(t.context.useProgram(t.handle),e.setBound(!0),0)),e.isBound=()=>!!t.bound,e.release=()=>{t.context.useProgram(null),e.setBound(!1)},e.setContext=e=>{t.vertexShader.setContext(e),t.fragmentShader.setContext(e),t.geometryShader.setContext(e)},e.link=()=>{if(t.linked)return!0;if(0===t.handle)return t.error=&quot;Program has not been initialized, and/or does not have shaders.&quot;,!1;if(t.uniformLocs={},t.context.linkProgram(t.handle),!t.context.getProgramParameter(t.handle,t.context.LINK_STATUS)){const e=t.context.getProgramInfoLog(t.handle);return Qu(`Error linking shader ${e}`),t.handle=0,!1}return e.setLinked(!0),t.attributeLocs={},!0},e.setUniformMatrix=(n,r)=>{const o=e.findUniform(n);if(-1===o)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;const a=new Float32Array(r);return t.context.uniformMatrix4fv(o,!1,a),!0},e.setUniformMatrix3x3=(n,r)=>{const o=e.findUniform(n);if(-1===o)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;const a=new Float32Array(r);return t.context.uniformMatrix3fv(o,!1,a),!0},e.setUniformf=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform1f(o,r),!0)},e.setUniformfv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform1fv(o,r),!0)},e.setUniformi=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform1i(o,r),!0)},e.setUniformiv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform1iv(o,r),!0)},e.setUniform2f=(n,r,o)=>{const a=e.findUniform(n);if(-1===a)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;if(void 0===o)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform2f(a,r,o),!0},e.setUniform2fv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform2fv(o,r),!0)},e.setUniform2i=(n,r,o)=>{const a=e.findUniform(n);if(-1===a)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;if(void 0===o)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform2i(a,r,o),!0},e.setUniform2iv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform2iv(o,r),!0)},e.setUniform3f=(n,r,o,a)=>{const i=e.findUniform(n);if(-1===i)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;if(void 0===a)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform3f(i,r,o,a),!0},e.setUniform3fArray=(n,r)=>{const o=e.findUniform(n);if(-1===o)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;if(!Array.isArray(r)||3!==r.length)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform3f(o,r[0],r[1],r[2]),!0},e.setUniform3fv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform3fv(o,r),!0)},e.setUniform3i=function(n){const r=e.findUniform(n);if(-1===r)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;for(var o=arguments.length,a=new Array(o>1?o-1:0),i=1;i<o;i++)a[i-1]=arguments[i];let s=a;if(1===s.length&&Array.isArray(s[0])&&(s=s[0]),3!==s.length)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform3i(r,s[0],s[1],s[2]),!0},e.setUniform3iv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform3iv(o,r),!0)},e.setUniform4f=function(n){const r=e.findUniform(n);if(-1===r)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;for(var o=arguments.length,a=new Array(o>1?o-1:0),i=1;i<o;i++)a[i-1]=arguments[i];let s=a;if(1===s.length&&Array.isArray(s[0])&&(s=s[0]),4!==s.length)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform4f(r,s[0],s[1],s[2],s[3]),!0},e.setUniform4fv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform4fv(o,r),!0)},e.setUniform4i=function(n){const r=e.findUniform(n);if(-1===r)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;for(var o=arguments.length,a=new Array(o>1?o-1:0),i=1;i<o;i++)a[i-1]=arguments[i];let s=a;if(1===s.length&&Array.isArray(s[0])&&(s=s[0]),4!==s.length)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform4i(r,s[0],s[1],s[2],s[3]),!0},e.setUniform4iv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform4iv(o,r),!0)},e.findUniform=e=>{if(!e||!t.linked)return-1;let n=t.uniformLocs[e];return void 0!==n?n:(n=t.context.getUniformLocation(t.handle,e),null===n?(t.error=`Uniform ${e} not found in current shader program.`,t.uniformLocs[e]=-1,-1):(t.uniformLocs[e]=n,n))},e.isUniformUsed=e=>{if(!e)return!1;let n=t.uniformLocs[e];return void 0!==n?null!==n:t.linked?(n=t.context.getUniformLocation(t.handle,e),t.uniformLocs[e]=n,null!==n):(Qu(&quot;attempt to find uniform when the shader program is not linked&quot;),!1)},e.isAttributeUsed=e=>{if(!e)return!1;if(e in t.attributeLocs)return!0;if(!t.linked)return Qu(&quot;attempt to find uniform when the shader program is not linked&quot;),!1;const n=t.context.getAttribLocation(t.handle,e);return-1!==n&&(t.attributeLocs[e]=n,!0)},e.attachShader=n=>{if(0===n.getHandle())return t.error=&quot;Shader object was not initialized, cannot attach it.&quot;,!1;if(&quot;Unknown&quot;===n.getShaderType())return t.error=&quot;Shader object is of type Unknown and cannot be used.&quot;,!1;if(0===t.handle){const e=t.context.createProgram();if(0===e)return t.error=&quot;Could not create shader program.&quot;,!1;t.handle=e,t.linked=!1}return&quot;Vertex&quot;===n.getShaderType()&&(0!==t.vertexShaderHandle&&t.context.detachShader(t.handle,t.vertexShaderHandle),t.vertexShaderHandle=n.getHandle()),&quot;Fragment&quot;===n.getShaderType()&&(0!==t.fragmentShaderHandle&&t.context.detachShader(t.handle,t.fragmentShaderHandle),t.fragmentShaderHandle=n.getHandle()),t.context.attachShader(t.handle,n.getHandle()),e.setLinked(!1),!0},e.detachShader=e=>{if(0===e.getHandle())return t.error=&quot;shader object was not initialized, cannot attach it.&quot;,!1;if(&quot;Unknown&quot;===e.getShaderType())return t.error=&quot;Shader object is of type Unknown and cannot be used.&quot;,!1;switch(0===t.handle&&(t.error=&quot;This shader program has not been initialized yet.&quot;),e.getShaderType()){case&quot;Vertex&quot;:return t.vertexShaderHandle!==e.getHandle()?(t.error=&quot;The supplied shader was not attached to this program.&quot;,!1):(t.context.detachShader(t.handle,e.getHandle()),t.vertexShaderHandle=0,t.linked=!1,!0);case&quot;Fragment&quot;:return t.fragmentShaderHandle!==e.getHandle()?(t.error=&quot;The supplied shader was not attached to this program.&quot;,!1):(t.context.detachShader(t.handle,e.getHandle()),t.fragmentShaderHandle=0,t.linked=!1,!0);default:return!1}},e.setContext=e=>{t.context=e,t.vertexShader.setContext(e),t.fragmentShader.setContext(e),t.geometryShader.setContext(e)},e.setLastCameraMTime=e=>{t.lastCameraMTime=e}}(e,t)}var td={newInstance:Wt.newInstance(ed,&quot;vtkShaderProgram&quot;),extend:ed,substitute:function(e,t,n,r){const o=&quot;string&quot;==typeof n?n:n.join(&quot;\\n&quot;),a=!1===r?t:new RegExp(t,&quot;g&quot;),i=e.replace(a,o);return{replace:i!==o,result:i}}};const nd={forceEmulation:!1,handleVAO:0,handleProgram:0,supported:!0,buffers:null,context:null};function rd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,nd,n),t.buffers=[],Wt.obj(e,t),Wt.get(e,t,[&quot;supported&quot;]),Wt.setGet(e,t,[&quot;forceEmulation&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLVertexArrayObject&quot;),e.exposedMethod=()=>{},e.initialize=()=>{t.instancingExtension=null,t._openGLRenderWindow.getWebgl2()||(t.instancingExtension=t.context.getExtension(&quot;ANGLE_instanced_arrays&quot;)),!t.forceEmulation&&t._openGLRenderWindow&&t._openGLRenderWindow.getWebgl2()?(t.extension=null,t.supported=!0,t.handleVAO=t.context.createVertexArray()):(t.extension=t.context.getExtension(&quot;OES_vertex_array_object&quot;),!t.forceEmulation&&t.extension?(t.supported=!0,t.handleVAO=t.extension.createVertexArrayOES()):t.supported=!1)},e.isReady=()=>0!==t.handleVAO||!1===t.supported,e.bind=()=>{if(e.isReady()||e.initialize(),e.isReady()&&t.supported)t.extension?t.extension.bindVertexArrayOES(t.handleVAO):t.context.bindVertexArray(t.handleVAO);else if(e.isReady()){const e=t.context;for(let n=0;n<t.buffers.length;++n){const r=t.buffers[n];t.context.bindBuffer(e.ARRAY_BUFFER,r.buffer);for(let n=0;n<r.attributes.length;++n){const o=r.attributes[n],a=o.isMatrix?o.size:1;for(let n=0;n<a;++n)e.enableVertexAttribArray(o.index+n),e.vertexAttribPointer(o.index+n,o.size,o.type,o.normalize,o.stride,o.offset+o.stride*n/o.size),o.divisor>0&&(t.instancingExtension?t.instancingExtension.vertexAttribDivisorANGLE(o.index+n,1):e.vertexAttribDivisor(o.index+n,1))}}}},e.release=()=>{if(e.isReady()&&t.supported)t.extension?t.extension.bindVertexArrayOES(null):t.context.bindVertexArray(null);else if(e.isReady()){const e=t.context;for(let n=0;n<t.buffers.length;++n){const r=t.buffers[n];t.context.bindBuffer(e.ARRAY_BUFFER,r.buffer);for(let n=0;n<r.attributes.length;++n){const o=r.attributes[n],a=o.isMatrix?o.size:1;for(let n=0;n<a;++n)e.enableVertexAttribArray(o.index+n),e.vertexAttribPointer(o.index+n,o.size,o.type,o.normalize,o.stride,o.offset+o.stride*n/o.size),o.divisor>0&&(t.instancingExtension?t.instancingExtension.vertexAttribDivisorANGLE(o.index+n,0):e.vertexAttribDivisor(o.index+n,0)),e.disableVertexAttribArray(o.index+n)}}}},e.shaderProgramChanged=()=>{e.release(),t.handleVAO&&(t.extension?t.extension.deleteVertexArrayOES(t.handleVAO):t.context.deleteVertexArray(t.handleVAO)),t.handleVAO=0,t.handleProgram=0},e.releaseGraphicsResources=()=>{e.shaderProgramChanged(),t.handleVAO&&(t.extension?t.extension.deleteVertexArrayOES(t.handleVAO):t.context.deleteVertexArray(t.handleVAO)),t.handleVAO=0,t.supported=!0,t.handleProgram=0},e.addAttributeArray=(t,n,r,o,a,i,s,l)=>e.addAttributeArrayWithDivisor(t,n,r,o,a,i,s,l,0,!1),e.addAttributeArrayWithDivisor=(n,r,o,a,i,s,l,c,u,d)=>{if(!n)return!1;if(!n.isBound()||0===r.getHandle()||r.getType()!==Fu.ARRAY_BUFFER)return!1;if(0===t.handleProgram&&(t.handleProgram=n.getHandle()),e.isReady()||e.initialize(),!e.isReady()||t.handleProgram!==n.getHandle())return!1;const p=t.context,f={};if(f.name=o,f.index=p.getAttribLocation(t.handleProgram,o),f.offset=a,f.stride=i,f.type=s,f.size=l,f.normalize=c,f.isMatrix=d,f.divisor=u,-1===f.Index)return!1;if(r.bind(),p.enableVertexAttribArray(f.index),p.vertexAttribPointer(f.index,f.size,f.type,f.normalize,f.stride,f.offset),u>0&&(t.instancingExtension?t.instancingExtension.vertexAttribDivisorANGLE(f.index,1):p.vertexAttribDivisor(f.index,1)),f.buffer=r.getHandle(),!t.supported){let e=!1;for(let n=0;n<t.buffers.length;++n){const r=t.buffers[n];if(r.buffer===f.buffer){e=!0;let t=!1;for(let e=0;e<r.attributes.length;++e)r.attributes[e].name===o&&(t=!0,r.attributes[e]=f);t||r.attributes.push(f)}}e||t.buffers.push({buffer:f.buffer,attributes:[f]})}return!0},e.addAttributeMatrixWithDivisor=(n,r,o,a,i,s,l,c,u)=>{const d=e.addAttributeArrayWithDivisor(n,r,o,a,i,s,l,c,u,!0);if(!d)return d;const p=t.context,f=p.getAttribLocation(t.handleProgram,o);for(let e=1;e<l;e++)p.enableVertexAttribArray(f+e),p.vertexAttribPointer(f+e,l,s,c,i,a+i*e/l),u>0&&(t.instancingExtension?t.instancingExtension.vertexAttribDivisorANGLE(f+e,1):p.vertexAttribDivisor(f+e,1));return!0},e.removeAttributeArray=n=>{if(!e.isReady()||0===t.handleProgram)return!1;if(!t.supported)for(let e=0;e<t.buffers.length;++e){const r=t.buffers[e];for(let o=0;o<r.attributes.length;++o)if(r.attributes[o].name===n)return r.attributes.splice(o,1),r.attributes.length||t.buffers.splice(e,1),!0}return!0},e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))}}(e,t)}var od={newInstance:Wt.newInstance(rd,&quot;vtkOpenGLVertexArrayObject&quot;),extend:rd};const ad={Start:0,Points:0,Lines:1,Tris:2,TriStrips:3,TrisEdges:4,TriStripsEdges:5,End:6},id={context:null,program:null,shaderSourceTime:null,VAO:null,attributeUpdateTime:null,CABO:null,primitiveType:0,pointPicking:!1};function sd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,id,n),Wt.obj(e,t),t.shaderSourceTime={},Wt.obj(t.shaderSourceTime),t.attributeUpdateTime={},Wt.obj(t.attributeUpdateTime),Wt.setGet(e,t,[&quot;program&quot;,&quot;shaderSourceTime&quot;,&quot;VAO&quot;,&quot;attributeUpdateTime&quot;,&quot;CABO&quot;,&quot;primitiveType&quot;,&quot;pointPicking&quot;]),t.program=td.newInstance(),t.VAO=od.newInstance(),t.CABO=$u.newInstance(),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLHelper&quot;),e.setOpenGLRenderWindow=e=>{t.context=e.getContext(),t.program.setContext(t.context),t.VAO.setOpenGLRenderWindow(e),t.CABO.setOpenGLRenderWindow(e)},e.releaseGraphicsResources=e=>{t.VAO.releaseGraphicsResources(),t.CABO.releaseGraphicsResources(),t.CABO.setElementCount(0)},e.drawArrays=(n,r,o,a)=>{if(t.CABO.getElementCount()){const i=e.getOpenGLMode(o),s=e.haveWideLines(n,r),l=t.context,c=l.getParameter(l.DEPTH_WRITEMASK);t.pointPicking&&l.depthMask(!1),i===l.LINES&&s?(e.updateShaders(n,r,a),l.drawArraysInstanced(i,0,t.CABO.getElementCount(),2*Math.ceil(r.getProperty().getLineWidth()))):(l.lineWidth(r.getProperty().getLineWidth()),e.updateShaders(n,r,a),l.drawArrays(i,0,t.CABO.getElementCount()),l.lineWidth(1));const u=(i===l.POINTS?1:0)||(i===l.LINES?2:3);return t.pointPicking&&l.depthMask(c),t.CABO.getElementCount()/u}return 0},e.getOpenGLMode=e=>{if(t.pointPicking)return t.context.POINTS;const n=t.primitiveType;return e===Zi.POINTS||n===ad.Points?t.context.POINTS:e===Zi.WIREFRAME||n===ad.Lines||n===ad.TrisEdges||n===ad.TriStripsEdges?t.context.LINES:t.context.TRIANGLES},e.haveWideLines=(e,n)=>n.getProperty().getLineWidth()>1&&!(t.CABO.getOpenGLRenderWindow()&&t.CABO.getOpenGLRenderWindow().getHardwareMaximumLineWidth()>=n.getProperty().getLineWidth()),e.getNeedToRebuildShaders=(t,n,r)=>!!(r.getNeedToRebuildShaders(e,t,n)||0===e.getProgram()||e.getShaderSourceTime().getMTime()<r.getMTime()||e.getShaderSourceTime().getMTime()<n.getMTime()),e.updateShaders=(n,r,o)=>{if(e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};o.buildShaders(a,n,r);const i=t.CABO.getOpenGLRenderWindow().getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==e.getProgram()&&(e.setProgram(i),e.getVAO().releaseGraphicsResources()),e.getShaderSourceTime().modified()}else t.CABO.getOpenGLRenderWindow().getShaderCache().readyShaderProgram(e.getProgram());e.getVAO().bind(),o.setMapperShaderParameters(e,n,r),o.setPropertyShaderParameters(e,n,r),o.setCameraShaderParameters(e,n,r),o.setLightingShaderParameters(e,n,r),o.invokeShaderCallbacks(e,n,r)},e.setMapperShaderParameters=(n,r,o)=>{if(e.haveWideLines(n,r)){e.getProgram().setUniform2f(&quot;viewportSize&quot;,o.usize,o.vsize);const t=parseFloat(r.getProperty().getLineWidth()),n=t/2;e.getProgram().setUniformf(&quot;lineWidthStepSize&quot;,t/Math.ceil(t)),e.getProgram().setUniformf(&quot;halfLineWidth&quot;,n)}t.primitiveType===ad.Points||r.getProperty().getRepresentation()===Zi.POINTS?e.getProgram().setUniformf(&quot;pointSize&quot;,r.getProperty().getPointSize()):t.pointPicking&&e.getProgram().setUniformf(&quot;pointSize&quot;,e.getPointPickingPrimitiveSize())},e.replaceShaderPositionVC=(n,r,o)=>{let a=n.Vertex;a=td.substitute(a,&quot;//VTK::PositionVC::Dec&quot;,[&quot;//VTK::PositionVC::Dec&quot;,&quot;uniform float pointSize;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;//VTK::PositionVC::Impl&quot;,&quot;  gl_PointSize = pointSize;&quot;],!1).result,e.getOpenGLMode(o.getProperty().getRepresentation())===t.context.LINES&&e.haveWideLines(r,o)&&(a=td.substitute(a,&quot;//VTK::PositionVC::Dec&quot;,[&quot;//VTK::PositionVC::Dec&quot;,&quot;uniform vec2 viewportSize;&quot;,&quot;uniform float lineWidthStepSize;&quot;,&quot;uniform float halfLineWidth;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;//VTK::PositionVC::Impl&quot;,&quot; if (halfLineWidth > 0.0)&quot;,&quot;   {&quot;,&quot;   float offset = float(gl_InstanceID / 2) * lineWidthStepSize - halfLineWidth;&quot;,&quot;   vec4 tmpPos = gl_Position;&quot;,&quot;   vec3 tmpPos2 = tmpPos.xyz / tmpPos.w;&quot;,&quot;   tmpPos2.x = tmpPos2.x + 2.0 * mod(float(gl_InstanceID), 2.0) * offset / viewportSize[0];&quot;,&quot;   tmpPos2.y = tmpPos2.y + 2.0 * mod(float(gl_InstanceID + 1), 2.0) * offset / viewportSize[1];&quot;,&quot;   gl_Position = vec4(tmpPos2.xyz * tmpPos.w, tmpPos.w);&quot;,&quot;   }&quot;]).result),n.Vertex=a},e.getPointPickingPrimitiveSize=()=>t.primitiveType===ad.Points?2:t.primitiveType===ad.Lines?4:6,e.getAllocatedGPUMemoryInBytes=()=>e.getCABO().getAllocatedGPUMemoryInBytes()}(e,t)}var ld={newInstance:Wt.newInstance(sd),extend:sd,primTypes:ad};const cd={CLAMP_TO_EDGE:0,REPEAT:1,MIRRORED_REPEAT:2},ud={NEAREST:0,LINEAR:1,NEAREST_MIPMAP_NEAREST:2,NEAREST_MIPMAP_LINEAR:3,LINEAR_MIPMAP_NEAREST:4,LINEAR_MIPMAP_LINEAR:5};var dd={Wrap:cd,Filter:ud};const pd=new Float32Array(1),fd=new Int32Array(pd.buffer);var gd={fromHalf:function(e){const t=(32768&e)>>15,n=(31744&e)>>10,r=1023&e;return 0===n?(t?-1:1)*2**-14*(r/1024):31===n?r?NaN:1/0*(t?-1:1):(t?-1:1)*2**(n-15)*(1+r/1024)},toHalf:function(e){pd[0]=e;const t=fd[0];let n=t>>16&32768,r=t>>12&2047;const o=t>>23&255;return o<103?n:o>142?(n|=31744,n|=(255===o?0:1)&&8388607&t,n):o<113?(r|=2048,n|=(r>>114-o)+(r>>113-o&1),n):(n|=o-112<<10|r>>1,n+=1&r,n)}};let md;const{Wrap:hd,Filter:vd}=dd,{VtkDataTypes:Td}=xs,{vtkDebugMacro:yd,vtkErrorMacro:bd,vtkWarningMacro:xd,requiredParam:Cd}=Ht,{toHalf:Sd}=gd;function Ad(e,t){function n(){return{internalFormat:t.internalFormat,format:t.format,openGLDataType:t.openGLDataType,width:t.width,height:t.height}}t.classHierarchy.push(&quot;vtkOpenGLTexture&quot;),e.render=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:null;if(n?t._openGLRenderWindow=n:(t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;)),t.context=t._openGLRenderWindow.getContext(),t.renderable.getInterpolate()?(t.generateMipmap?e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR):e.setMinificationFilter(vd.LINEAR),e.setMagnificationFilter(vd.LINEAR)):(e.setMinificationFilter(vd.NEAREST),e.setMagnificationFilter(vd.NEAREST)),t.renderable.getRepeat()&&(e.setWrapR(hd.REPEAT),e.setWrapS(hd.REPEAT),e.setWrapT(hd.REPEAT)),t.renderable.getInputData()&&t.renderable.setImage(null),!t.handle||t.renderable.getMTime()>t.textureBuildTime.getMTime()){if(null!==t.renderable.getImageBitmap()&&(t.renderable.getInterpolate()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR)),t.renderable.getImageBitmap()&&t.renderable.getImageLoaded()&&(e.create2DFromImageBitmap(t.renderable.getImageBitmap()),e.activate(),e.sendParameters(),t.textureBuildTime.modified())),null!==t.renderable.getImage()&&(t.renderable.getInterpolate()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR)),t.renderable.getImage()&&t.renderable.getImageLoaded()&&(e.create2DFromImage(t.renderable.getImage()),e.activate(),e.sendParameters(),t.textureBuildTime.modified())),null!==t.renderable.getCanvas()){t.renderable.getInterpolate()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR));const n=t.renderable.getCanvas();e.create2DFromRaw({width:n.width,height:n.height,numComps:4,dataType:Td.UNSIGNED_CHAR,data:n,flip:!0}),e.activate(),e.sendParameters(),t.textureBuildTime.modified()}if(null!==t.renderable.getJsImageData()){const n=t.renderable.getJsImageData();t.renderable.getInterpolate()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR)),e.create2DFromRaw({width:n.width,height:n.height,numComps:4,dataType:Td.UNSIGNED_CHAR,data:n.data,flip:!0}),e.activate(),e.sendParameters(),t.textureBuildTime.modified()}const n=t.renderable.getInputData(0);if(n&&n.getPointData().getScalars()){const r=n.getExtent(),o=n.getPointData().getScalars(),a=[];for(let e=0;e<t.renderable.getNumberOfInputPorts();++e){const n=t.renderable.getInputData(e),r=n?n.getPointData().getScalars().getData():null;r&&a.push(r)}t.renderable.getInterpolate()&&4===o.getNumberOfComponents()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR)),a.length%6==0?e.createCubeFromRaw({width:r[1]-r[0]+1,height:r[3]-r[2]+1,numComps:o.getNumberOfComponents(),dataType:o.getDataType(),data:a}):e.create2DFromRaw({width:r[1]-r[0]+1,height:r[3]-r[2]+1,numComps:o.getNumberOfComponents(),dataType:o.getDataType(),data:o.getData()}),e.activate(),e.sendParameters(),t.textureBuildTime.modified()}}t.handle&&e.activate()};const r=()=>{if(t.minificationFilter!==vd.LINEAR&&t.magnificationFilter!==vd.LINEAR||(void 0===md&&(md=function(){try{const e=4,t=2,n=1,r=new Int16Array([0,32767]),o=[1,1],a=document.createElement(&quot;canvas&quot;);a.width=e,a.height=e;const i=a.getContext(&quot;webgl2&quot;);if(!i)return!1;const s=i.getExtension(&quot;EXT_texture_norm16&quot;);if(!s)return!1;const l=`#version 300 es\\n    void main() {\\n      gl_PointSize = ${e.toFixed(1)};\\n      gl_Position = vec4(0, 0, 0, 1);\\n    }\\n  `,c=&quot;#version 300 es\\n    precision highp float;\\n    precision highp int;\\n    precision highp sampler2D;\\n\\n    uniform sampler2D u_image;\\n\\n    out vec4 color;\\n\\n    void main() {\\n        vec4 intColor = texture(u_image, gl_PointCoord.xy);\\n        color = vec4(vec3(intColor.rrr), 1);\\n    }\\n    &quot;,u=i.createShader(i.VERTEX_SHADER);if(i.shaderSource(u,l),i.compileShader(u),!i.getShaderParameter(u,i.COMPILE_STATUS))return!1;const d=i.createShader(i.FRAGMENT_SHADER);if(i.shaderSource(d,c),i.compileShader(d),!i.getShaderParameter(d,i.COMPILE_STATUS))return!1;const p=i.createProgram();if(i.attachShader(p,u),i.attachShader(p,d),i.linkProgram(p),!i.getProgramParameter(p,i.LINK_STATUS))return!1;const f=i.createTexture();i.bindTexture(i.TEXTURE_2D,f),i.texImage2D(i.TEXTURE_2D,0,s.R16_SNORM_EXT,t,n,0,i.RED,i.SHORT,r),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_MAG_FILTER,i.LINEAR),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_MIN_FILTER,i.LINEAR),i.useProgram(p),i.drawArrays(i.POINTS,0,1);const g=new Uint8Array(4);i.readPixels(o[0],o[1],1,1,i.RGBA,i.UNSIGNED_BYTE,g);const[m,h,v]=g,T=i.getExtension(&quot;WEBGL_lose_context&quot;);return T&&T.loseContext(),m===h&&h===v&&0!==m}catch(e){return!1}}()),md))return t.oglNorm16Ext};function o(e){const[t,n,r,o,a,i]=e;return[n-t+1,o-r+1,i-a+1]}function a(e){const[t,n,r]=o(e);return t*n*r}function i(e,n){const r=new((arguments.length>2&&void 0!==arguments[2]?arguments[2]:null)||e.constructor)(n.reduce(((e,t)=>e+a(t)),0)),o=[t.width,t.height,t.depth];let i=0;return n.forEach((t=>{!function(e,t,n,r,o){const[a,i,s,l,c,u]=n,[d,p]=t,f=d*p;let g=o;for(let t=c;t<=u;t++){const n=t*f;for(let t=s;t<=l;t++){const o=n+t*d;for(let t=o+a,n=o+i;t<=n;t++,g++)r[g]=e[t]}}}(e,o,t,r,i),i+=a(t)})),r}function s(e){if(t._openGLRenderWindow.getWebgl2())return e;const n=[],r=t.width,o=t.height,a=t.components;if(e&&(!Oo(r)||!Oo(o))){const i=t.context.getExtension(&quot;OES_texture_half_float&quot;),s=wo(r),l=wo(o),c=s*l*t.components;for(let u=0;u<e.length;u++)if(null!==e[u]){let d=null;const p=o/l,f=r/s;let g=!1;t.openGLDataType===t.context.FLOAT?d=new Float32Array(c):i&&t.openGLDataType===i.HALF_FLOAT_OES?(d=new Uint16Array(c),g=!0):d=new Uint8Array(c);for(let t=0;t<l;t++){const n=t*s*a,i=t*p;let l=Math.floor(i),c=Math.ceil(i);c>=o&&(c=o-1);const m=i-l,h=1-m;l=l*r*a,c=c*r*a;for(let t=0;t<s;t++){const o=t*a,i=t*f;let s=Math.floor(i),p=Math.ceil(i);p>=r&&(p=r-1);const v=i-s;s*=a,p*=a;for(let t=0;t<a;t++)d[n+o+t]=g?gd.toHalf(gd.fromHalf(e[u][l+s+t])*h*(1-v)+gd.fromHalf(e[u][l+p+t])*h*v+gd.fromHalf(e[u][c+s+t])*m*(1-v)+gd.fromHalf(e[u][c+p+t])*m*v):e[u][l+s+t]*h*(1-v)+e[u][l+p+t]*h*v+e[u][c+s+t]*m*(1-v)+e[u][c+p+t]*m*v}}n.push(d),t.width=s,t.height=l}else n.push(null)}if(0===n.length)for(let t=0;t<e.length;t++)n.push(e[t]);return n}function l(e){return!!t._openGLRenderWindow&&(!t.resizable&&!t.renderable?.getResizable()&&(!!t._openGLRenderWindow.getWebgl2()&&(!(t._openGLRenderWindow.getGLInformations().RENDERER.value.match(/WebKit/gi)&&navigator.platform.match(/Mac/gi)&&r())||e!==Td.UNSIGNED_SHORT&&e!==Td.SHORT)))}function c(n,r){const o=n.getNumberOfComponents(),a=n.getDataType(),i=n.getData(),s=new Array(o),l=new Array(o);for(let e=0;e<o;++e){const[t,r]=n.getRange(e);s[e]=t,l[e]=r}const c=function(e,t,n){const r=new Array(n),o=new Array(n);for(let a=0;a<n;++a)r[a]=e[a],o[a]=t[a]-e[a]||1;return{scale:o,offset:r}}(s,l,o);return function(n,r,o,a){e.getOpenGLDataType(n);const i=function(e,t){for(let n=0;n<e.length;n++){const r=e[n],o=t[n]+r;if(r<-2048||r>2048||o<-2048||o>2048)return!1}return!0}(r,o)||a;let s=!1;if(t._openGLRenderWindow.getWebgl2())s=t.openGLDataType===t.context.FLOAT&&null===t.context.getExtension(&quot;OES_texture_float_linear&quot;)&&i||t.openGLDataType===t.context.HALF_FLOAT;else{const e=t.context.getExtension(&quot;OES_texture_half_float&quot;);s=e&&t.openGLDataType===e.HALF_FLOAT_OES}t.canUseHalfFloat=s&&i}(a,c.offset,c.scale,r),e.useHalfFloat()||e.getOpenGLDataType(a,!0),{numComps:o,dataType:a,data:i,scaleOffsets:c}}e.destroyTexture=()=>{e.deactivate(),t.context&&t.handle&&t.context.deleteTexture(t.handle),t._prevTexParams=null,t.handle=0,t.numberOfDimensions=0,t.target=0,t.components=0,t.width=0,t.height=0,t.depth=0,e.resetFormatAndType()},e.createTexture=()=>{t.handle||(t.handle=t.context.createTexture(),t.target&&(t.context.bindTexture(t.target,t.handle),t.context.texParameteri(t.target,t.context.TEXTURE_MIN_FILTER,e.getOpenGLFilterMode(t.minificationFilter)),t.context.texParameteri(t.target,t.context.TEXTURE_MAG_FILTER,e.getOpenGLFilterMode(t.magnificationFilter)),t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_S,e.getOpenGLWrapMode(t.wrapS)),t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_T,e.getOpenGLWrapMode(t.wrapT)),t._openGLRenderWindow.getWebgl2()&&t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_R,e.getOpenGLWrapMode(t.wrapR)),t.context.bindTexture(t.target,null)))},e.getTextureUnit=()=>t._openGLRenderWindow?t._openGLRenderWindow.getTextureUnitForTexture(e):-1,e.activate=()=>{t._openGLRenderWindow.activateTexture(e),e.bind()},e.deactivate=()=>{t._openGLRenderWindow&&t._openGLRenderWindow.deactivateTexture(e)},e.releaseGraphicsResources=n=>{n&&t.handle&&(n.activateTexture(e),n.deactivateTexture(e),t.context.deleteTexture(t.handle),t._prevTexParams=null,t.handle=0,t.numberOfDimensions=0,t.target=0,t.internalFormat=0,t.format=0,t.openGLDataType=0,t.components=0,t.width=0,t.height=0,t.depth=0,t.allocatedGPUMemoryInBytes=0),t.shaderProgram&&(t.shaderProgram.releaseGraphicsResources(n),t.shaderProgram=null)},e.bind=()=>{t.context.bindTexture(t.target,t.handle),t.autoParameters&&e.getMTime()>t.sendParametersTime.getMTime()&&e.sendParameters()},e.isBound=()=>{let e=!1;if(t.context&&t.handle){let n=0;t.target===t.context.TEXTURE_2D?n=t.context.TEXTURE_BINDING_2D:xd(&quot;impossible case&quot;),e=t.context.getIntegerv(n)===t.handle}return e},e.sendParameters=()=>{t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_S,e.getOpenGLWrapMode(t.wrapS)),t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_T,e.getOpenGLWrapMode(t.wrapT)),t._openGLRenderWindow.getWebgl2()&&t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_R,e.getOpenGLWrapMode(t.wrapR)),t.context.texParameteri(t.target,t.context.TEXTURE_MIN_FILTER,e.getOpenGLFilterMode(t.minificationFilter)),t.context.texParameteri(t.target,t.context.TEXTURE_MAG_FILTER,e.getOpenGLFilterMode(t.magnificationFilter)),t._openGLRenderWindow.getWebgl2()&&(t.context.texParameteri(t.target,t.context.TEXTURE_BASE_LEVEL,t.baseLevel),t.context.texParameteri(t.target,t.context.TEXTURE_MAX_LEVEL,t.maxLevel)),t.sendParametersTime.modified()},e.getInternalFormat=(n,r)=>(t._forceInternalFormat||(t.internalFormat=e.getDefaultInternalFormat(n,r)),t.internalFormat||yd(`Unable to find suitable internal format for T=${n} NC= ${r}`),[t.context.R32F,t.context.RG32F,t.context.RGB32F,t.context.RGBA32F].includes(t.internalFormat)&&!t.context.getExtension(&quot;OES_texture_float_linear&quot;)&&xd(&quot;Failed to load OES_texture_float_linear. Texture filtering is not available for *32F internal formats.&quot;),t.internalFormat),e.getDefaultInternalFormat=(n,o)=>{let a=0;return a=t._openGLRenderWindow.getDefaultTextureInternalFormat(n,o,r(),e.useHalfFloat()),a||(a||(yd(&quot;Unsupported internal texture type!&quot;),yd(`Unable to find suitable internal format for T=${n} NC= ${o}`)),a)},e.useHalfFloat=()=>t.enableUseHalfFloat&&t.canUseHalfFloat,e.setInternalFormat=n=>{t._forceInternalFormat=!0,n!==t.internalFormat&&(t.internalFormat=n,e.modified())},e.getFormat=(n,r)=>(t.format=e.getDefaultFormat(n,r),t.format),e.getDefaultFormat=(e,n)=>{if(t._openGLRenderWindow.getWebgl2())switch(n){case 1:return t.context.RED;case 2:return t.context.RG;case 3:default:return t.context.RGB;case 4:return t.context.RGBA}else switch(n){case 1:return t.context.LUMINANCE;case 2:return t.context.LUMINANCE_ALPHA;case 3:default:return t.context.RGB;case 4:return t.context.RGBA}},e.resetFormatAndType=()=>{t._prevTexParams=null,t.format=0,t.internalFormat=0,t._forceInternalFormat=!1,t.openGLDataType=0},e.getDefaultDataType=n=>{const o=e.useHalfFloat();if(t._openGLRenderWindow.getWebgl2())switch(n){case Td.UNSIGNED_CHAR:return t.context.UNSIGNED_BYTE;case r()&&!o&&Td.SHORT:return t.context.SHORT;case r()&&!o&&Td.UNSIGNED_SHORT:return t.context.UNSIGNED_SHORT;case o&&Td.SHORT:case o&&Td.UNSIGNED_SHORT:return t.context.HALF_FLOAT;case Td.FLOAT:case Td.VOID:default:return t.context.FLOAT}switch(n){case Td.UNSIGNED_CHAR:return t.context.UNSIGNED_BYTE;case Td.FLOAT:case Td.VOID:default:if(t.context.getExtension(&quot;OES_texture_float&quot;)&&t.context.getExtension(&quot;OES_texture_float_linear&quot;))return t.context.FLOAT;{const e=t.context.getExtension(&quot;OES_texture_half_float&quot;);if(e&&t.context.getExtension(&quot;OES_texture_half_float_linear&quot;))return e.HALF_FLOAT_OES}return t.context.UNSIGNED_BYTE}},e.getOpenGLDataType=function(n){let r=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return t.openGLDataType&&!r||(t.openGLDataType=e.getDefaultDataType(n)),t.openGLDataType},e.getShiftAndScale=()=>{let e=0,n=1;switch(t.openGLDataType){case t.context.BYTE:n=127.5,e=n-128;break;case t.context.UNSIGNED_BYTE:n=255,e=0;break;case t.context.SHORT:n=32767.5,e=n-32768;break;case t.context.UNSIGNED_SHORT:n=65536,e=0;break;case t.context.INT:n=2147483647.5,e=n-2147483648;break;case t.context.UNSIGNED_INT:n=4294967295,e=0;case t.context.FLOAT:}return{shift:e,scale:n}},e.getOpenGLFilterMode=e=>{switch(e){case vd.NEAREST:return t.context.NEAREST;case vd.LINEAR:return t.context.LINEAR;case vd.NEAREST_MIPMAP_NEAREST:return t.context.NEAREST_MIPMAP_NEAREST;case vd.NEAREST_MIPMAP_LINEAR:return t.context.NEAREST_MIPMAP_LINEAR;case vd.LINEAR_MIPMAP_NEAREST:return t.context.LINEAR_MIPMAP_NEAREST;case vd.LINEAR_MIPMAP_LINEAR:return t.context.LINEAR_MIPMAP_LINEAR;default:return t.context.NEAREST}},e.getOpenGLWrapMode=e=>{switch(e){case hd.CLAMP_TO_EDGE:return t.context.CLAMP_TO_EDGE;case hd.REPEAT:return t.context.REPEAT;case hd.MIRRORED_REPEAT:return t.context.MIRRORED_REPEAT;default:return t.context.CLAMP_TO_EDGE}},e.updateArrayDataTypeForGL=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]&&arguments[2],o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[];const a=[];let s=t.width*t.height*t.components;r&&(s*=t.depth);const l=!!o.length;if(e!==Td.FLOAT&&t.openGLDataType===t.context.FLOAT)for(let e=0;e<n.length;e++)if(n[e])if(l)a.push(i(n[e],o,Float32Array));else{const t=n[e].length>s?n[e].subarray(0,s):n[e];a.push(new Float32Array(t))}else a.push(null);if(e!==Td.UNSIGNED_CHAR&&t.openGLDataType===t.context.UNSIGNED_BYTE)for(let e=0;e<n.length;e++)if(n[e])if(l)a.push(i(n[e],o,Uint8Array));else{const t=n[e].length>s?n[e].subarray(0,s):n[e];a.push(new Uint8Array(t))}else a.push(null);let c=!1;if(t._openGLRenderWindow.getWebgl2())c=t.openGLDataType===t.context.HALF_FLOAT;else{const e=t.context.getExtension(&quot;OES_texture_half_float&quot;);c=e&&t.openGLDataType===e.HALF_FLOAT_OES}if(c)for(let e=0;e<n.length;e++)if(n[e]){const t=l?i(n[e],o):n[e],r=new Uint16Array(l?t.length:s),c=r.length;for(let e=0;e<c;e++)r[e]=Sd(t[e]);a.push(r)}else a.push(null);if(0===a.length)for(let e=0;e<n.length;e++)a.push(l&&n[e]?i(n[e],o):n[e]);return a},e.create2DFromRaw=function(){let{width:n=Cd(&quot;width&quot;),height:o=Cd(&quot;height&quot;),numComps:a=Cd(&quot;numComps&quot;),dataType:i=Cd(&quot;dataType&quot;),data:c=Cd(&quot;data&quot;),flip:u=!1}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};if(e.getOpenGLDataType(i,!0),e.getInternalFormat(i,a),e.getFormat(i,a),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_2D,t.components=a,t.width=n,t.height=o,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind();const d=[c],p=s(e.updateArrayDataTypeForGL(i,d));return t.context.pixelStorei(t.context.UNPACK_FLIP_Y_WEBGL,u),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(i)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),null!=p[0]&&t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,p[0])):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,p[0]),t.generateMipmap&&t.context.generateMipmap(t.target),u&&t.context.pixelStorei(t.context.UNPACK_FLIP_Y_WEBGL,!1),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*a*t._openGLRenderWindow.getDefaultTextureByteSize(i,r(),e.useHalfFloat()),e.deactivate(),!0},e.createCubeFromRaw=function(){let{width:n=Cd(&quot;width&quot;),height:o=Cd(&quot;height&quot;),numComps:a=Cd(&quot;numComps&quot;),dataType:i=Cd(&quot;dataType&quot;),data:c=Cd(&quot;data&quot;)}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};if(e.getOpenGLDataType(i),e.getInternalFormat(i,a),e.getFormat(i,a),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_CUBE_MAP,t.components=a,t.width=n,t.height=o,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),t.maxLevel=c.length/6-1,e.createTexture(),e.bind();const u=s(e.updateArrayDataTypeForGL(i,c)),d=[];let p=t.width,f=t.height;for(let e=0;e<u.length;e++){e%6==0&&0!==e&&(p/=2,f/=2),d[e]=at(i,f*p*t.components);for(let n=0;n<f;++n){const r=n*p*t.components,o=(f-n-1)*p*t.components;d[e].set(u[e].slice(o,o+p*t.components),r)}}t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(i)&&t.context.texStorage2D(t.target,6,t.internalFormat,t.width,t.height);for(let e=0;e<6;e++){let n=0,r=t.width,o=t.height;for(;r>=1&&o>=1;){let a=null;n<=t.maxLevel&&(a=d[6*n+e]),l(i)?null!=a&&t.context.texSubImage2D(t.context.TEXTURE_CUBE_MAP_POSITIVE_X+e,n,0,0,r,o,t.format,t.openGLDataType,a):t.context.texImage2D(t.context.TEXTURE_CUBE_MAP_POSITIVE_X+e,n,t.internalFormat,r,o,0,t.format,t.openGLDataType,a),n++,r/=2,o/=2}}return t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*a*t._openGLRenderWindow.getDefaultTextureByteSize(i,r(),e.useHalfFloat()),e.deactivate(),!0},e.createDepthFromRaw=function(){let{width:n=Cd(&quot;width&quot;),height:o=Cd(&quot;height&quot;),dataType:a=Cd(&quot;dataType&quot;),data:i=Cd(&quot;data&quot;)}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};return e.getOpenGLDataType(a),t.format=t.context.DEPTH_COMPONENT,t._openGLRenderWindow.getWebgl2()?a===Td.FLOAT?t.internalFormat=t.context.DEPTH_COMPONENT32F:t.internalFormat=t.context.DEPTH_COMPONENT16:t.internalFormat=t.context.DEPTH_COMPONENT,t.internalFormat&&t.format&&t.openGLDataType?(t.target=t.context.TEXTURE_2D,t.components=1,t.width=n,t.height=o,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind(),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(a)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),null!=i&&t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,i)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,i),t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(a,r(),e.useHalfFloat()),e.deactivate(),!0):(bd(&quot;Failed to determine texture parameters.&quot;),!1)},e.create2DFromImage=n=>{if(e.getOpenGLDataType(Td.UNSIGNED_CHAR),e.getInternalFormat(Td.UNSIGNED_CHAR,4),e.getFormat(Td.UNSIGNED_CHAR,4),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_2D,t.components=4,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind();const o=!(t._openGLRenderWindow.getWebgl2()||Oo(n.width)&&Oo(n.height));let a=n,i=n.width,s=n.height,c=!0;const u=window.chrome;if(o||u){const e=new OffscreenCanvas(wo(n.width),wo(n.height));i=e.width,s=e.height;const t=e.getContext(&quot;2d&quot;);t.translate(0,e.height),t.scale(1,-1),t.drawImage(n,0,0,n.width,n.height,0,0,e.width,e.height),a=e,c=!1}return t.width=i,t.height=s,t.context.pixelStorei(t.context.UNPACK_FLIP_Y_WEBGL,c),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(Td.UNSIGNED_CHAR)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,a)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,a),t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(Td.UNSIGNED_CHAR,r(),e.useHalfFloat()),e.deactivate(),!0},e.create2DFromImageBitmap=n=>(e.getOpenGLDataType(Td.UNSIGNED_CHAR),e.getInternalFormat(Td.UNSIGNED_CHAR,4),e.getFormat(Td.UNSIGNED_CHAR,4),t.internalFormat&&t.format&&t.openGLDataType?(t.target=t.context.TEXTURE_2D,t.components=4,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind(),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),t.width=n.width,t.height=n.height,l(Td.UNSIGNED_CHAR)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,n)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,n),t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(Td.UNSIGNED_CHAR,r(),e.useHalfFloat()),e.deactivate(),!0):(bd(&quot;Failed to determine texture parameters.&quot;),!1)),e.create2DFilterableFromRaw=function(){let{width:t=Cd(&quot;width&quot;),height:n=Cd(&quot;height&quot;),numComps:r=Cd(&quot;numComps&quot;),dataType:o=Cd(&quot;dataType&quot;),data:a=Cd(&quot;data&quot;),preferSizeOverAccuracy:i=!1,ranges:s}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};return e.create2DFilterableFromDataArray({width:t,height:n,dataArray:xs.newInstance({numberOfComponents:r,dataType:o,values:a,ranges:s}),preferSizeOverAccuracy:i})},e.create2DFilterableFromDataArray=function(){let{width:t=Cd(&quot;width&quot;),height:n=Cd(&quot;height&quot;),dataArray:r=Cd(&quot;dataArray&quot;),preferSizeOverAccuracy:o=!1}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};const{numComps:a,dataType:i,data:s}=c(r,o);e.create2DFromRaw({width:t,height:n,numComps:a,dataType:i,data:s})},e.updateVolumeInfoForGL=(n,o)=>{let a=!1;const i=e.useHalfFloat();t.volumeInfo?.scale&&t.volumeInfo?.offset||(t.volumeInfo={scale:new Array(o),offset:new Array(o)});for(let e=0;e<o;++e)t.volumeInfo.scale[e]=1,t.volumeInfo.offset[e]=0;if(r()&&!i&&n===Td.SHORT){for(let e=0;e<o;++e)t.volumeInfo.scale[e]=32767;a=!0}if(r()&&!i&&n===Td.UNSIGNED_SHORT){for(let e=0;e<o;++e)t.volumeInfo.scale[e]=65535;a=!0}if(n===Td.UNSIGNED_CHAR){for(let e=0;e<o;++e)t.volumeInfo.scale[e]=255;a=!0}return(n===Td.FLOAT||i&&(n===Td.SHORT||n===Td.UNSIGNED_SHORT))&&(a=!0),a},e.create3DFromRaw=function(){let{width:i=Cd(&quot;width&quot;),height:c=Cd(&quot;height&quot;),depth:u=Cd(&quot;depth&quot;),numComps:d=Cd(&quot;numComps&quot;),dataType:p=Cd(&quot;dataType&quot;),data:f=Cd(&quot;data&quot;),updatedExtents:g=[]}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},m=p,h=f;if(!e.updateVolumeInfoForGL(m,d)&&h){const e=i*c*u,n=structuredClone(t.volumeInfo),r=new Float32Array(e*d);t.volumeInfo.offset=n.offset,t.volumeInfo.scale=n.scale;let o=0;const a=n.scale.map((e=>1/e));for(let t=0;t<e;t++)for(let e=0;e<d;e++)r[o]=(h[o]-n.offset[e])*a[e],o++;m=Td.FLOAT,h=r}if(e.getOpenGLDataType(m),e.getInternalFormat(m,d),e.getFormat(m,d),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_3D,t.components=d,t.width=i,t.height=c,t.depth=u,t.numberOfDimensions=3,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind();const v=g.length>0,T=!v||!ke(t._prevTexParams,n()),y=[h],b=s(e.updateArrayDataTypeForGL(m,y,!0,T?[]:g));if(t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),T)l(m)?(t.context.texStorage3D(t.target,1,t.internalFormat,t.width,t.height,t.depth),null!=b[0]&&t.context.texSubImage3D(t.target,0,0,0,0,t.width,t.height,t.depth,t.format,t.openGLDataType,b[0])):t.context.texImage3D(t.target,0,t.internalFormat,t.width,t.height,t.depth,0,t.format,t.openGLDataType,b[0]),t._prevTexParams=n();else if(v){const e=b[0];let n=0;for(let r=0;r<g.length;r++){const i=g[r],s=o(i),l=a(i),c=new e.constructor(e.buffer,n,l);n+=c.byteLength,t.context.texSubImage3D(t.target,0,i[0],i[2],i[4],s[0],s[1],s[2],t.format,t.openGLDataType,c)}}return t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(m,r(),e.useHalfFloat()),e.deactivate(),!0},e.create3DFilterableFromRaw=function(){let{width:t=Cd(&quot;width&quot;),height:n=Cd(&quot;height&quot;),depth:r=Cd(&quot;depth&quot;),numComps:o=Cd(&quot;numComps&quot;),dataType:a=Cd(&quot;dataType&quot;),data:i=Cd(&quot;data&quot;),preferSizeOverAccuracy:s=!1,ranges:l,updatedExtents:c=[]}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};return e.create3DFilterableFromDataArray({width:t,height:n,depth:r,dataArray:xs.newInstance({numberOfComponents:o,dataType:a,values:i,ranges:l}),preferSizeOverAccuracy:s,updatedExtents:c})},e.create3DFilterableFromDataArray=function(){let{width:n=Cd(&quot;width&quot;),height:r=Cd(&quot;height&quot;),depth:o=Cd(&quot;depth&quot;),dataArray:a=Cd(&quot;dataArray&quot;),preferSizeOverAccuracy:i=!1,updatedExtents:s=[]}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};const{numComps:u,dataType:d,data:p,scaleOffsets:f}=c(a,i),g=[],m=[];for(let e=0;e<u;++e)g[e]=0,m[e]=1;if(t.volumeInfo={scale:m,offset:g,dataComputedScale:f.scale,dataComputedOffset:f.offset,width:n,height:r,depth:o},t._openGLRenderWindow.getWebgl2())return e.create3DFromRaw({width:n,height:r,depth:o,numComps:u,dataType:d,data:p,updatedExtents:s});const h=n*r*o,v=structuredClone(f);let T=(e,t,n,r,o)=>{e[t]=n},y=Td.UNSIGNED_CHAR;if(d===Td.UNSIGNED_CHAR)for(let e=0;e<u;++e)v.offset[e]=0,v.scale[e]=255;else t.context.getExtension(&quot;OES_texture_float&quot;)&&t.context.getExtension(&quot;OES_texture_float_linear&quot;)?(y=Td.FLOAT,T=(e,t,n,r,o)=>{e[t]=(n-r)/o}):(y=Td.UNSIGNED_CHAR,T=(e,t,n,r,o)=>{e[t]=255*(n-r)/o});if(e.getOpenGLDataType(y),e.getInternalFormat(y,u),e.getFormat(y,u),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_2D,t.components=u,t.depth=1,t.numberOfDimensions=2;let b=t.context.getParameter(t.context.MAX_TEXTURE_SIZE);b>4096&&(y===Td.FLOAT||u>=3)&&(b=4096);let x=1,C=1;h>b*b&&(x=Math.ceil(Math.sqrt(h/(b*b))),C=x);let S=Math.sqrt(h)/x;S=wo(S);const A=Math.floor(S*x/n),I=Math.ceil(o/A),w=wo(r*I/C);let O;t.width=S,t.height=w,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind(),t.volumeInfo.xreps=A,t.volumeInfo.yreps=I,t.volumeInfo.xstride=x,t.volumeInfo.ystride=C,t.volumeInfo.offset=v.offset,t.volumeInfo.scale=v.scale;const P=S*w*u;O=y===Td.FLOAT?new Float32Array(P):new Uint8Array(P);let R=0;const M=Math.floor(n/x),E=Math.floor(r/C);for(let e=0;e<I;e++){const a=Math.min(A,o-e*A),i=u*(t.width-a*Math.floor(n/x));for(let t=0;t<E;t++){for(let o=0;o<a;o++){const a=u*((e*A+o)*n*r+C*t*n);for(let e=0;e<M;e++)for(let t=0;t<u;t++)T(O,R,p[a+x*e*u+t],v.offset[t],v.scale[t]),R++}R+=i}}return t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(y)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),null!=O&&t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,O)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,O),e.deactivate(),!0},e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))},e.getMaximumTextureSize=e=>e&&e.isCurrent()?e.getIntegerv(e.MAX_TEXTURE_SIZE):-1,e.enableUseHalfFloat=e=>{t.enableUseHalfFloat=e}}const Id={_openGLRenderWindow:null,_forceInternalFormat:!1,_prevTexParams:null,context:null,handle:0,sendParametersTime:null,textureBuildTime:null,numberOfDimensions:0,target:0,format:0,openGLDataType:0,components:0,width:0,height:0,depth:0,autoParameters:!0,wrapS:hd.CLAMP_TO_EDGE,wrapT:hd.CLAMP_TO_EDGE,wrapR:hd.CLAMP_TO_EDGE,minificationFilter:vd.NEAREST,magnificationFilter:vd.NEAREST,minLOD:-1e3,maxLOD:1e3,baseLevel:0,maxLevel:1e3,generateMipmap:!1,oglNorm16Ext:null,allocatedGPUMemoryInBytes:0,enableUseHalfFloat:!0,canUseHalfFloat:!1};function wd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Id,n),qt.extend(e,t,n),t.sendParametersTime={},ht(t.sendParametersTime,{mtime:0}),t.textureBuildTime={},ht(t.textureBuildTime,{mtime:0}),xt(e,t,[&quot;format&quot;,&quot;openGLDataType&quot;]),Ct(e,t,[&quot;keyMatrixTime&quot;,&quot;minificationFilter&quot;,&quot;magnificationFilter&quot;,&quot;wrapS&quot;,&quot;wrapT&quot;,&quot;wrapR&quot;,&quot;generateMipmap&quot;,&quot;oglNorm16Ext&quot;]),Tt(e,t,[&quot;width&quot;,&quot;height&quot;,&quot;volumeInfo&quot;,&quot;components&quot;,&quot;handle&quot;,&quot;target&quot;,&quot;allocatedGPUMemoryInBytes&quot;]),wt(0,t,[&quot;openGLRenderWindow&quot;]),Ad(e,t)}const Od=Mt(wd,&quot;vtkOpenGLTexture&quot;);var Pd={newInstance:Od,extend:wd,...dd};Jt(&quot;vtkTexture&quot;,Od);var Rd=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkPolyDataVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\nattribute vec4 vertexMC;\\n\\n// frag position in VC\\n//VTK::PositionVC::Dec\\n\\n// optional normal declaration\\n//VTK::Normal::Dec\\n\\n// extra lighting parameters\\n//VTK::Light::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// material property values\\n//VTK::Color::Dec\\n\\n// clipping plane vars\\n//VTK::Clip::Dec\\n\\n// camera and actor matrix values\\n//VTK::Camera::Dec\\n\\n// Apple Bug\\n//VTK::PrimID::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\nvoid main()\\n{\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Clip::Impl\\n\\n  //VTK::PrimID::Impl\\n\\n  //VTK::PositionVC::Impl\\n\\n  //VTK::Light::Impl\\n\\n  //VTK::Picking::Impl\\n}\\n&quot;,Md=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkPolyDataFS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// Template for the polydata mappers fragment shader\\n\\nuniform int PrimitiveIDOffset;\\n\\n// VC position of this fragment\\n//VTK::PositionVC::Dec\\n\\n// optional color passed in from the vertex shader, vertexColor\\n//VTK::Color::Dec\\n\\n// optional surface normal declaration\\n//VTK::Normal::Dec\\n\\n// extra lighting parameters\\n//VTK::Light::Dec\\n\\n// define vtkImageLabelOutlineOn\\n//VTK::ImageLabelOutlineOn\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\n// Depth Peeling Support\\n//VTK::DepthPeeling::Dec\\n\\n// clipping plane vars\\n//VTK::Clip::Dec\\n\\n// label outline \\n//VTK::LabelOutline::Dec\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\n// Apple Bug\\n//VTK::PrimID::Dec\\n\\n// handle coincident offsets\\n//VTK::Coincident::Dec\\n\\n//VTK::ZBuffer::Dec\\n\\n//VTK::LabelOutlineHelperFunction\\n\\nvoid main()\\n{\\n  // VC position of this fragment. This should not branch/return/discard.\\n  //VTK::PositionVC::Impl\\n\\n  // Place any calls that require uniform flow (e.g. dFdx) here.\\n  //VTK::UniformFlow::Impl\\n\\n  // Set gl_FragDepth here (gl_FragCoord.z by default)\\n  //VTK::Depth::Impl\\n\\n  // Early depth peeling abort:\\n  //VTK::DepthPeeling::PreColor\\n\\n  // Apple Bug\\n  //VTK::PrimID::Impl\\n\\n  //VTK::Clip::Impl\\n\\n  //VTK::Color::Impl\\n\\n  // Generate the normal if we are not passed in one\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Light::Impl\\n\\n  if (gl_FragData[0].a <= 0.0)\\n    {\\n    discard;\\n    }\\n\\n  //VTK::DepthPeeling::Impl\\n\\n  //VTK::Picking::Impl\\n\\n  // handle coincident offsets\\n  //VTK::Coincident::Impl\\n\\n  //VTK::ZBuffer::Impl\\n\\n  //VTK::RenderPassFragmentShader::Impl\\n}\\n&quot;,Ed=function(e,t){e.replaceShaderCoincidentOffset=(n,r,o)=>{const a=e.getCoincidentParameters(r,o);if(a&&(0!==a.factor||0!==a.offset)){let e=n.Fragment;e=td.substitute(e,&quot;//VTK::Coincident::Dec&quot;,[&quot;uniform float cfactor;&quot;,&quot;uniform float coffset;&quot;]).result,t.context.getExtension(&quot;EXT_frag_depth&quot;)&&(0!==a.factor?(e=td.substitute(e,&quot;//VTK::UniformFlow::Impl&quot;,[&quot;float cscale = length(vec2(dFdx(gl_FragCoord.z),dFdy(gl_FragCoord.z)));&quot;,&quot;//VTK::UniformFlow::Impl&quot;],!1).result,e=td.substitute(e,&quot;//VTK::Depth::Impl&quot;,&quot;gl_FragDepthEXT = gl_FragCoord.z + cfactor*cscale + 0.000016*coffset;&quot;).result):e=td.substitute(e,&quot;//VTK::Depth::Impl&quot;,&quot;gl_FragDepthEXT = gl_FragCoord.z + 0.000016*coffset;&quot;).result),t._openGLRenderWindow.getWebgl2()&&(0!==a.factor?(e=td.substitute(e,&quot;//VTK::UniformFlow::Impl&quot;,[&quot;float cscale = length(vec2(dFdx(gl_FragCoord.z),dFdy(gl_FragCoord.z)));&quot;,&quot;//VTK::UniformFlow::Impl&quot;],!1).result,e=td.substitute(e,&quot;//VTK::Depth::Impl&quot;,&quot;gl_FragDepth = gl_FragCoord.z + cfactor*cscale + 0.000016*coffset;&quot;).result):e=td.substitute(e,&quot;//VTK::Depth::Impl&quot;,&quot;gl_FragDepth = gl_FragCoord.z + 0.000016*coffset;&quot;).result),n.Fragment=e}}},Vd=function(e,t){e.applyShaderReplacements=(e,t,n)=>{let r=null;if(t&&(r=t.ShaderReplacements),r)for(let t=0;t<r.length;t++){const o=r[t];if(n&&o.replaceFirst||!n&&!o.replaceFirst){const t=o.shaderType,n=e[t],r=td.substitute(n,o.originalValue,o.replacementValue,o.replaceAll);e[t]=r.result}}},e.buildShaders=(n,r,o)=>{e.getReplacedShaderTemplate(n,r,o),t.lastRenderPassShaderReplacement=t.currentRenderPass?t.currentRenderPass.getShaderReplacement():null,t.lastRenderPassShaderReplacement&&t.lastRenderPassShaderReplacement(n);const a=t.renderable.getViewSpecificProperties().OpenGL;e.applyShaderReplacements(n,a,!0),e.replaceShaderValues(n,r,o),e.applyShaderReplacements(n,a)},e.getReplacedShaderTemplate=(n,r,o)=>{const a=t.renderable.getViewSpecificProperties().OpenGL;e.getShaderTemplate(n,r,o);let i=n.Vertex;if(a){const e=a.VertexShaderCode;void 0!==e&&&quot;&quot;!==e&&(i=e)}n.Vertex=i;let s=n.Fragment;if(a){const e=a.FragmentShaderCode;void 0!==e&&&quot;&quot;!==e&&(s=e)}n.Fragment=s;let l=n.Geometry;if(a){const e=a.GeometryShaderCode;void 0!==e&&(l=e)}n.Geometry=l}};const{FieldAssociations:Dd}=Us,{primTypes:Ld}=ld,{Representation:Bd,Shading:Nd}=os,{ScalarMode:Fd}=Gl,{Filter:_d,Wrap:kd}=Pd,{vtkErrorMacro:Gd}=Ht,Ud={type:&quot;StartEvent&quot;},zd={type:&quot;EndEvent&quot;},{CoordinateSystem:Wd}=Ki;const Hd={context:null,VBOBuildTime:0,VBOBuildString:null,primitives:null,primTypes:null,shaderRebuildString:null,tmpMat4:null,ambientColor:[],diffuseColor:[],specularColor:[],lightColor:[],lightDirection:[],lastHaveSeenDepthRequest:!1,haveSeenDepthRequest:!1,lastSelectionState:Al.MIN_KNOWN_PASS-1,selectionStateChanged:null,selectionWebGLIdsToVTKIds:null,pointPicking:!1};function jd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Hd,n),qt.extend(e,t,n),Ed(e,t,n),Vd(e,t,n),t.primitives=[],t.primTypes=Ld,t.tmpMat3=fe(new Float64Array(9)),t.tmpMat4=m(new Float64Array(16));for(let e=Ld.Start;e<Ld.End;e++)t.primitives[e]=ld.newInstance(),t.primitives[e].setPrimitiveType(e),t.primitives[e].set({lastLightComplexity:0,lastLightCount:0,lastSelectionPass:!1},!0);Ct(e,t,[&quot;context&quot;]),t.VBOBuildTime={},ht(t.VBOBuildTime,{mtime:0}),t.selectionStateChanged={},ht(t.selectionStateChanged,{mtime:0}),function(e,t){function n(e,t,n){return t.identity(n),e.reduce(((e,n,r)=>0===r?n?t.copy(e,n):t.identity(e):n?t.multiply(e,e,n):e),n)}t.classHierarchy.push(&quot;vtkOpenGLPolyDataMapper&quot;),e.buildPass=n=>{n&&(t.currentRenderPass=null,t.openGLActor=e.getFirstAncestorOfType(&quot;vtkOpenGLActor&quot;),t._openGLRenderer=t.openGLActor.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t.openGLCamera=t._openGLRenderer.getViewNodeFor(t._openGLRenderer.getRenderable().getActiveCamera()))},e.translucentPass=(n,r)=>{n&&(t.currentRenderPass=r,e.render())},e.zBufferPass=n=>{n&&(t.haveSeenDepthRequest=!0,t.renderDepth=!0,e.render(),t.renderDepth=!1)},e.opaqueZBufferPass=t=>e.zBufferPass(t),e.opaquePass=t=>{t&&e.render()},e.render=()=>{const n=t._openGLRenderWindow.getContext();if(t.context!==n){t.context=n;for(let e=Ld.Start;e<Ld.End;e++)t.primitives[e].setOpenGLRenderWindow(t._openGLRenderWindow)}const r=t.openGLActor.getRenderable(),o=t._openGLRenderer.getRenderable();e.renderPiece(o,r)},e.getShaderTemplate=(e,t,n)=>{e.Vertex=Rd,e.Fragment=Md,e.Geometry=&quot;&quot;},e.replaceShaderColor=(e,n,r)=>{let o=e.Vertex,a=e.Geometry,i=e.Fragment;const s=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);let l=[&quot;uniform float ambient;&quot;,&quot;uniform float diffuse;&quot;,&quot;uniform float specular;&quot;,&quot;uniform float opacityUniform; // the fragment opacity&quot;,&quot;uniform vec3 ambientColorUniform;&quot;,&quot;uniform vec3 diffuseColorUniform;&quot;];s&&(l=l.concat([&quot;uniform vec3 specularColorUniform;&quot;,&quot;uniform float specularPowerUniform;&quot;]));let c=[&quot;vec3 ambientColor;&quot;,&quot;  vec3 diffuseColor;&quot;,&quot;  float opacity;&quot;];s&&(c=c.concat([&quot;  vec3 specularColor;&quot;,&quot;  float specularPower;&quot;])),c=c.concat([&quot;  ambientColor = ambientColorUniform;&quot;,&quot;  diffuseColor = diffuseColorUniform;&quot;,&quot;  opacity = opacityUniform;&quot;]),s&&(c=c.concat([&quot;  specularColor = specularColorUniform;&quot;,&quot;  specularPower = specularPowerUniform;&quot;])),0===t.lastBoundBO.getCABO().getColorComponents()||t.drawingEdges||(l=l.concat([&quot;varying vec4 vertexColorVSOutput;&quot;]),o=td.substitute(o,&quot;//VTK::Color::Dec&quot;,[&quot;attribute vec4 scalarColor;&quot;,&quot;varying vec4 vertexColorVSOutput;&quot;]).result,o=td.substitute(o,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorVSOutput =  scalarColor;&quot;]).result,a=td.substitute(a,&quot;//VTK::Color::Dec&quot;,[&quot;in vec4 vertexColorVSOutput[];&quot;,&quot;out vec4 vertexColorGSOutput;&quot;]).result,a=td.substitute(a,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorGSOutput = vertexColorVSOutput[i];&quot;]).result),0===t.lastBoundBO.getCABO().getColorComponents()||t.drawingEdges?(t.renderable.getAreScalarsMappedFromCells()||t.renderable.getInterpolateScalarsBeforeMapping())&&t.renderable.getColorCoordinates()&&!t.drawingEdges?i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,c.concat([&quot;  vec4 texColor = texture2D(texture1, tcoordVCVSOutput.st);&quot;,&quot;  diffuseColor = texColor.rgb;&quot;,&quot;  ambientColor = texColor.rgb;&quot;,&quot;  opacity = opacity*texColor.a;&quot;])).result:(r.getBackfaceProperty()&&!t.drawingEdges&&(l=l.concat([&quot;uniform float opacityUniformBF; // the fragment opacity&quot;,&quot;uniform float ambientIntensityBF; // the material ambient&quot;,&quot;uniform float diffuseIntensityBF; // the material diffuse&quot;,&quot;uniform vec3 ambientColorUniformBF; // ambient material color&quot;,&quot;uniform vec3 diffuseColorUniformBF; // diffuse material color&quot;]),s?(l=l.concat([&quot;uniform float specularIntensityBF; // the material specular intensity&quot;,&quot;uniform vec3 specularColorUniformBF; // intensity weighted color&quot;,&quot;uniform float specularPowerUniformBF;&quot;]),c=c.concat([&quot;if (gl_FrontFacing == false) {&quot;,&quot;  ambientColor = ambientIntensityBF * ambientColorUniformBF;&quot;,&quot;  diffuseColor = diffuseIntensityBF * diffuseColorUniformBF;&quot;,&quot;  specularColor = specularIntensityBF * specularColorUniformBF;&quot;,&quot;  specularPower = specularPowerUniformBF;&quot;,&quot;  opacity = opacityUniformBF; }&quot;])):c=c.concat([&quot;if (gl_FrontFacing == false) {&quot;,&quot;  ambientColor = ambientIntensityBF * ambientColorUniformBF;&quot;,&quot;  diffuseColor = diffuseIntensityBF * diffuseColorUniformBF;&quot;,&quot;  opacity = opacityUniformBF; }&quot;])),t.haveCellScalars&&!t.drawingEdges&&(l=l.concat([&quot;uniform samplerBuffer texture1;&quot;])),i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,c).result):i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,c.concat([&quot;  diffuseColor = vertexColorVSOutput.rgb;&quot;,&quot;  ambientColor = vertexColorVSOutput.rgb;&quot;,&quot;  opacity = opacity*vertexColorVSOutput.a;&quot;])).result,i=td.substitute(i,&quot;//VTK::Color::Dec&quot;,l).result,e.Vertex=o,e.Geometry=a,e.Fragment=i},e.replaceShaderLight=(e,n,r)=>{let o=e.Fragment;const a=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;),i=t.lastBoundBO.getReferenceByName(&quot;lastLightCount&quot;);let s=[];switch(a){case 0:o=td.substitute(o,&quot;//VTK::Light::Impl&quot;,[&quot;  gl_FragData[0] = vec4(ambientColor * ambient + diffuseColor * diffuse, opacity);&quot;,&quot;  //VTK::Light::Impl&quot;],!1).result;break;case 1:o=td.substitute(o,&quot;//VTK::Light::Impl&quot;,[&quot;  float df = max(0.0, normalVCVSOutput.z);&quot;,&quot;  float sf = pow(df, specularPower);&quot;,&quot;  vec3 diffuseL = df * diffuseColor;&quot;,&quot;  vec3 specularL = sf * specularColor;&quot;,&quot;  gl_FragData[0] = vec4(ambientColor * ambient + diffuseL * diffuse + specularL * specular, opacity);&quot;,&quot;  //VTK::Light::Impl&quot;],!1).result;break;case 2:for(let e=0;e<i;++e)s=s.concat([`uniform vec3 lightColor${e};`,`uniform vec3 lightDirectionVC${e}; // normalized`,`uniform vec3 lightHalfAngleVC${e}; // normalized`]);o=td.substitute(o,&quot;//VTK::Light::Dec&quot;,s).result,s=[&quot;vec3 diffuseL = vec3(0,0,0);&quot;,&quot;  vec3 specularL = vec3(0,0,0);&quot;,&quot;  float df;&quot;];for(let e=0;e<i;++e)s=s.concat([`  df = max(0.0, dot(normalVCVSOutput, -lightDirectionVC${e}));`,`  diffuseL += ((df) * lightColor${e});`,`  if (dot(normalVCVSOutput, lightDirectionVC${e}) < 0.0)`,&quot;    {&quot;,`    float sf = sign(df)*pow(max(1e-5,\\n                                              dot(reflect(lightDirectionVC${e},normalVCVSOutput),\\n                                                  normalize(-vertexVC.xyz))),\\n                                         specularPower);`,`    specularL += (sf * lightColor${e});`,&quot;    }&quot;]);s=s.concat([&quot;  diffuseL = diffuseL * diffuseColor;&quot;,&quot;  specularL = specularL * specularColor;&quot;,&quot;  gl_FragData[0] = vec4(ambientColor * ambient + diffuseL * diffuse + specularL * specular, opacity);&quot;,&quot;  //VTK::Light::Impl&quot;]),o=td.substitute(o,&quot;//VTK::Light::Impl&quot;,s,!1).result;break;case 3:for(let e=0;e<i;++e)s=s.concat([`uniform vec3 lightColor${e};`,`uniform vec3 lightDirectionVC${e}; // normalized`,`uniform vec3 lightHalfAngleVC${e}; // normalized`,`uniform vec3 lightPositionVC${e};`,`uniform vec3 lightAttenuation${e};`,`uniform float lightConeAngle${e};`,`uniform float lightExponent${e};`,`uniform int lightPositional${e};`]);o=td.substitute(o,&quot;//VTK::Light::Dec&quot;,s).result,s=[&quot;vec3 diffuseL = vec3(0,0,0);&quot;,&quot;  vec3 specularL = vec3(0,0,0);&quot;,&quot;  vec3 vertLightDirectionVC;&quot;,&quot;  float attenuation;&quot;,&quot;  float df;&quot;];for(let e=0;e<i;++e)s=s.concat([&quot;  attenuation = 1.0;&quot;,`  if (lightPositional${e} == 0)`,&quot;    {&quot;,`      vertLightDirectionVC = lightDirectionVC${e};`,&quot;    }&quot;,&quot;  else&quot;,&quot;    {&quot;,`    vertLightDirectionVC = vertexVC.xyz - lightPositionVC${e};`,&quot;    float distanceVC = length(vertLightDirectionVC);&quot;,&quot;    vertLightDirectionVC = normalize(vertLightDirectionVC);&quot;,&quot;    attenuation = 1.0 /&quot;,`      (lightAttenuation${e}.x`,`       + lightAttenuation${e}.y * distanceVC`,`       + lightAttenuation${e}.z * distanceVC * distanceVC);`,&quot;    // per OpenGL standard cone angle is 90 or less for a spot light&quot;,`    if (lightConeAngle${e} <= 90.0)`,&quot;      {&quot;,`      float coneDot = dot(vertLightDirectionVC, lightDirectionVC${e});`,&quot;      // if inside the cone&quot;,`      if (coneDot >= cos(radians(lightConeAngle${e})))`,&quot;        {&quot;,`        attenuation = attenuation * pow(coneDot, lightExponent${e});`,&quot;        }&quot;,&quot;      else&quot;,&quot;        {&quot;,&quot;        attenuation = 0.0;&quot;,&quot;        }&quot;,&quot;      }&quot;,&quot;    }&quot;,&quot;    df = max(0.0, attenuation*dot(normalVCVSOutput, -vertLightDirectionVC));&quot;,`    diffuseL += ((df) * lightColor${e});`,&quot;    if (dot(normalVCVSOutput, vertLightDirectionVC) < 0.0)&quot;,&quot;      {&quot;,`      float sf = sign(df)*attenuation*pow(max(1e-5,\\n                                                           dot(reflect(lightDirectionVC${e},\\n                                                                       normalVCVSOutput),\\n                                                               normalize(-vertexVC.xyz))),\\n                                                       specularPower);`,`    specularL += ((sf) * lightColor${e});`,&quot;    }&quot;]);s=s.concat([&quot;  diffuseL = diffuseL * diffuseColor;&quot;,&quot;  specularL = specularL * specularColor;&quot;,&quot;  gl_FragData[0] = vec4(ambientColor * ambient + diffuseL * diffuse + specularL * specular, opacity);&quot;,&quot;  //VTK::Light::Impl&quot;]),o=td.substitute(o,&quot;//VTK::Light::Impl&quot;,s,!1).result;break;default:Gd(&quot;bad light complexity&quot;)}e.Fragment=o},e.replaceShaderNormal=(e,n,r)=>{if(t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;)>0){let n=e.Vertex,o=e.Geometry,a=e.Fragment;t.lastBoundBO.getCABO().getNormalOffset()?(n=td.substitute(n,&quot;//VTK::Normal::Dec&quot;,[&quot;attribute vec3 normalMC;&quot;,&quot;uniform mat3 normalMatrix;&quot;,&quot;varying vec3 normalVCVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::Normal::Impl&quot;,[&quot;normalVCVSOutput = normalMatrix * normalMC;&quot;]).result,o=td.substitute(o,&quot;//VTK::Normal::Dec&quot;,[&quot;in vec3 normalVCVSOutput[];&quot;,&quot;out vec3 normalVCGSOutput;&quot;]).result,o=td.substitute(o,&quot;//VTK::Normal::Impl&quot;,[&quot;normalVCGSOutput = normalVCVSOutput[i];&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Dec&quot;,[&quot;varying vec3 normalVCVSOutput;&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Impl&quot;,[&quot;vec3 normalVCVSOutput = normalize(normalVCVSOutput);&quot;,&quot;  if (gl_FrontFacing == false) { normalVCVSOutput = -normalVCVSOutput; }&quot;]).result):t.haveCellNormals?(a=td.substitute(a,&quot;//VTK::Normal::Dec&quot;,[&quot;uniform mat3 normalMatrix;&quot;,&quot;uniform samplerBuffer textureN;&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Impl&quot;,[&quot;vec3 normalVCVSOutput = normalize(normalMatrix *&quot;,&quot;    texelFetchBuffer(textureN, gl_PrimitiveID + PrimitiveIDOffset).xyz);&quot;,&quot;  if (gl_FrontFacing == false) { normalVCVSOutput = -normalVCVSOutput; }&quot;]).result):t.lastBoundBO.getOpenGLMode(r.getProperty().getRepresentation())===t.context.LINES?(a=td.substitute(a,&quot;//VTK::UniformFlow::Impl&quot;,[&quot;  vec3 fdx = dFdx(vertexVC.xyz);&quot;,&quot;  vec3 fdy = dFdy(vertexVC.xyz);&quot;,&quot;  //VTK::UniformFlow::Impl&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Impl&quot;,[&quot;vec3 normalVCVSOutput;&quot;,&quot;  if (abs(fdx.x) > 0.0)&quot;,&quot;    { fdx = normalize(fdx); normalVCVSOutput = normalize(cross(vec3(fdx.y, -fdx.x, 0.0), fdx)); }&quot;,&quot;  else { fdy = normalize(fdy); normalVCVSOutput = normalize(cross(vec3(fdy.y, -fdy.x, 0.0), fdy));}&quot;]).result):(a=td.substitute(a,&quot;//VTK::Normal::Dec&quot;,[&quot;uniform int cameraParallel;&quot;]).result,a=td.substitute(a,&quot;//VTK::UniformFlow::Impl&quot;,[&quot;  vec3 fdx = dFdx(vertexVC.xyz);&quot;,&quot;  vec3 fdy = dFdy(vertexVC.xyz);&quot;,&quot;  //VTK::UniformFlow::Impl&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Impl&quot;,[&quot;  fdx = normalize(fdx);&quot;,&quot;  fdy = normalize(fdy);&quot;,&quot;  vec3 normalVCVSOutput = normalize(cross(fdx,fdy));&quot;,&quot;  if (cameraParallel == 1 && normalVCVSOutput.z < 0.0) { normalVCVSOutput = -1.0*normalVCVSOutput; }&quot;,&quot;  if (cameraParallel == 0 && dot(normalVCVSOutput,vertexVC.xyz) > 0.0) { normalVCVSOutput = -1.0*normalVCVSOutput; }&quot;]).result),e.Vertex=n,e.Geometry=o,e.Fragment=a}},e.replaceShaderPositionVC=(e,n,r)=>{t.lastBoundBO.replaceShaderPositionVC(e,n,r);let o=e.Vertex,a=e.Geometry,i=e.Fragment;t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;)>0?(o=td.substitute(o,&quot;//VTK::PositionVC::Dec&quot;,[&quot;varying vec4 vertexVCVSOutput;&quot;]).result,o=td.substitute(o,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vertexVCVSOutput = MCVCMatrix * vertexMC;&quot;,&quot;  gl_Position = MCPCMatrix * vertexMC;&quot;]).result,o=td.substitute(o,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Dec&quot;,[&quot;in vec4 vertexVCVSOutput[];&quot;,&quot;out vec4 vertexVCGSOutput;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vertexVCGSOutput = vertexVCVSOutput[i];&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Dec&quot;,[&quot;varying vec4 vertexVCVSOutput;&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vec4 vertexVC = vertexVCVSOutput;&quot;]).result):(o=td.substitute(o,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;]).result,o=td.substitute(o,&quot;//VTK::PositionVC::Impl&quot;,[&quot;  gl_Position = MCPCMatrix * vertexMC;&quot;]).result),e.Vertex=o,e.Geometry=a,e.Fragment=i},e.replaceShaderTCoord=(e,n,r)=>{if(t.lastBoundBO.getCABO().getTCoordOffset()){let n=e.Vertex,r=e.Geometry,o=e.Fragment;if(t.drawingEdges)return;n=td.substitute(n,&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCVSOutput = tcoordMC;&quot;).result;const a=t.openGLActor.getActiveTextures();let i=2,s=2;if(a&&a.length>0&&(i=a[0].getComponents(),a[0].getTarget()===t.context.TEXTURE_CUBE_MAP&&(s=3)),t.renderable.getColorTextureMap()&&(i=t.renderable.getColorTextureMap().getPointData().getScalars().getNumberOfComponents(),s=2),2===s){if(n=td.substitute(n,&quot;//VTK::TCoord::Dec&quot;,&quot;attribute vec2 tcoordMC; varying vec2 tcoordVCVSOutput;&quot;).result,r=td.substitute(r,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec2 tcoordVCVSOutput[];&quot;,&quot;out vec2 tcoordVCGSOutput;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCGSOutput = tcoordVCVSOutput[i];&quot;).result,o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;varying vec2 tcoordVCVSOutput;&quot;,&quot;uniform sampler2D texture1;&quot;]).result,a&&a.length>=1)switch(i){case 1:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.r;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.r;&quot;]).result;break;case 2:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.r;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.r;&quot;,&quot;  opacity = opacity * tcolor.g;&quot;]).result;break;default:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.rgb;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.rgb;&quot;,&quot;  opacity = opacity * tcolor.a;&quot;]).result}}else switch(n=td.substitute(n,&quot;//VTK::TCoord::Dec&quot;,&quot;attribute vec3 tcoordMC; varying vec3 tcoordVCVSOutput;&quot;).result,r=td.substitute(r,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec3 tcoordVCVSOutput[];&quot;,&quot;out vec3 tcoordVCGSOutput;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCGSOutput = tcoordVCVSOutput[i];&quot;).result,o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;varying vec3 tcoordVCVSOutput;&quot;,&quot;uniform samplerCube texture1;&quot;]).result,i){case 1:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.r;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.r;&quot;]).result;break;case 2:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.r;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.r;&quot;,&quot;  opacity = opacity * tcolor.g;&quot;]).result;break;default:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.rgb;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.rgb;&quot;,&quot;  opacity = opacity * tcolor.a;&quot;]).result}e.Vertex=n,e.Geometry=r,e.Fragment=o}},e.replaceShaderClip=(e,n,r)=>{let o=e.Vertex,a=e.Fragment;if(t.renderable.getNumberOfClippingPlanes()){const e=t.renderable.getNumberOfClippingPlanes();o=td.substitute(o,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,`uniform vec4 clipPlanes[${e}];`,`varying float clipDistancesVSOutput[${e}];`]).result,o=td.substitute(o,&quot;//VTK::Clip::Impl&quot;,[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], vertexMC);&quot;,&quot;    }&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,`varying float clipDistancesVSOutput[${e}];`]).result,a=td.substitute(a,&quot;//VTK::Clip::Impl&quot;,[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    if (clipDistancesVSOutput[planeNum] < 0.0) discard;&quot;,&quot;    }&quot;]).result}e.Vertex=o,e.Fragment=a},e.getCoincidentParameters=(e,n)=>{let r={factor:0,offset:0};const o=n.getProperty();if(t.renderable.getResolveCoincidentTopology()==gl.PolygonOffset||o.getEdgeVisibility()&&o.getRepresentation()===Bd.SURFACE){const e=t.lastBoundBO.getPrimitiveType();e===Ld.Points||o.getRepresentation()===Bd.POINTS?r=t.renderable.getCoincidentTopologyPointOffsetParameter():e===Ld.Lines||o.getRepresentation()===Bd.WIREFRAME?r=t.renderable.getCoincidentTopologyLineOffsetParameters():e!==Ld.Tris&&e!==Ld.TriStrips||(r=t.renderable.getCoincidentTopologyPolygonOffsetParameters()),e!==Ld.TrisEdges&&e!==Ld.TriStripsEdges||(r=t.renderable.getCoincidentTopologyPolygonOffsetParameters(),r.factor/=2,r.offset/=2)}const a=t._openGLRenderer.getSelector();return a&&a.getFieldAssociation()===Dd.FIELD_ASSOCIATION_POINTS&&(r.offset-=2),r},e.replaceShaderPicking=(e,n,r)=>{let o=e.Fragment,a=e.Vertex;if(o=td.substitute(o,&quot;//VTK::Picking::Dec&quot;,[&quot;uniform int picking;&quot;,&quot;//VTK::Picking::Dec&quot;]).result,t._openGLRenderer.getSelector()){switch(t.lastSelectionState!==Al.ID_LOW24&&t.lastSelectionState!==Al.ID_HIGH24||(a=td.substitute(a,&quot;//VTK::Picking::Dec&quot;,[&quot;flat out int vertexIDVSOutput;\\n&quot;,&quot;uniform int VertexIDOffset;\\n&quot;]).result,a=td.substitute(a,&quot;//VTK::Picking::Impl&quot;,&quot;  vertexIDVSOutput = gl_VertexID + VertexIDOffset;\\n&quot;).result,o=td.substitute(o,&quot;//VTK::Picking::Dec&quot;,&quot;flat in int vertexIDVSOutput;\\n&quot;).result,o=td.substitute(o,&quot;//VTK::Picking::Impl&quot;,[&quot;  int idx = vertexIDVSOutput;&quot;,&quot;//VTK::Picking::Impl&quot;]).result),t.lastSelectionState){case Al.ID_LOW24:o=td.substitute(o,&quot;//VTK::Picking::Impl&quot;,&quot;  gl_FragData[0] = vec4(float(idx%256)/255.0, float((idx/256)%256)/255.0, float((idx/65536)%256)/255.0, 1.0);&quot;).result;break;case Al.ID_HIGH24:o=td.substitute(o,&quot;//VTK::Picking::Impl&quot;,&quot;  gl_FragData[0] = vec4(float((idx/16777216)%256)/255.0, 0.0, 0.0, 1.0);&quot;).result;break;default:o=td.substitute(o,&quot;//VTK::Picking::Dec&quot;,&quot;uniform vec3 mapperIndex;&quot;).result,o=td.substitute(o,&quot;//VTK::Picking::Impl&quot;,&quot;  gl_FragData[0] = picking != 0 ? vec4(mapperIndex,1.0) : gl_FragData[0];&quot;).result}e.Fragment=o,e.Vertex=a}},e.replaceShaderValues=(n,r,o)=>{if(e.replaceShaderColor(n,r,o),e.replaceShaderNormal(n,r,o),e.replaceShaderLight(n,r,o),e.replaceShaderTCoord(n,r,o),e.replaceShaderPicking(n,r,o),e.replaceShaderClip(n,r,o),e.replaceShaderCoincidentOffset(n,r,o),e.replaceShaderPositionVC(n,r,o),t.haveSeenDepthRequest){let e=n.Fragment;e=td.substitute(e,&quot;//VTK::ZBuffer::Dec&quot;,&quot;uniform int depthRequest;&quot;).result,e=td.substitute(e,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float iz = floor(gl_FragCoord.z*65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result,n.Fragment=e}},e.getNeedToRebuildShaders=(e,n,r)=>{let o=0,a=0;const i=e.getPrimitiveType(),s=t.currentInput;let l=!1;const c=s.getPointData().getNormals(),u=s.getCellData().getNormals(),d=r.getProperty().getInterpolation()===Nd.FLAT,p=r.getProperty().getRepresentation(),f=e.getOpenGLMode(p,i);if(f===t.context.TRIANGLES||u&&!c||!d&&c?l=!0:d||f!==t.context.LINES||(l=!0),r.getProperty().getLighting()&&l){o=0;const e=n.getLightsByReference();for(let t=0;t<e.length;++t){const n=e[t];n.getSwitch()>0&&(a++,0===o&&(o=1)),1===o&&(a>1||1!==n.getIntensity()||!n.lightTypeIsHeadLight())&&(o=2),o<3&&n.getPositional()&&(o=3)}}let g=!1;const m=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;),h=t.lastBoundBO.getReferenceByName(&quot;lastLightCount&quot;);return m===o&&h===a||(t.lastBoundBO.set({lastLightComplexity:o},!0),t.lastBoundBO.set({lastLightCount:a},!0),g=!0),(!t.currentRenderPass&&t.lastRenderPassShaderReplacement||t.currentRenderPass&&t.currentRenderPass.getShaderReplacement()!==t.lastRenderPassShaderReplacement)&&(g=!0),!!(t.lastHaveSeenDepthRequest!==t.haveSeenDepthRequest||e.getShaderSourceTime().getMTime()<t.renderable.getMTime()||e.getShaderSourceTime().getMTime()<t.currentInput.getMTime()||e.getShaderSourceTime().getMTime()<t.selectionStateChanged.getMTime()||g)&&(t.lastHaveSeenDepthRequest=t.haveSeenDepthRequest,!0)},e.invokeShaderCallbacks=(e,n,r)=>{const o=t.renderable.getViewSpecificProperties().ShadersCallbacks;o&&o.forEach((t=>{t.callback(t.userData,e,n,r)}))},e.setMapperShaderParameters=(n,r,o)=>{if(n.getProgram().isUniformUsed(&quot;PrimitiveIDOffset&quot;)&&n.getProgram().setUniformi(&quot;PrimitiveIDOffset&quot;,t.primitiveIDOffset),n.getProgram().isUniformUsed(&quot;VertexIDOffset&quot;)&&n.getProgram().setUniformi(&quot;VertexIDOffset&quot;,t.vertexIDOffset),n.getCABO().getElementCount()&&(t.VBOBuildTime.getMTime()>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())){const e=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);n.getProgram().isAttributeUsed(&quot;vertexMC&quot;)&&(n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;vertexMC&quot;,n.getCABO().getVertexOffset(),n.getCABO().getStride(),t.context.FLOAT,3,!1)||Gd(&quot;Error setting vertexMC in shader VAO.&quot;)),n.getProgram().isAttributeUsed(&quot;normalMC&quot;)&&n.getCABO().getNormalOffset()&&e>0?n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;normalMC&quot;,n.getCABO().getNormalOffset(),n.getCABO().getStride(),t.context.FLOAT,3,!1)||Gd(&quot;Error setting normalMC in shader VAO.&quot;):n.getVAO().removeAttributeArray(&quot;normalMC&quot;),t.renderable.getCustomShaderAttributes().forEach(((e,r)=>{n.getProgram().isAttributeUsed(`${e}MC`)&&(n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),`${e}MC`,n.getCABO().getCustomData()[r].offset,n.getCABO().getStride(),t.context.FLOAT,n.getCABO().getCustomData()[r].components,!1)||Gd(`Error setting ${e}MC in shader VAO.`))})),n.getProgram().isAttributeUsed(&quot;tcoordMC&quot;)&&n.getCABO().getTCoordOffset()?n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;tcoordMC&quot;,n.getCABO().getTCoordOffset(),n.getCABO().getStride(),t.context.FLOAT,n.getCABO().getTCoordComponents(),!1)||Gd(&quot;Error setting tcoordMC in shader VAO.&quot;):n.getVAO().removeAttributeArray(&quot;tcoordMC&quot;),n.getProgram().isAttributeUsed(&quot;scalarColor&quot;)&&n.getCABO().getColorComponents()?n.getVAO().addAttributeArray(n.getProgram(),n.getCABO().getColorBO(),&quot;scalarColor&quot;,n.getCABO().getColorOffset(),n.getCABO().getColorBOStride(),t.context.UNSIGNED_BYTE,4,!0)||Gd(&quot;Error setting scalarColor in shader VAO.&quot;):n.getVAO().removeAttributeArray(&quot;scalarColor&quot;),n.getAttributeUpdateTime().modified()}if(t.renderable.getNumberOfClippingPlanes()){const e=t.renderable.getNumberOfClippingPlanes(),r=[],a=n.getCABO().getCoordShiftAndScaleEnabled()?n.getCABO().getInverseShiftAndScaleMatrix():null,i=a?p(t.tmpMat4,o.getMatrix()):o.getMatrix();a&&(h(i,i),b(i,i,a),h(i,i));for(let n=0;n<e;n++){const e=[];t.renderable.getClippingPlaneInDataCoords(i,n,e);for(let t=0;t<4;t++)r.push(e[t])}n.getProgram().setUniformi(&quot;numClipPlanes&quot;,e),n.getProgram().setUniform4fv(&quot;clipPlanes&quot;,r)}t.internalColorTexture&&n.getProgram().isUniformUsed(&quot;texture1&quot;)&&n.getProgram().setUniformi(&quot;texture1&quot;,t.internalColorTexture.getTextureUnit());const a=t.openGLActor.getActiveTextures();if(a)for(let e=0;e<a.length;++e){const t=a[e].getTextureUnit(),r=`texture${t+1}`;n.getProgram().isUniformUsed(r)&&n.getProgram().setUniformi(r,t)}if(t.haveSeenDepthRequest&&n.getProgram().setUniformi(&quot;depthRequest&quot;,t.renderDepth?1:0),n.getProgram().isUniformUsed(&quot;coffset&quot;)){const t=e.getCoincidentParameters(r,o);n.getProgram().setUniformf(&quot;coffset&quot;,t.offset),n.getProgram().isUniformUsed(&quot;cfactor&quot;)&&n.getProgram().setUniformf(&quot;cfactor&quot;,t.factor)}n.setMapperShaderParameters(r,o,t._openGLRenderer.getTiledSizeAndOrigin());const i=t._openGLRenderer.getSelector();n.getProgram().setUniform3fArray(&quot;mapperIndex&quot;,i?i.getPropColorValue():[0,0,0]),n.getProgram().setUniformi(&quot;picking&quot;,i?i.getCurrentPass()+1:0)},e.setLightingShaderParameters=(e,n,r)=>{const o=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);if(o<2)return;const a=e.getProgram();let i=0;const s=n.getLightsByReference();for(let e=0;e<s.length;++e){const r=s[e];if(r.getSwitch()>0){const e=r.getColorByReference(),o=r.getIntensity();t.lightColor[0]=e[0]*o,t.lightColor[1]=e[1]*o,t.lightColor[2]=e[2]*o;const s=r.getDirection(),l=n.getActiveCamera().getViewMatrix(),c=[...s];r.lightTypeIsSceneLight()&&(c[0]=l[0]*s[0]+l[1]*s[1]+l[2]*s[2],c[1]=l[4]*s[0]+l[5]*s[1]+l[6]*s[2],c[2]=l[8]*s[0]+l[9]*s[1]+l[10]*s[2],Fo(c)),t.lightDirection[0]=c[0],t.lightDirection[1]=c[1],t.lightDirection[2]=c[2],Fo(t.lightDirection),a.setUniform3fArray(`lightColor${i}`,t.lightColor),a.setUniform3fArray(`lightDirectionVC${i}`,t.lightDirection),i++}}if(o<3)return;const l=n.getActiveCamera().getViewMatrix();h(l,l),i=0;for(let e=0;e<s.length;++e){const t=s[e];if(t.getSwitch()>0){const e=t.getTransformedPosition(),n=new Float64Array(3);In(n,e,l),a.setUniform3fArray(`lightAttenuation${i}`,t.getAttenuationValuesByReference()),a.setUniformi(`lightPositional${i}`,t.getPositional()),a.setUniformf(`lightExponent${i}`,t.getExponent()),a.setUniformf(`lightConeAngle${i}`,t.getConeAngle()),a.setUniform3fArray(`lightPositionVC${i}`,[n[0],n[1],n[2]]),i++}}},e.setCameraShaderParameters=(e,a,i)=>{const s=e.getProgram(),l=t.openGLCamera.getKeyMatrices(a),c=a.getActiveCamera(),u=t.openGLCamera.getKeyMatrixTime().getMTime(),d=s.getLastCameraMTime(),p=e.getCABO().getCoordShiftAndScaleEnabled()?e.getCABO().getInverseShiftAndScaleMatrix():null,f=i.getIsIdentity(),g=f?{mcwc:null,normalMatrix:null}:t.openGLActor.getKeyMatrices();if(i.getCoordinateSystem()===Wd.DISPLAY){const e=t._openGLRenderer.getTiledSizeAndOrigin();m(t.tmpMat4),t.tmpMat4[0]=2/e.usize,t.tmpMat4[12]=-1,t.tmpMat4[5]=2/e.vsize,t.tmpMat4[13]=-1,b(t.tmpMat4,t.tmpMat4,p),s.setUniformMatrix(&quot;MCPCMatrix&quot;,t.tmpMat4)}else s.setUniformMatrix(&quot;MCPCMatrix&quot;,n([l.wcpc,g.mcwc,p],r,t.tmpMat4));s.isUniformUsed(&quot;MCVCMatrix&quot;)&&s.setUniformMatrix(&quot;MCVCMatrix&quot;,n([l.wcvc,g.mcwc,p],r,t.tmpMat4)),s.isUniformUsed(&quot;normalMatrix&quot;)&&s.setUniformMatrix3x3(&quot;normalMatrix&quot;,n([l.normalMatrix,g.normalMatrix],o,t.tmpMat3)),d!==u&&(s.isUniformUsed(&quot;cameraParallel&quot;)&&s.setUniformi(&quot;cameraParallel&quot;,c.getParallelProjection()),s.setLastCameraMTime(u)),f||s.setLastCameraMTime(0)},e.setPropertyShaderParameters=(e,n,r)=>{const o=e.getProgram();let a=r.getProperty(),i=a.getOpacity(),s=t.drawingEdges?a.getEdgeColorByReference():a.getAmbientColorByReference(),l=t.drawingEdges?a.getEdgeColorByReference():a.getDiffuseColorByReference(),c=t.drawingEdges?1:a.getAmbient(),u=t.drawingEdges?0:a.getDiffuse(),d=t.drawingEdges?0:a.getSpecular();const p=a.getSpecularPower();o.setUniformf(&quot;opacityUniform&quot;,i),o.setUniform3fArray(&quot;ambientColorUniform&quot;,s),o.setUniform3fArray(&quot;diffuseColorUniform&quot;,l),o.setUniformf(&quot;ambient&quot;,c),o.setUniformf(&quot;diffuse&quot;,u);const f=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);if(f<1)return;let g=a.getSpecularColorByReference();if(o.setUniform3fArray(&quot;specularColorUniform&quot;,g),o.setUniformf(&quot;specularPowerUniform&quot;,p),o.setUniformf(&quot;specular&quot;,d),o.isUniformUsed(&quot;ambientIntensityBF&quot;)){if(a=r.getBackfaceProperty(),i=a.getOpacity(),s=a.getAmbientColor(),c=a.getAmbient(),l=a.getDiffuseColor(),u=a.getDiffuse(),g=a.getSpecularColor(),d=a.getSpecular(),o.setUniformf(&quot;ambientIntensityBF&quot;,c),o.setUniformf(&quot;diffuseIntensityBF&quot;,u),o.setUniformf(&quot;opacityUniformBF&quot;,i),o.setUniform3fArray(&quot;ambientColorUniformBF&quot;,s),o.setUniform3fArray(&quot;diffuseColorUniformBF&quot;,l),f<1)return;o.setUniformf(&quot;specularIntensityBF&quot;,d),o.setUniform3fArray(&quot;specularColorUniformBF&quot;,g),o.setUniformf(&quot;specularPowerUniformBF&quot;,p)}},e.updateMaximumPointCellIds=(e,n)=>{const r=t._openGLRenderer.getSelector();if(r){if(t.selectionWebGLIdsToVTKIds?.points?.length){const e=t.selectionWebGLIdsToVTKIds.points.length;r.setMaximumPointId(e-1)}if(t.selectionWebGLIdsToVTKIds?.cells?.length){const e=t.selectionWebGLIdsToVTKIds.cells.length;r.setMaximumCellId(e-1)}r.getFieldAssociation()===Dd.FIELD_ASSOCIATION_POINTS&&(t.pointPicking=!0)}},e.renderPieceStart=(n,r)=>{t.primitiveIDOffset=0,t.vertexIDOffset=0;const o=function(e){const t=e.getSelector();return t?t.getCurrentPass():Al.MIN_KNOWN_PASS-1}(t._openGLRenderer);t.lastSelectionState!==o&&(t.selectionStateChanged.modified(),t.lastSelectionState=o),t._openGLRenderer.getSelector()&&t._openGLRenderer.getSelector().renderProp(r),e.updateBufferObjects(n,r),t.renderable.getColorTextureMap()&&t.internalColorTexture.activate(),t.lastBoundBO=null},e.renderPieceDraw=(n,r)=>{const o=r.getProperty().getRepresentation(),a=r.getProperty().getEdgeVisibility()&&o===Bd.SURFACE,i=t._openGLRenderer.getSelector(),s=i&&i.getFieldAssociation()===Dd.FIELD_ASSOCIATION_POINTS&&(t.lastSelectionState===Al.ID_LOW24||t.lastSelectionState===Al.ID_HIGH24);for(let i=Ld.Start;i<Ld.End;i++)t.primitives[i].setPointPicking(s),t.primitives[i].getCABO().getElementCount()&&(t.drawingEdges=a&&(i===Ld.TrisEdges||i===Ld.TriStripsEdges),t.drawingEdges&&(t.renderDepth||t.lastSelectionState>=0)||(t.lastBoundBO=t.primitives[i],t.primitiveIDOffset+=t.primitives[i].drawArrays(n,r,o,e),t.vertexIDOffset+=t.primitives[i].getCABO().getElementCount()))},e.renderPieceFinish=(e,n)=>{t.LastBoundBO&&t.LastBoundBO.getVAO().release(),t.renderable.getColorTextureMap()&&t.internalColorTexture.deactivate()},e.renderPiece=(n,r)=>{if(e.invokeEvent(Ud),t.renderable.getStatic()||t.renderable.update(),t.currentInput=t.renderable.getInputData(),e.invokeEvent(zd),!t.currentInput)return void Gd(&quot;No input!&quot;);if(!t.currentInput.getPoints||!t.currentInput.getPoints().getNumberOfValues())return;const o=t.context,a=r.getProperty().getBackfaceCulling(),i=r.getProperty().getFrontfaceCulling();a||i?i?(t._openGLRenderWindow.enableCullFace(),o.cullFace(o.FRONT)):(t._openGLRenderWindow.enableCullFace(),o.cullFace(o.BACK)):t._openGLRenderWindow.disableCullFace(),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r)},e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n),e.updateMaximumPointCellIds()},e.getNeedToRebuildBufferObjects=(n,r)=>{const o=t.VBOBuildTime.getMTime();return o<e.getMTime()||o<t.renderable.getMTime()||o<r.getMTime()||o<t.currentInput.getMTime()},e.buildBufferObjects=(e,n)=>{const r=t.currentInput;if(null===r)return;t.renderable.mapScalars(r,1);const o=t.renderable.getColorMapColors();t.haveCellScalars=!1;const a=t.renderable.getScalarMode();t.renderable.getScalarVisibility()&&(a!==Fd.USE_CELL_DATA&&a!==Fd.USE_CELL_FIELD_DATA&&a!==Fd.USE_FIELD_DATA&&r.getPointData().getScalars()||a===Fd.USE_POINT_FIELD_DATA||!o||(t.haveCellScalars=!0));let i=n.getProperty().getInterpolation()!==Nd.FLAT?r.getPointData().getNormals():null;null===i&&r.getCellData().getNormals()&&(t.haveCellNormals=!0,i=r.getCellData().getNormals());const s=n.getProperty().getRepresentation();let l=r.getPointData().getTCoords();t.openGLActor.getActiveTextures()||(l=null);let c=!1;if(t.renderable.getColorCoordinates()){l=t.renderable.getColorCoordinates(),c=t.renderable.getAreScalarsMappedFromCells(),t.internalColorTexture||(t.internalColorTexture=Pd.newInstance({resizable:!0}));const e=t.internalColorTexture;e.setMinificationFilter(_d.NEAREST),e.setMagnificationFilter(_d.NEAREST),e.setWrapS(kd.CLAMP_TO_EDGE),e.setWrapT(kd.CLAMP_TO_EDGE),e.setOpenGLRenderWindow(t._openGLRenderWindow);const n=t.renderable.getColorTextureMap(),r=n.getExtent(),o=n.getPointData().getScalars();e.create2DFromRaw({width:r[1]-r[0]+1,height:r[3]-r[2]+1,numComps:o.getNumberOfComponents(),dataType:o.getDataType(),data:o.getData()}),e.activate(),e.sendParameters(),e.deactivate()}const u=`${r.getMTime()}A${s}B${r.getMTime()}C${i?i.getMTime():1}D${o?o.getMTime():1}E${n.getProperty().getEdgeVisibility()}F${l?l.getMTime():1}`;if(t.VBOBuildString!==u){const e={points:r.getPoints(),normals:i,tcoords:l,colors:o,cellOffset:0,vertexOffset:0,useTCoordsPerCell:c,haveCellScalars:t.haveCellScalars,haveCellNormals:t.haveCellNormals,customAttributes:t.renderable.getCustomShaderAttributes().map((e=>r.getPointData().getArrayByName(e)))};t.renderable.getPopulateSelectionSettings()&&(t.selectionWebGLIdsToVTKIds={points:null,cells:null});const a=[{inRep:&quot;verts&quot;,cells:r.getVerts()},{inRep:&quot;lines&quot;,cells:r.getLines()},{inRep:&quot;polys&quot;,cells:r.getPolys()},{inRep:&quot;strips&quot;,cells:r.getStrips()},{inRep:&quot;polys&quot;,cells:r.getPolys()},{inRep:&quot;strips&quot;,cells:r.getStrips()}],d=n.getProperty().getEdgeVisibility()&&s===Bd.SURFACE;for(let n=Ld.Start;n<Ld.End;n++)n!==Ld.TrisEdges&&n!==Ld.TriStripsEdges?(e.cellOffset+=t.primitives[n].getCABO().createVBO(a[n].cells,a[n].inRep,s,e,t.selectionWebGLIdsToVTKIds),e.vertexOffset+=t.primitives[n].getCABO().getElementCount()):d?t.primitives[n].getCABO().createVBO(a[n].cells,a[n].inRep,Bd.WIREFRAME,{...e,tcoords:null,colors:null,haveCellScalars:!1,haveCellNormals:!1}):t.primitives[n].releaseGraphicsResources();t.renderable.getPopulateSelectionSettings()&&t.renderable.setSelectionWebGLIdsToVTKIds(t.selectionWebGLIdsToVTKIds),t.VBOBuildString=u}t.VBOBuildTime.modified()},e.getAllocatedGPUMemoryInBytes=()=>{let e=0;return t.primitives.forEach((t=>{e+=t.getAllocatedGPUMemoryInBytes()})),e}}(e,t)}const Kd=Mt(jd,&quot;vtkOpenGLPolyDataMapper&quot;);var $d={newInstance:Kd,extend:jd};Jt(&quot;vtkMapper&quot;,Kd);const qd=1,{primTypes:Xd}=ld,{Filter:Yd,Wrap:Zd}=Pd,{vtkErrorMacro:Qd}=Ht,Jd={type:&quot;StartEvent&quot;},ep={type:&quot;EndEvent&quot;},tp={context:null,VBOBuildTime:0,VBOBuildString:null,primitives:null,primTypes:null,shaderRebuildString:null};const np=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,tp,n),qt.extend(e,t,n),Ed(e,t,n),Vd(e,t,n),t.primitives=[],t.primTypes=Xd,t.tmpMat4=m(new Float64Array(16));for(let e=Xd.Start;e<Xd.End;e++)t.primitives[e]=ld.newInstance(),t.primitives[e].setPrimitiveType(e),t.primitives[e].set({lastLightComplexity:0,lastLightCount:0,lastSelectionPass:!1},!0);Ct(e,t,[&quot;context&quot;]),t.VBOBuildTime={},ht(t.VBOBuildTime,{mtime:0}),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLPolyDataMapper2D&quot;),e.buildPass=n=>{n&&(t.openGLActor2D=e.getFirstAncestorOfType(&quot;vtkOpenGLActor2D&quot;),t._openGLRenderer=t.openGLActor2D.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t.openGLCamera=t._openGLRenderer.getViewNodeFor(t._openGLRenderer.getRenderable().getActiveCamera()))},e.overlayPass=t=>{t&&e.render()},e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkPolyData2DVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\n// all variables that represent positions or directions have a suffix\\n// indicating the coordinate system they are in. The possible values are\\n// MC - Model Coordinates\\n// WC - WC world coordinates\\n// VC - View Coordinates\\n// DC - Display Coordinates\\n\\nin vec4 vertexWC;\\n\\n// frag position in VC\\n//VTK::PositionVC::Dec\\n\\n// material property values\\n//VTK::Color::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// Apple Bug\\n//VTK::PrimID::Dec\\n\\nuniform mat4 WCVCMatrix;  // World to view matrix\\n\\nvoid main()\\n{\\n  // Apple Bug\\n  //VTK::PrimID::Impl\\n\\n  gl_Position = WCVCMatrix*vertexWC;\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::PositionVC::Impl\\n}\\n&quot;,e.Fragment=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkPolyData2DFS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\nuniform int PrimitiveIDOffset;\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// Scalar coloring\\n//VTK::Color::Dec\\n\\n// Depth Peeling\\n//VTK::DepthPeeling::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\n// Apple Bug\\n//VTK::PrimID::Dec\\n\\nvoid main()\\n{\\n  // Apple Bug\\n  //VTK::PrimID::Impl\\n\\n  //VTK::Color::Impl\\n  //VTK::TCoord::Impl\\n\\n  //VTK::DepthPeeling::Impl\\n  //VTK::Picking::Impl\\n\\n  if (gl_FragData[0].a <= 0.0)\\n    {\\n    discard;\\n    }\\n}\\n&quot;,e.Geometry=&quot;&quot;},e.render=()=>{const n=t._openGLRenderWindow.getContext();if(t.context!==n){t.context=n;for(let e=Xd.Start;e<Xd.End;e++)t.primitives[e].setOpenGLRenderWindow(t._openGLRenderWindow)}const r=t.openGLActor2D.getRenderable(),o=t._openGLRenderer.getRenderable();e.renderPiece(o,r)},e.renderPiece=(n,r)=>{if(e.invokeEvent(Jd),t.renderable.getStatic()||t.renderable.update(),t.currentInput=t.renderable.getInputData(),e.invokeEvent(ep),!t.currentInput)return void Qd(&quot;No input!&quot;);if(!t.currentInput.getPoints||!t.currentInput.getPoints().getNumberOfValues())return;const o=t.context;t._openGLRenderWindow.enableCullFace(),o.cullFace(o.BACK),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r)},e.renderPieceStart=(n,r)=>{t.primitiveIDOffset=0,t._openGLRenderer.getSelector()&&(t._openGLRenderer.getSelector().getCurrentPass(),t._openGLRenderer.getSelector().renderProp(r)),t.renderable.getColorTextureMap()&&t.internalColorTexture.activate(),e.updateBufferObjects(n,r),t.lastBoundBO=null},e.getNeedToRebuildShaders=(e,n,r)=>e.getShaderSourceTime().getMTime()<t.renderable.getMTime()||e.getShaderSourceTime().getMTime()<t.currentInput.getMTime(),e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n)},e.getNeedToRebuildBufferObjects=(n,r)=>{const o=t.VBOBuildTime.getMTime();return!!(o<e.getMTime()||o<t._openGLRenderWindow.getMTime()||o<t.renderable.getMTime()||o<r.getMTime()||o<t.currentInput.getMTime()||t.renderable.getTransformCoordinate()&&o<n.getMTime())},e.buildBufferObjects=(e,n)=>{const r=t.currentInput;if(null===r)return;t.renderable.mapScalars(r,n.getProperty().getOpacity());const o=t.renderable.getColorMapColors(),a=n.getProperty().getRepresentation();let i=r.getPointData().getTCoords();t.openGLActor2D.getActiveTextures()||(i=null);let s=!1;if(t.renderable.getColorCoordinates()){i=t.renderable.getColorCoordinates(),s=t.renderable.getAreScalarsMappedFromCells(),t.internalColorTexture||(t.internalColorTexture=Pd.newInstance({resizable:!0}));const e=t.internalColorTexture;e.setMinificationFilter(Yd.NEAREST),e.setMagnificationFilter(Yd.NEAREST),e.setWrapS(Zd.CLAMP_TO_EDGE),e.setWrapT(Zd.CLAMP_TO_EDGE),e.setOpenGLRenderWindow(t._openGLRenderWindow);const n=t.renderable.getColorTextureMap(),r=n.getExtent(),o=n.getPointData().getScalars();e.create2DFromRaw({width:r[1]-r[0]+1,height:r[3]-r[2]+1,numComps:o.getNumberOfComponents(),dataType:o.getDataType(),data:o.getData()}),e.activate(),e.sendParameters(),e.deactivate()}const l=t.renderable.getTransformCoordinate(),c=e.getRenderWindow().getViews()[0].getViewportSize(e),u=`${r.getMTime()}A${a}B${r.getMTime()}C${o?o.getMTime():1}D${i?i.getMTime():1}E${l?e.getMTime():1}F${c}`;if(t.VBOBuildString!==u){let n=r.getPoints();if(l){const t=Yl.newInstance(),r=n.getNumberOfPoints();t.setNumberOfPoints(r);const o=[];for(let a=0;a<r;++a){n.getPoint(a,o),l.setValue(o);const r=l.getComputedDoubleViewportValue(e);t.setPoint(a,r[0],r[1],0)}n=t}const c={points:n,tcoords:i,colors:o,cellOffset:0,useTCoordsPerCell:s,haveCellScalars:t.renderable.getAreScalarsMappedFromCells(),customAttributes:t.renderable.getCustomShaderAttributes().map((e=>r.getPointData().getArrayByName(e)))};c.cellOffset+=t.primitives[Xd.Points].getCABO().createVBO(r.getVerts(),&quot;verts&quot;,a,c),c.cellOffset+=t.primitives[Xd.Lines].getCABO().createVBO(r.getLines(),&quot;lines&quot;,a,c),c.cellOffset+=t.primitives[Xd.Tris].getCABO().createVBO(r.getPolys(),&quot;polys&quot;,a,c),c.cellOffset+=t.primitives[Xd.TriStrips].getCABO().createVBO(r.getStrips(),&quot;strips&quot;,a,c),t.VBOBuildTime.modified(),t.VBOBuildString=u}},e.renderPieceDraw=(n,r)=>{const o=r.getProperty().getRepresentation();t.context.depthMask(!0);for(let a=Xd.Start;a<Xd.End;a++)t.primitives[a].getCABO().getElementCount()&&(t.lastBoundBO=t.primitives[a],t.primitiveIDOffset+=t.primitives[a].drawArrays(n,r,o,e))},e.renderPieceFinish=(e,n)=>{t.lastBoundBO&&t.lastBoundBO.getVAO().release(),t.renderable.getColorTextureMap()&&t.internalColorTexture.deactivate()},e.replaceShaderValues=(t,n,r)=>{e.replaceShaderColor(t,n,r),e.replaceShaderTCoord(t,n,r),e.replaceShaderPicking(t,n,r),e.replaceShaderPositionVC(t,n,r)},e.replaceShaderColor=(e,n,r)=>{let o=e.Vertex,a=e.Geometry,i=e.Fragment,s=[&quot;uniform vec3 diffuseColorUniform;&quot;,&quot;uniform float opacityUniform;&quot;],l=[&quot;vec3 diffuseColor = diffuseColorUniform;&quot;,&quot;float opacity = opacityUniform;&quot;];0!==t.lastBoundBO.getCABO().getColorComponents()?(s=s.concat([&quot;varying vec4 vertexColorVSOutput;&quot;]),o=td.substitute(o,&quot;//VTK::Color::Dec&quot;,[&quot;attribute vec4 scalarColor;&quot;,&quot;varying vec4 vertexColorVSOutput;&quot;]).result,o=td.substitute(o,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorVSOutput =  scalarColor;&quot;]).result,a=td.substitute(a,&quot;//VTK::Color::Dec&quot;,[&quot;in vec4 vertexColorVSOutput[];&quot;,&quot;out vec4 vertexColorGSOutput;&quot;]).result,a=td.substitute(a,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorGSOutput = vertexColorVSOutput[i];&quot;]).result,i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,l.concat([&quot;  diffuseColor = vertexColorVSOutput.rgb;&quot;,&quot;  opacity = opacity*vertexColorVSOutput.a;&quot;])).result):t.renderable.getAreScalarsMappedFromCells()&&(l=l.concat([&quot;  vec4 texColor = texture2D(texture1, tcoordVCVSOutput.st);&quot;,&quot;  diffuseColor = texColor.rgb;&quot;,&quot;  opacity = opacity*texColor.a;&quot;])),l=l.concat([&quot;gl_FragData[0] = vec4(diffuseColor, opacity);&quot;]),i=td.substitute(i,&quot;//VTK::Color::Dec&quot;,s).result,i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,l).result,e.Vertex=o,e.Geometry=a,e.Fragment=i},e.replaceShaderTCoord=(e,n,r)=>{if(t.lastBoundBO.getCABO().getTCoordOffset()){let n=e.Vertex,r=e.Geometry,o=e.Fragment;const a=t.lastBoundBO.getCABO().getTCoordComponents();1===a?(n=td.substitute(n,&quot;//VTK::TCoord::Dec&quot;,[&quot;in float tcoordMC;&quot;,&quot;out float tcoordVCVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::TCoord::Impl&quot;,[&quot;tcoordVCVSOutput = tcoordMC;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Dec&quot;,[&quot;in float tcoordVCVSOutput[];\\n&quot;,&quot;out float tcoordVCGSOutput;&quot;]).result,r=td.substitute(r,[&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCGSOutput = tcoordVCVSOutput[i];&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;in float tcoordVCVSOutput;&quot;,&quot;uniform sampler2D texture1;&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;gl_FragData[0] = gl_FragData[0]*texture2D(texture1, vec2(tcoordVCVSOutput,0));&quot;]).result):2===a&&(n=td.substitute(n,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec2 tcoordMC;&quot;,&quot;out vec2 tcoordVCVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::TCoord::Impl&quot;,[&quot;tcoordVCVSOutput = tcoordMC;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec2 tcoordVCVSOutput[];\\n&quot;,&quot;out vec2 tcoordVCGSOutput;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Impl&quot;,[&quot;tcoordVCGSOutput = tcoordVCVSOutput[i];&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec2 tcoordVCVSOutput;&quot;,&quot;uniform sampler2D texture1;&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;gl_FragData[0] = gl_FragData[0]*texture2D(texture1, tcoordVCVSOutput.st);&quot;]).result),t.renderable.getAreScalarsMappedFromCells()&&(r=td.substitute(r,&quot;//VTK::PrimID::Impl&quot;,[&quot;gl_PrimitiveID = gl_PrimitiveIDIn;&quot;]).result),e.Vertex=n,e.Geometry=r,e.Fragment=o}},e.replaceShaderPicking=(e,t,n)=>{let r=e.Fragment;r=td.substitute(r,&quot;//VTK::Picking::Dec&quot;,[&quot;uniform vec3 mapperIndex;&quot;,&quot;uniform int picking;&quot;]).result,r=td.substitute(r,&quot;//VTK::Picking::Impl&quot;,&quot;  gl_FragData[0] = picking != 0 ? vec4(mapperIndex,1.0) : gl_FragData[0];&quot;).result,e.Fragment=r},e.replaceShaderPositionVC=(e,n,r)=>{t.lastBoundBO.replaceShaderPositionVC(e,n,r)},e.invokeShaderCallbacks=(e,n,r)=>{const o=t.renderable.getViewSpecificProperties().ShadersCallbacks;o&&o.forEach((t=>{t.callback(t.userData,e,n,r)}))},e.setMapperShaderParameters=(e,n,r)=>{if(e.getProgram().isUniformUsed(&quot;PrimitiveIDOffset&quot;)&&e.getProgram().setUniformi(&quot;PrimitiveIDOffset&quot;,t.primitiveIDOffset),e.getProgram().isAttributeUsed(&quot;vertexWC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;vertexWC&quot;,e.getCABO().getVertexOffset(),e.getCABO().getStride(),t.context.FLOAT,3,!1)||Qd(&quot;Error setting vertexWC in shader VAO.&quot;)),e.getCABO().getElementCount()&&(t.VBOBuildTime.getMTime()>e.getAttributeUpdateTime().getMTime()||e.getShaderSourceTime().getMTime()>e.getAttributeUpdateTime().getMTime())){t.renderable.getCustomShaderAttributes().forEach(((n,r)=>{e.getProgram().isAttributeUsed(`${n}MC`)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),`${n}MC`,e.getCABO().getCustomData()[r].offset,e.getCABO().getStride(),t.context.FLOAT,e.getCABO().getCustomData()[r].components,!1)||Qd(`Error setting ${n}MC in shader VAO.`))})),e.getProgram().isAttributeUsed(&quot;tcoordMC&quot;)&&e.getCABO().getTCoordOffset()?e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;tcoordMC&quot;,e.getCABO().getTCoordOffset(),e.getCABO().getStride(),t.context.FLOAT,e.getCABO().getTCoordComponents(),!1)||Qd(&quot;Error setting tcoordMC in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;tcoordMC&quot;),e.getProgram().isAttributeUsed(&quot;scalarColor&quot;)&&e.getCABO().getColorComponents()?e.getVAO().addAttributeArray(e.getProgram(),e.getCABO().getColorBO(),&quot;scalarColor&quot;,e.getCABO().getColorOffset(),e.getCABO().getColorBOStride(),t.context.UNSIGNED_BYTE,4,!0)||Qd(&quot;Error setting scalarColor in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;scalarColor&quot;),t.internalColorTexture&&e.getProgram().isUniformUsed(&quot;texture1&quot;)&&t.internalColorTexture.getTextureUnit()>-1&&e.getProgram().setUniformi(&quot;texture1&quot;,t.internalColorTexture.getTextureUnit());const o=t.openGLActor2D.getActiveTextures();if(o)for(let t=0;t<o.length;++t){const n=o[t].getTextureUnit(),r=`texture${n+1}`;e.getProgram().isUniformUsed(r)&&e.getProgram().setUniformi(r,n)}e.setMapperShaderParameters(n,r,t._openGLRenderer.getTiledSizeAndOrigin());const a=t._openGLRenderer.getSelector();e.getProgram().setUniform3fArray(&quot;mapperIndex&quot;,a?a.getPropColorValue():[0,0,0]),e.getProgram().setUniformi(&quot;picking&quot;,a?a.getCurrentPass()+1:0)}},e.setPropertyShaderParameters=(e,n,r)=>{const o=t.renderable.getColorMapColors();if(!o||0===o.getNumberOfComponents()){const t=e.getProgram(),n=r.getProperty(),o=n.getOpacity();t.setUniformf(&quot;opacityUniform&quot;,o);const a=n.getColor();t.setUniform3fArray(&quot;diffuseColorUniform&quot;,a)}},e.setLightingShaderParameters=(e,t,n)=>{},e.setCameraShaderParameters=(e,n,o)=>{const a=e.getProgram(),i=e.getCABO().getCoordShiftAndScaleEnabled()?e.getCABO().getInverseShiftAndScaleMatrix():null,s=n.getRenderWindow().getViews()[0].getViewportSize(n),l=n.getViewport(),c=o.getActualPositionCoordinate().getComputedDoubleViewportValue(n),u=[0,0,1,1],d=[0,0,1,1];if(d[0]=l[0]>=u[0]?l[0]:u[0],d[1]=l[1]>=u[1]?l[1]:u[1],d[2]=l[2]<=u[2]?l[2]:u[2],d[3]=l[3]<=u[3]?l[3]:u[3],d[0]>=d[2])return;if(d[1]>=d[3])return;s[0]=yo(s[0]*(d[2]-d[0])/(l[2]-l[0])),s[1]=yo(s[1]*(d[3]-d[1])/(l[3]-l[1]));const p=t._openGLRenderer.getParent().getSize(),f=yo(c[0]-(d[0]-l[0])*p[0]),g=yo(c[1]-(d[1]-l[1])*p[1]),v=-f;let T=-f+s[0];const y=-g;let b=-g+s[1];v===T&&(T=v+1),y===b&&(b=y+1);const x=m(new Float64Array(16));var C,S,A;x[0]=2/(T-v),x[5]=2/(b-y),x[3]=-1*(T+v)/(T-v),x[7]=-1*(b+y)/(b-y),x[10]=0,x[11]=o.getProperty().getDisplayLocation()===qd?-1:1,x[15]=1,h(x,x),a.setUniformMatrix(&quot;WCVCMatrix&quot;,(C=[x,i],S=r,A=t.tmpMat4,S.identity(A),C.reduce(((e,t,n)=>0===n?t?S.copy(e,t):S.identity(e):t?S.multiply(e,e,t):e),A)))},e.getAllocatedGPUMemoryInBytes=()=>{let e=0;return t.primitives.forEach((t=>{e+=t.getAllocatedGPUMemoryInBytes()})),e}}(e,t)}),&quot;vtkOpenGLPolyDataMapper2D&quot;);Jt(&quot;vtkMapper2D&quot;,np);var rp={Orientation:{HORIZONTAL:&quot;horizontal&quot;,VERTICAL:&quot;vertical&quot;,AUTO:&quot;auto&quot;}};const{VectorMode:op}=cl,{Orientation:ap}=rp;function ip(e,t,n){e.strokeStyle=t.strokeColor,e.lineWidth=t.strokeSize,e.fillStyle=t.fontColor;const r=t.fontSize??n;e.font=`${t.fontStyle} ${r}px ${t.fontFamily}`}function sp(e,t){return e=>{const n=e.getLastSize(),r=(n[0]/700)**.8,o=(n[1]/700)**.8,a=Math.min(r,o),i=e.getAxisTextStyle(),s=e.getTickTextStyle();Object.assign(i,t.axisTextStyle),Object.assign(s,t.tickTextStyle),void 0===i.fontSize&&(i.fontSize=Math.max(24*a,12)),void 0===s.fontSize&&(e.getLastAspectRatio()>1?s.fontSize=Math.max(20*a,10):s.fontSize=Math.max(16*a,10));const l=e.updateTextureAtlas();e.setTopTitle(!1);const c=e.getBoxSizeByReference();let u=!1;if(u=t.orientation===ap.VERTICAL||t.orientation!==ap.HORIZONTAL&&e.getLastAspectRatio()>1,u)e.setTickLabelPixelOffset(.3*s.fontSize),l.titleWidth<=l.tickWidth+e.getTickLabelPixelOffset()+.8*s.fontSize?(e.setTopTitle(!0),e.setAxisTitlePixelOffset(.2*s.fontSize),c[0]=2*(l.tickWidth+e.getTickLabelPixelOffset()+.8*s.fontSize)/n[0],e.setBoxPosition([.98-c[0],-.92])):(e.setAxisTitlePixelOffset(.2*s.fontSize),c[0]=2*(l.titleHeight+e.getAxisTitlePixelOffset()+l.tickWidth+e.getTickLabelPixelOffset()+.8*s.fontSize)/n[0],e.setBoxPosition([.99-c[0],-.92])),c[1]=Math.max(1.2,Math.min(1.84/o,1.84));else{e.setAxisTitlePixelOffset(1.2*s.fontSize),e.setTickLabelPixelOffset(.1*s.fontSize);const t=2*(.8*s.fontSize+l.titleHeight+e.getAxisTitlePixelOffset())/n[1],r=2*l.tickWidth/n[0];c[0]=Math.min(1.9,Math.max(1.4,1.4*r*(e.getTicks().length+3))),c[1]=t,e.setBoxPosition([-.5*c[0],-.97])}e.recomputeBarSegments(l)}}function lp(e,t){return e=>{const t=e.getLastTickBounds(),n=ro().domain([t[0],t[1]]),r=n.ticks(5),o=n.tickFormat(5);e.setTicks(r),e.setTickStrings(r.map(o))}}const cp=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{renderable:null};Object.assign(t,{},n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;axisTitlePixelOffset&quot;,&quot;tickLabelPixelOffset&quot;,&quot;renderable&quot;,&quot;topTitle&quot;,&quot;ticks&quot;,&quot;tickStrings&quot;,&quot;tickPositions&quot;]),Wt.get(e,t,[&quot;lastSize&quot;,&quot;lastAspectRatio&quot;,&quot;lastTickBounds&quot;,&quot;axisTextStyle&quot;,&quot;tickTextStyle&quot;,&quot;barActor&quot;,&quot;tmActor&quot;]),Wt.getArray(e,t,[&quot;boxPosition&quot;,&quot;boxSize&quot;]),Wt.setArray(e,t,[&quot;boxPosition&quot;,&quot;boxSize&quot;],2),t.forceUpdate=!1,t.lastRebuildTime={},Wt.obj(t.lastRebuildTime,{mtime:0}),t.lastSize=[-1,-1],t.tmCanvas=document.createElement(&quot;canvas&quot;),t.tmContext=t.tmCanvas.getContext(&quot;2d&quot;),t._tmAtlas=new Map,t.barMapper=Gl.newInstance(),t.barMapper.setInterpolateScalarsBeforeMapping(!0),t.barMapper.setUseLookupTableScalarRange(!0),t.polyData=gu.newInstance(),t.barMapper.setInputData(t.polyData),t.barActor=ss.newInstance(),t.barActor.setMapper(t.barMapper),t.tmPolyData=gu.newInstance(),t.tmMapper=Gl.newInstance(),t.tmMapper.setInputData(t.tmPolyData),t.tmTexture=vu.newInstance({resizable:!0}),t.tmTexture.setInterpolate(!1),t.tmActor=ss.newInstance({parentProp:e}),t.tmActor.setMapper(t.tmMapper),t.tmActor.addTexture(t.tmTexture),t.barPosition=[0,0],t.barSize=[0,0],t.boxPosition=[.88,-.92],t.boxSize=[.1,1.1],t.lastTickBounds=[],function(e,t){t.classHierarchy.push(&quot;vtkScalarBarActorHelper&quot;),e.setRenderable=n=>{t.renderable!==n&&(t.renderable=n,t.barActor.setProperty(n.getProperty()),t.barActor.setParentProp(n),t.barActor.setCoordinateSystemToDisplay(),t.tmActor.setProperty(n.getProperty()),t.tmActor.setParentProp(n),t.tmActor.setCoordinateSystemToDisplay(),t.generateTicks=n.generateTicks,t.axisTextStyle={...n.getAxisTextStyle()},t.tickTextStyle={...n.getTickTextStyle()},e.modified())},e.updateAPISpecificData=(n,r,o)=>{t.lastSize[0]===n[0]&&t.lastSize[1]===n[1]||(t.lastSize[0]=n[0],t.lastSize[1]=n[1],t.lastAspectRatio=n[0]/n[1],t.forceUpdate=!0);const a=t.renderable.getScalarsToColors();if(a&&t.renderable.getVisibility()&&(t.barMapper.setLookupTable(a),t.camera=r,t.renderWindow=o,t.forceUpdate||Math.max(a.getMTime(),e.getMTime(),t.renderable.getMTime())>t.lastRebuildTime.getMTime())){const n=a.getMappingRange();if(t.lastTickBounds=[...n],t.renderable.getGenerateTicks()(e),t.renderable.getAutomated())t.renderable.getAutoLayout()(e);else{t.axisTextStyle={...t.renderable.getAxisTextStyle()},t.tickTextStyle={...t.renderable.getTickTextStyle()},t.barPosition=[...t.renderable.getBarPosition()],t.barSize=[...t.renderable.getBarSize()],t.boxPosition=[...t.renderable.getBoxPosition()],t.boxSize=[...t.renderable.getBoxSize()],t.axisTitlePixelOffset=t.renderable.getAxisTitlePixelOffset(),t.tickLabelPixelOffset=t.renderable.getTickLabelPixelOffset();const n=e.updateTextureAtlas();e.recomputeBarSegments(n)}e.updatePolyDataForLabels(),e.updatePolyDataForBarSegments(),t.lastRebuildTime.modified(),t.forceUpdate=!1}},e.updateTextureAtlas=()=>{t.tmContext.textBaseline=&quot;bottom&quot;,t.tmContext.textAlign=&quot;left&quot;;const n={},r=new Map;let o=0,a=1;ip(t.tmContext,t.axisTextStyle,18);let i=t.tmContext.measureText(t.renderable.getAxisLabel()),s={height:i.actualBoundingBoxAscent+2,startingHeight:a,width:i.width+2,textStyle:t.axisTextStyle};r.set(t.renderable.getAxisLabel(),s),a+=s.height,o=s.width,n.titleWidth=s.width,n.titleHeight=s.height,n.tickWidth=0,n.tickHeight=0,ip(t.tmContext,t.tickTextStyle,14);const l=[...e.getTickStrings(),&quot;NaN&quot;,&quot;Below&quot;,&quot;Above&quot;];for(let e=0;e<l.length;e++)r.has(l[e])||(i=t.tmContext.measureText(l[e]),s={height:i.actualBoundingBoxAscent+2,startingHeight:a,width:i.width+2,textStyle:t.tickTextStyle},r.set(l[e],s),a+=s.height,o<s.width&&(o=s.width),n.tickWidth<s.width&&(n.tickWidth=s.width),n.tickHeight<s.height&&(n.tickHeight=s.height));return o=wo(o),a=wo(a),r.forEach((e=>{e.tcoords=[0,(a-e.startingHeight-e.height)/a,e.width/o,(a-e.startingHeight-e.height)/a,e.width/o,(a-e.startingHeight)/a,0,(a-e.startingHeight)/a]})),t.tmCanvas.width=o,t.tmCanvas.height=a,t.tmContext.textBaseline=&quot;bottom&quot;,t.tmContext.textAlign=&quot;left&quot;,t.tmContext.clearRect(0,0,o,a),r.forEach(((e,n)=>{const r=e.textStyle===t.axisTextStyle?18:14;ip(t.tmContext,e.textStyle,r),t.tmContext.fillText(n,1,e.startingHeight+e.height-1)})),t.tmTexture.setCanvas(t.tmCanvas),t.tmTexture.modified(),t._tmAtlas=r,n},e.computeBarSize=e=>{t.vertical=t.boxSize[1]>t.boxSize[0];const n=2*e.tickHeight/t.lastSize[1],r=[1,1];if(t.vertical){const o=2*(e.tickWidth+t.tickLabelPixelOffset)/t.lastSize[0];if(t.topTitle){const n=2*(e.titleHeight+t.axisTitlePixelOffset)/t.lastSize[1];t.barSize[0]=t.boxSize[0]-o,t.barSize[1]=t.boxSize[1]-n}else{const n=2*(e.titleHeight+t.axisTitlePixelOffset)/t.lastSize[0];t.barSize[0]=t.boxSize[0]-n-o,t.barSize[1]=t.boxSize[1]}t.barPosition[0]=t.boxPosition[0]+o,t.barPosition[1]=t.boxPosition[1],r[1]=n}else{const n=(2*e.tickWidth-8)/t.lastSize[0],o=2*(e.titleHeight+t.axisTitlePixelOffset)/t.lastSize[1];t.barSize[0]=t.boxSize[0],t.barPosition[0]=t.boxPosition[0],t.barSize[1]=t.boxSize[1]-o,t.barPosition[1]=t.boxPosition[1],r[0]=n}return r},e.recomputeBarSegments=n=>{const r=e.computeBarSize(n);t.barSegments=[];const o=[0,0],a=t.vertical?1:0,i=t.vertical?.01:.02;function s(e,n){t.barSegments.push({corners:[[...o],[o[0]+r[0],o[1]],[o[0]+r[0],o[1]+r[1]],[o[0],o[1]+r[1]]],scalars:n,title:e}),o[a]+=r[a]+i}t.renderable.getDrawNanAnnotation()&&t.renderable.getScalarsToColors().getNanColor()&&s(&quot;NaN&quot;,[NaN,NaN,NaN,NaN]),t.renderable.getDrawBelowRangeSwatch()&&t.renderable.getScalarsToColors().getUseBelowRangeColor?.()&&s(&quot;Below&quot;,[-.1,-.1,-.1,-.1]);const l=t.renderable.getScalarsToColors().getUseAboveRangeColor?.();o[a]+=i;const c=r[a];r[a]=l?1-2*i-r[a]-o[a]:1-i-o[a],s(&quot;ticks&quot;,t.vertical?[0,0,.995,.995]:[0,.995,.995,0]),t.renderable.getDrawAboveRangeSwatch()&&l&&(r[a]=c,o[a]+=i,s(&quot;Above&quot;,[1.1,1.1,1.1,1.1]))};const n=new Float64Array(3);e.createPolyDataForOneLabel=(e,r,o,a,i,s)=>{const l=t._tmAtlas.get(e);if(!l)return;let c=s.ptIdx,u=s.cellIdx;n[0]=(.5*r[0]+.5)*t.lastSize[0],n[1]=(.5*r[1]+.5)*t.lastSize[1],n[2]=r[2],n[0]+=i[0],n[1]+=i[1];const d=[],p=&quot;vertical&quot;===a?[1,0]:[0,1];&quot;vertical&quot;===a?(d[0]=l.width,d[1]=-l.height,&quot;middle&quot;===o[0]?n[1]-=l.width/2:&quot;right&quot;===o[0]&&(n[1]-=l.width),&quot;middle&quot;===o[1]?n[0]+=l.height/2:&quot;top&quot;===o[1]&&(n[0]+=l.height)):(d[0]=l.width,d[1]=l.height,&quot;middle&quot;===o[0]?n[0]-=l.width/2:&quot;right&quot;===o[0]&&(n[0]-=l.width),&quot;middle&quot;===o[1]?n[1]-=l.height/2:&quot;top&quot;===o[1]&&(n[1]-=l.height)),s.points[3*c]=n[0],s.points[3*c+1]=n[1],s.points[3*c+2]=n[2],s.tcoords[2*c]=l.tcoords[0],s.tcoords[2*c+1]=l.tcoords[1],c++,n[p[0]]+=d[0],s.points[3*c]=n[0],s.points[3*c+1]=n[1],s.points[3*c+2]=n[2],s.tcoords[2*c]=l.tcoords[2],s.tcoords[2*c+1]=l.tcoords[3],c++,n[p[1]]+=d[1],s.points[3*c]=n[0],s.points[3*c+1]=n[1],s.points[3*c+2]=n[2],s.tcoords[2*c]=l.tcoords[4],s.tcoords[2*c+1]=l.tcoords[5],c++,n[p[0]]-=d[0],s.points[3*c]=n[0],s.points[3*c+1]=n[1],s.points[3*c+2]=n[2],s.tcoords[2*c]=l.tcoords[6],s.tcoords[2*c+1]=l.tcoords[7],c++,s.polys[4*u]=3,s.polys[4*u+1]=c-4,s.polys[4*u+2]=c-3,s.polys[4*u+3]=c-2,u++,s.polys[4*u]=3,s.polys[4*u+1]=c-4,s.polys[4*u+2]=c-2,s.polys[4*u+3]=c-1,s.ptIdx+=4,s.cellIdx+=2};const r=new Float64Array(3);e.updatePolyDataForLabels=()=>{const n=e.getTickStrings().length+t.barSegments.length,o=4*n,a=2*n,i=new Float64Array(3*o),s=new Uint16Array(4*a),l=new Float32Array(2*o),c={ptIdx:0,cellIdx:0,polys:s,points:i,tcoords:l},u=t.vertical?0:1,d=t.vertical?1:0;r[2]=-.99;const p=t.vertical?[&quot;right&quot;,&quot;middle&quot;]:[&quot;middle&quot;,&quot;bottom&quot;];let f=[0,1];const g=[0,0];t.vertical?(g[0]=-t.tickLabelPixelOffset,t.topTitle?(r[0]=t.boxPosition[0]+.5*t.boxSize[0],r[1]=t.barPosition[1]+t.barSize[1],e.createPolyDataForOneLabel(t.renderable.getAxisLabel(),r,[&quot;middle&quot;,&quot;bottom&quot;],&quot;horizontal&quot;,[0,t.axisTitlePixelOffset],c)):(r[0]=t.barPosition[0]+t.barSize[0],r[1]=t.barPosition[1]+.5*t.barSize[1],e.createPolyDataForOneLabel(t.renderable.getAxisLabel(),r,[&quot;middle&quot;,&quot;top&quot;],&quot;vertical&quot;,[t.axisTitlePixelOffset,0],c)),f=[-1,0]):(g[1]=t.tickLabelPixelOffset,r[0]=t.barPosition[0]+.5*t.barSize[0],r[1]=t.barPosition[1]+t.barSize[1],e.createPolyDataForOneLabel(t.renderable.getAxisLabel(),r,[&quot;middle&quot;,&quot;bottom&quot;],&quot;horizontal&quot;,[0,t.axisTitlePixelOffset],c)),r[u]=t.barPosition[u]+(.5*f[u]+.5)*t.barSize[u],r[d]=t.barPosition[d]+.5*t.barSize[d];let m=null;for(let n=0;n<t.barSegments.length;n++){const o=t.barSegments[n];&quot;ticks&quot;===o.title?m=o:(r[d]=t.barPosition[d]+.5*t.barSize[d]*(o.corners[2][d]+o.corners[0][d]),e.createPolyDataForOneLabel(o.title,r,p,&quot;horizontal&quot;,g,c))}const h=t.barPosition[d]+t.barSize[d]*m.corners[0][d],v=t.barSize[d]*(m.corners[2][d]-m.corners[0][d]),T=e.getTicks(),y=e.getTickStrings(),b=e.getTickPositions();for(let n=0;n<T.length;n++){const o=b?b[n]:(T[n]-t.lastTickBounds[0])/(t.lastTickBounds[1]-t.lastTickBounds[0]);r[d]=h+v*o,e.createPolyDataForOneLabel(y[n],r,p,&quot;horizontal&quot;,g,c)}const x=xs.newInstance({numberOfComponents:2,values:l,name:&quot;TextureCoordinates&quot;});t.tmPolyData.getPointData().setTCoords(x),t.tmPolyData.getPoints().setData(i,3),t.tmPolyData.getPoints().modified(),t.tmPolyData.getPolys().setData(s,1),t.tmPolyData.getPolys().modified(),t.tmPolyData.modified()},e.updatePolyDataForBarSegments=()=>{const e=t.renderable.getScalarsToColors();let n=0;t.renderable.getDrawNanAnnotation()&&e.getNanColor()&&(n+=1),t.renderable.getDrawBelowRangeSwatch()&&e.getUseBelowRangeColor?.()&&(n+=1),t.renderable.getDrawAboveRangeSwatch()&&e.getUseAboveRangeColor?.()&&(n+=1);const o=4*(1+n),a=o;let i=1;e.getVectorMode()===op.COMPONENT&&(i=e.getVectorComponent()+1);const s=new Float64Array(3*o),l=new Uint16Array(5*a),c=new Float32Array(o*i);let u=0,d=0;for(let e=0;e<t.barSegments.length;e++){const n=t.barSegments[e];for(let e=0;e<4;e++){r[0]=t.barPosition[0]+n.corners[e][0]*t.barSize[0],r[1]=t.barPosition[1]+n.corners[e][1]*t.barSize[1],s[3*u]=(.5*r[0]+.5)*t.lastSize[0],s[3*u+1]=(.5*r[1]+.5)*t.lastSize[1],s[3*u+2]=r[2];for(let r=0;r<i;r++)c[u*i+r]=t.lastTickBounds[0]+n.scalars[e]*(t.lastTickBounds[1]-t.lastTickBounds[0]);u++}l[5*d]=4,l[5*d+1]=u-4,l[5*d+2]=u-3,l[5*d+3]=u-2,l[5*d+4]=u-1,d++}const p=xs.newInstance({numberOfComponents:i,values:c,name:&quot;Scalars&quot;});t.polyData.getPointData().setScalars(p),t.polyData.getPoints().setData(s,3),t.polyData.getPoints().modified(),t.polyData.getPolys().setData(l,1),t.polyData.getPolys().modified(),t.polyData.modified()}}(e,t)}),&quot;vtkScalarBarActorHelper&quot;);function up(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,function(e){return{automated:!0,autoLayout:null,axisLabel:&quot;Scalar Value&quot;,barPosition:[0,0],barSize:[0,0],boxPosition:[.88,-.92],boxSize:[.1,1.1],scalarToColors:null,axisTitlePixelOffset:36,axisTextStyle:{fontColor:&quot;white&quot;,fontStyle:&quot;normal&quot;,fontSize:void 0,fontFamily:&quot;serif&quot;},tickLabelPixelOffset:14,tickTextStyle:{fontColor:&quot;white&quot;,fontStyle:&quot;normal&quot;,fontSize:void 0,fontFamily:&quot;serif&quot;},generateTicks:null,drawNanAnnotation:!0,drawBelowRangeSwatch:!0,drawAboveRangeSwatch:!0,orientation:null,...e}}(n)),t.autoLayout||(t.autoLayout=sp(0,t)),t.generateTicks||(t.generateTicks=lp()),ss.extend(e,t,n),e.getProperty().setDiffuse(0),e.getProperty().setAmbient(1),Wt.setGet(e,t,[&quot;automated&quot;,&quot;autoLayout&quot;,&quot;axisTitlePixelOffset&quot;,&quot;axisLabel&quot;,&quot;scalarsToColors&quot;,&quot;tickLabelPixelOffset&quot;,&quot;generateTicks&quot;,&quot;drawNanAnnotation&quot;,&quot;drawBelowRangeSwatch&quot;,&quot;drawAboveRangeSwatch&quot;,&quot;orientation&quot;]),Wt.get(e,t,[&quot;axisTextStyle&quot;,&quot;tickTextStyle&quot;]),Wt.getArray(e,t,[&quot;barPosition&quot;,&quot;barSize&quot;,&quot;boxPosition&quot;,&quot;boxSize&quot;]),Wt.setArray(e,t,[&quot;barPosition&quot;,&quot;barSize&quot;,&quot;boxPosition&quot;,&quot;boxSize&quot;],2),function(e,t){t.classHierarchy.push(&quot;vtkScalarBarActor&quot;),e.setTickTextStyle=n=>{t.tickTextStyle={...t.tickTextStyle,...n},e.modified()},e.setAxisTextStyle=n=>{t.axisTextStyle={...t.axisTextStyle,...n},e.modified()},e.setOrientationToHorizontal=()=>e.setOrientation(ap.HORIZONTAL),e.setOrientationToVertical=()=>e.setOrientation(ap.VERTICAL),e.resetAutoLayoutToDefault=()=>{e.setAutoLayout(sp(0,t))},e.resetGenerateTicksToDefault=()=>{e.setGenerateTicks(lp())}}(e,t)}var dp={newInstance:Wt.newInstance(up,&quot;vtkScalarBarActor&quot;),extend:up,newScalarBarActorHelper:cp,...rp};const pp={};const fp=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,pp,n),qt.extend(e,t,n),t.scalarBarActorHelper=dp.newScalarBarActorHelper(),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLScalarBarActor&quot;),e.buildPass=n=>{n&&(t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getParent(),t.scalarBarActorHelper.getRenderable()||t.scalarBarActorHelper.setRenderable(t.renderable),e.prepareNodes(),e.addMissingNode(t.scalarBarActorHelper.getBarActor()),e.addMissingNode(t.scalarBarActorHelper.getTmActor()),e.removeUnusedNodes())},e.opaquePass=(e,n)=>{if(e){const e=t._openGLRenderer?t._openGLRenderer.getRenderable().getActiveCamera():null,n=t._openGLRenderer.getTiledSizeAndOrigin();t.scalarBarActorHelper.updateAPISpecificData([n.usize,n.vsize],e,t._openGLRenderWindow.getRenderable())}}}(e,t)}),&quot;vtkOpenGLScalarBarActor&quot;);Jt(&quot;vtkScalarBarActor&quot;,fp);const{vtkErrorMacro:gp}=Ht,mp={context:null};const hp=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,mp,n),qt.extend(e,t,n),t.openGLTexture=Pd.newInstance(),t.tris=ld.newInstance(),t.keyMatrixTime={},ht(t.keyMatrixTime,{mtime:0}),t.keyMatrices={normalMatrix:fe(new Float64Array(9)),mcwc:m(new Float64Array(16))},Ct(e,t,[&quot;context&quot;]),Tt(e,t,[&quot;activeTextures&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLSkybox&quot;),e.buildPass=n=>{if(n){t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getParent(),t.context=t._openGLRenderWindow.getContext(),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow),t.openGLTexture.setOpenGLRenderWindow(t._openGLRenderWindow);const n=t._openGLRenderer.getRenderable();t.openGLCamera=t._openGLRenderer.getViewNodeFor(n.getActiveCamera())}},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;n.incrementOpaqueActorCount()}},e.opaquePass=(n,r)=>{if(n&&!t._openGLRenderer.getSelector()){e.updateBufferObjects(),t.context.depthMask(!0),t._openGLRenderWindow.getShaderCache().readyShaderProgram(t.tris.getProgram()),t.openGLTexture.render(t._openGLRenderWindow);const n=t.openGLTexture.getTextureUnit();t.tris.getProgram().setUniformi(&quot;sbtexture&quot;,n);const r=t._openGLRenderer.getRenderable(),o=t.openGLCamera.getKeyMatrices(r),a=new Float64Array(16);if(v(a,o.wcpc),t.tris.getProgram().setUniformMatrix(&quot;IMCPCMatrix&quot;,a),&quot;box&quot;===t.lastFormat){const e=r.getActiveCamera().getPosition();t.tris.getProgram().setUniform3f(&quot;camPos&quot;,e[0],e[1],e[2])}t.tris.getVAO().bind(),t.context.drawArrays(t.context.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release(),t.openGLTexture.deactivate()}},e.updateBufferObjects=()=>{if(!t.tris.getCABO().getElementCount()){const e=new Float32Array(12);for(let t=0;t<4;t++)e[3*t]=t%2*2-1,e[3*t+1]=t>1?1:-1,e[3*t+2]=1;const n=xs.newInstance({numberOfComponents:3,values:e});n.setName(&quot;points&quot;);const r=new Uint16Array(8);r[0]=3,r[1]=0,r[2]=1,r[3]=3,r[4]=3,r[5]=0,r[6]=3,r[7]=2;const o=xs.newInstance({numberOfComponents:1,values:r});t.tris.getCABO().createVBO(o,&quot;polys&quot;,Zi.SURFACE,{points:n,cellOffset:0})}t.renderable.getFormat()!==t.lastFormat&&(t.lastFormat=t.renderable.getFormat(),&quot;box&quot;===t.lastFormat&&t.tris.setProgram(t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(&quot;//VTK::System::Dec\\n             attribute vec3 vertexMC;\\n             uniform mat4 IMCPCMatrix;\\n             varying vec3 TexCoords;\\n             void main () {\\n              gl_Position = vec4(vertexMC.xyz, 1.0);\\n              vec4 wpos = IMCPCMatrix * gl_Position;\\n              TexCoords = wpos.xyz/wpos.w;\\n             }&quot;,&quot;//VTK::System::Dec\\n             //VTK::Output::Dec\\n             varying vec3 TexCoords;\\n             uniform samplerCube sbtexture;\\n             uniform vec3 camPos;\\n             void main () {\\n               // skybox looks from inside out\\n               // which means we have to adjust\\n               // our tcoords. Otherwise text would\\n               // be flipped\\n               vec3 tc = normalize(TexCoords - camPos);\\n               if (abs(tc.z) < max(abs(tc.x),abs(tc.y)))\\n               {\\n                 tc = vec3(1.0, 1.0, -1.0) * tc;\\n               }\\n               else\\n               {\\n                 tc = vec3(-1.0, 1.0, 1.0) * tc;\\n               }\\n               gl_FragData[0] = textureCube(sbtexture, tc);\\n             }&quot;,&quot;&quot;)),&quot;background&quot;===t.lastFormat&&t.tris.setProgram(t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(&quot;//VTK::System::Dec\\n             attribute vec3 vertexMC;\\n             uniform mat4 IMCPCMatrix;\\n             varying vec2 TexCoords;\\n             void main () {\\n              gl_Position = vec4(vertexMC.xyz, 1.0);\\n              vec4 wpos = IMCPCMatrix * gl_Position;\\n              TexCoords = vec2(vertexMC.x, vertexMC.y)*0.5 + 0.5;\\n             }&quot;,&quot;//VTK::System::Dec\\n             //VTK::Output::Dec\\n             varying vec2 TexCoords;\\n             uniform sampler2D sbtexture;\\n             void main () {\\n               gl_FragData[0] = texture2D(sbtexture, TexCoords);\\n             }&quot;,&quot;&quot;)),t.tris.getShaderSourceTime().modified(),t.tris.getVAO().bind(),t.tris.getVAO().addAttributeArray(t.tris.getProgram(),t.tris.getCABO(),&quot;vertexMC&quot;,t.tris.getCABO().getVertexOffset(),t.tris.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||gp(&quot;Error setting vertexMC in shader VAO.&quot;));const e=t.renderable.getTextures();e.length||gp(&quot;vtkSkybox requires a texture map&quot;),t.openGLTexture.getRenderable()!==e[0]&&(t.openGLTexture.releaseGraphicsResources(t._openGLRenderWindow),t.openGLTexture.setRenderable(e[0]))}}(e,t)}));Jt(&quot;vtkSkybox&quot;,hp);const{FieldAssociations:vp}=Us,Tp={fieldAssociation:vp.FIELD_ASSOCIATION_CELLS,captureZValues:!1};function yp(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Tp,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;fieldAssociation&quot;,&quot;captureZValues&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkHardwareSelector&quot;),e.getSourceDataAsync=async(e,t,n,r,o)=>{},e.selectAsync=async(t,n,r,o,a)=>{const i=await e.getSourceDataAsync(t,n,r,o,a);return i?i.generateSelection(n,r,o,a):[]}}(e,t)}var bp={newInstance:Wt.newInstance(yp,&quot;vtkHardwareSelector&quot;),extend:yp};const xp={glFramebuffer:null,colorBuffers:null,depthTexture:null,previousDrawBinding:0,previousReadBinding:0,previousDrawBuffer:0,previousReadBuffer:0,previousActiveFramebuffer:null};function Cp(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,xp,n),ht(e,t),t.colorBuffers&&et(&quot;you cannot initialize colorBuffers through the constructor. You should call setColorBuffer() instead.&quot;),t.colorBuffers=[],St(e,t,[&quot;colorBuffers&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkFramebuffer&quot;),e.getBothMode=()=>t.context.FRAMEBUFFER,e.saveCurrentBindingsAndBuffers=t=>{const n=void 0!==t?t:e.getBothMode();e.saveCurrentBindings(n),e.saveCurrentBuffers(n)},e.saveCurrentBindings=e=>{if(!t.context)return void et(&quot;you must set the OpenGLRenderWindow before calling saveCurrentBindings&quot;);const n=t.context;t.previousDrawBinding=n.getParameter(t.context.FRAMEBUFFER_BINDING),t.previousActiveFramebuffer=t._openGLRenderWindow.getActiveFramebuffer()},e.saveCurrentBuffers=e=>{},e.restorePreviousBindingsAndBuffers=t=>{const n=void 0!==t?t:e.getBothMode();e.restorePreviousBindings(n),e.restorePreviousBuffers(n)},e.restorePreviousBindings=e=>{if(!t.context)return void et(&quot;you must set the OpenGLRenderWindow before calling restorePreviousBindings&quot;);const n=t.context;n.bindFramebuffer(n.FRAMEBUFFER,t.previousDrawBinding),t._openGLRenderWindow.setActiveFramebuffer(t.previousActiveFramebuffer)},e.restorePreviousBuffers=e=>{},e.bind=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:null;null===n&&(n=t.context.FRAMEBUFFER),t.context.bindFramebuffer(n,t.glFramebuffer);for(let e=0;e<t.colorBuffers.length;e++)t.colorBuffers[e].bind();t._openGLRenderWindow.setActiveFramebuffer(e)},e.create=(e,n)=>{t.context?(t.glFramebuffer=t.context.createFramebuffer(),t.glFramebuffer.width=e,t.glFramebuffer.height=n):et(&quot;you must set the OpenGLRenderWindow before calling create&quot;)},e.setColorBuffer=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;const r=t.context;if(!r)return void et(&quot;you must set the OpenGLRenderWindow before calling setColorBuffer&quot;);let o=r.COLOR_ATTACHMENT0;if(n>0){if(!t._openGLRenderWindow.getWebgl2())return void et(&quot;Using multiple framebuffer attachments requires WebGL 2&quot;);o+=n}t.colorBuffers[n]=e,r.framebufferTexture2D(r.FRAMEBUFFER,o,r.TEXTURE_2D,e.getHandle(),0)},e.removeColorBuffer=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;const n=t.context;if(!n)return void et(&quot;you must set the OpenGLRenderWindow before calling removeColorBuffer&quot;);let r=n.COLOR_ATTACHMENT0;if(e>0){if(!t._openGLRenderWindow.getWebgl2())return void et(&quot;Using multiple framebuffer attachments requires WebGL 2&quot;);r+=e}n.framebufferTexture2D(n.FRAMEBUFFER,r,n.TEXTURE_2D,null,0),t.colorBuffers=t.colorBuffers.splice(e,1)},e.setDepthBuffer=e=>{if(t.context)if(t._openGLRenderWindow.getWebgl2()){const n=t.context;n.framebufferTexture2D(n.FRAMEBUFFER,n.DEPTH_ATTACHMENT,n.TEXTURE_2D,e.getHandle(),0)}else et(&quot;Attaching depth buffer textures to fbo requires WebGL 2&quot;);else et(&quot;you must set the OpenGLRenderWindow before calling setDepthBuffer&quot;)},e.removeDepthBuffer=()=>{if(t.context)if(t._openGLRenderWindow.getWebgl2()){const e=t.context;e.framebufferTexture2D(e.FRAMEBUFFER,e.DEPTH_ATTACHMENT,e.TEXTURE_2D,null,0)}else et(&quot;Attaching depth buffer textures to framebuffers requires WebGL 2&quot;);else et(&quot;you must set the OpenGLRenderWindow before calling removeDepthBuffer&quot;)},e.getGLFramebuffer=()=>t.glFramebuffer,e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))},e.releaseGraphicsResources=()=>{t.glFramebuffer&&t.context.deleteFramebuffer(t.glFramebuffer)},e.getSize=()=>null==t.glFramebuffer?null:[t.glFramebuffer.width,t.glFramebuffer.height],e.populateFramebuffer=()=>{if(!t.context)return void et(&quot;you must set the OpenGLRenderWindow before calling populateFrameBuffer&quot;);e.bind();const n=t.context,r=Pd.newInstance();r.setOpenGLRenderWindow(t._openGLRenderWindow),r.setMinificationFilter(ud.LINEAR),r.setMagnificationFilter(ud.LINEAR),r.create2DFromRaw({width:t.glFramebuffer.width,height:t.glFramebuffer.height,numComps:4,dataType:cs.UNSIGNED_CHAR,data:null}),e.setColorBuffer(r),t.depthTexture=n.createRenderbuffer(),n.bindRenderbuffer(n.RENDERBUFFER,t.depthTexture),n.renderbufferStorage(n.RENDERBUFFER,n.DEPTH_COMPONENT16,t.glFramebuffer.width,t.glFramebuffer.height),n.framebufferRenderbuffer(n.FRAMEBUFFER,n.DEPTH_ATTACHMENT,n.RENDERBUFFER,t.depthTexture)},e.getColorTexture=()=>t.colorBuffers[0]}(e,t)}var Sp={newInstance:Mt(Cp,&quot;vtkFramebuffer&quot;),extend:Cp};const Ap={contentType:-1,fieldType:-1,properties:null,selectionList:[]};function Ip(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ap,n),Wt.obj(e,t),t.properties={},Wt.setGet(e,t,[&quot;contentType&quot;,&quot;fieldType&quot;,&quot;properties&quot;,&quot;selectionList&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkSelectionNode&quot;),e.getBounds=()=>t.points.getBounds()}(e,t)}var wp={newInstance:Wt.newInstance(Ip,&quot;vtkSelectionNode&quot;),extend:Ip,SelectionContent:{GLOBALIDS:0,PEDIGREEIDS:1,VALUES:2,INDICES:3,FRUSTUM:4,LOCATIONS:5,THRESHOLDS:6,BLOCKS:7,QUERY:8},SelectionField:{CELL:0,POINT:1,FIELD:2,VERTEX:3,EDGE:4,ROW:5}};const{PassTypes:Op}=Il,{SelectionContent:Pp,SelectionField:Rp}=wp,{FieldAssociations:Mp}=Us,{vtkErrorMacro:Ep}=Wt;function Vp(e){return`${e.propID} ${e.compositeID}`}function Dp(e,t,n,r){return n?n[4*(t*(r[2]-r[0]+1)+e)+3]:0}function Lp(e,t,n,r){if(!n)return 0;const o=4*(t*(r[2]-r[0]+1)+e),a=n[o],i=n[o+1];return 256*(256*n[o+2]+i)+a}function Bp(e,t){let n=t;return n<<=24,n|=e,n}function Np(e,t,n,r){const o=n<0?0:n;if(0===o){if(r[0]=t[0],r[1]=t[1],t[0]<e.area[0]||t[0]>e.area[2]||t[1]<e.area[1]||t[1]>e.area[3])return null;const n=[t[0]-e.area[0],t[1]-e.area[1]],o=Lp(n[0],n[1],e.pixBuffer[Op.ACTOR_PASS],e.area);if(o<=0||o-1>=e.props.length)return null;const a={valid:!0};a.propID=o-1,a.prop=e.props[a.propID];let i=Lp(n[0],n[1],e.pixBuffer[Op.COMPOSITE_INDEX_PASS],e.area);if((i<0||i>16777215)&&(i=0),a.compositeID=i-1,e.captureZValues){const r=4*(n[1]*(e.area[2]-e.area[0]+1)+n[0]);a.zValue=(256*e.zBuffer[r]+e.zBuffer[r+1])/65535,a.displayPosition=t}if(e.pixBuffer[Op.ID_LOW24]&&0===Dp(n[0],n[1],e.pixBuffer[Op.ID_LOW24],e.area))return a;const s=Lp(n[0],n[1],e.pixBuffer[Op.ID_LOW24],e.area),l=Lp(n[0],n[1],e.pixBuffer[Op.ID_HIGH24],e.area);return a.attributeID=Bp(s,l),a}const a=[t[0],t[1]],i=[0,0];let s=Np(e,t,0,r);if(s&&s.valid)return s;for(let t=1;t<o;++t){for(let n=a[1]>t?a[1]-t:0;n<=a[1]+t;++n){if(i[1]=n,a[0]>=t&&(i[0]=a[0]-t,s=Np(e,i,0,r),s&&s.valid))return s;if(i[0]=a[0]+t,s=Np(e,i,0,r),s&&s.valid)return s}for(let n=a[0]>=t?a[0]-(t-1):0;n<=a[0]+(t-1);++n){if(i[0]=n,a[1]>=t&&(i[1]=a[1]-t,s=Np(e,i,0,r),s&&s.valid))return s;if(i[1]=a[1]+t,s=Np(e,i,0,r),s&&s.valid)return s}}return r[0]=t[0],r[1]=t[1],null}function Fp(e,t,n,r,o){const a=[];let i=0;return t.forEach(((t,s)=>{const l=wp.newInstance();switch(l.setContentType(Pp.INDICES),e){case Mp.FIELD_ASSOCIATION_CELLS:l.setFieldType(Rp.CELL);break;case Mp.FIELD_ASSOCIATION_POINTS:l.setFieldType(Rp.POINT);break;default:Ep(&quot;Unknown field association&quot;)}l.getProperties().propID=t.info.propID,l.getProperties().prop=t.info.prop,l.getProperties().compositeID=t.info.compositeID,l.getProperties().attributeID=t.info.attributeID,l.getProperties().pixelCount=t.pixelCount,n&&(l.getProperties().displayPosition=[t.info.displayPosition[0],t.info.displayPosition[1],t.info.zValue],l.getProperties().worldPosition=o.displayToWorld(t.info.displayPosition[0],t.info.displayPosition[1],t.info.zValue,r)),l.setSelectionList(t.attributeIDs),a[i]=l,i++})),a}const _p={area:void 0,currentPass:-1,propColorValue:null,props:null,maximumPointId:0,maximumCellId:0,idOffset:1};function kp(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,_p,n),bp.extend(e,t,n),t.propColorValue=[0,0,0],t.props=[],t.area||(t.area=[0,0,0,0]),Wt.setGetArray(e,t,[&quot;area&quot;],4),Wt.setGet(e,t,[&quot;_renderer&quot;,&quot;currentPass&quot;,&quot;_openGLRenderWindow&quot;,&quot;maximumPointId&quot;,&quot;maximumCellId&quot;]),Wt.setGetArray(e,t,[&quot;propColorValue&quot;],3),Wt.moveToProtected(e,t,[&quot;renderer&quot;,&quot;openGLRenderWindow&quot;]),Wt.event(e,t,&quot;event&quot;),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLHardwareSelector&quot;),e.releasePixBuffers=()=>{t.rawPixBuffer=[],t.pixBuffer=[],t.zBuffer=null},e.beginSelection=()=>{t._openGLRenderer=t._openGLRenderWindow.getViewNodeFor(t._renderer),t.maxAttributeId=0;const n=t._openGLRenderWindow.getSize();if(t.framebuffer){t.framebuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.framebuffer.saveCurrentBindingsAndBuffers();const e=t.framebuffer.getSize();e&&e[0]===n[0]&&e[1]===n[1]?t.framebuffer.bind():(t.framebuffer.create(n[0],n[1]),t.framebuffer.populateFramebuffer())}else t.framebuffer=Sp.newInstance(),t.framebuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.framebuffer.saveCurrentBindingsAndBuffers(),t.framebuffer.create(n[0],n[1]),t.framebuffer.populateFramebuffer();if(t._openGLRenderer.clear(),t._openGLRenderer.setSelector(e),t.hitProps={},t.propPixels={},t.props=[],e.releasePixBuffers(),t.fieldAssociation===Mp.FIELD_ASSOCIATION_POINTS){const e=t._openGLRenderWindow.getContext(),n=e.isEnabled(e.BLEND);e.disable(e.BLEND),t._openGLRenderWindow.traverseAllPasses(),n&&e.enable(e.BLEND)}},e.endSelection=()=>{t.hitProps={},t._openGLRenderer.setSelector(null),t.framebuffer.restorePreviousBindingsAndBuffers()},e.preCapturePass=()=>{const e=t._openGLRenderWindow.getContext();t.originalBlending=e.isEnabled(e.BLEND),e.disable(e.BLEND)},e.postCapturePass=()=>{const e=t._openGLRenderWindow.getContext();t.originalBlending&&e.enable(e.BLEND)},e.select=()=>{let n=null;return e.captureBuffers()&&(n=e.generateSelection(t.area[0],t.area[1],t.area[2],t.area[3]),e.releasePixBuffers()),n},e.getSourceDataAsync=async(n,r,o,a,i)=>{if(t._renderer=n,void 0===r){const n=t._openGLRenderWindow.getSize();e.setArea(0,0,n[0]-1,n[1]-1)}else e.setArea(r,o,a,i);if(!e.captureBuffers())return!1;const s={area:[...t.area],pixBuffer:[...t.pixBuffer],captureZValues:t.captureZValues,zBuffer:t.zBuffer,props:[...t.props],fieldAssociation:t.fieldAssociation,renderer:n,openGLRenderWindow:t._openGLRenderWindow,generateSelection:function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return function(e,t,n,r,o){const a=Math.floor(t),i=Math.floor(n),s=Math.floor(r),l=Math.floor(o),c=new Map,u=[0,0];for(let t=i;t<=l;t++)for(let n=a;n<=s;n++){const r=Np(e,[n,t],0,u);if(r&&r.valid){const t=Vp(r);if(c.has(t)){const n=c.get(t);n.pixelCount++,e.captureZValues&&r.zValue<n.info.zValue&&(n.info=r),-1===n.attributeIDs.indexOf(r.attributeID)&&n.attributeIDs.push(r.attributeID)}else c.set(t,{info:r,pixelCount:1,attributeIDs:[r.attributeID]})}}return Fp(e.fieldAssociation,c,e.captureZValues,e.renderer,e.openGLRenderWindow)}(s,...t)}};return s},e.captureBuffers=()=>{if(!t._renderer||!t._openGLRenderWindow)return Ep(&quot;Renderer and view must be set before calling Select.&quot;),!1;t._openGLRenderer=t._openGLRenderWindow.getViewNodeFor(t._renderer),t._openGLRenderWindow.getRenderable().preRender(),e.invokeEvent({type:&quot;StartEvent&quot;}),t.originalBackground=t._renderer.getBackgroundByReference(),t._renderer.setBackground(0,0,0,0);const n=t._openGLRenderWindow.getRenderPasses();e.beginSelection();const r=[];for(t.currentPass=Op.MIN_KNOWN_PASS;t.currentPass<=Op.MAX_KNOWN_PASS;t.currentPass++)e.passRequired(t.currentPass)&&(e.preCapturePass(t.currentPass),t.captureZValues&&t.currentPass===Op.ACTOR_PASS&&&quot;function&quot;==typeof n[0].requestDepth&&&quot;function&quot;==typeof n[0].getFramebuffer?(n[0].requestDepth(),t._openGLRenderWindow.traverseAllPasses()):t._openGLRenderWindow.traverseAllPasses(),e.postCapturePass(t.currentPass),e.savePixelBuffer(t.currentPass),r.push(t.currentPass));return r.forEach((n=>{t.currentPass=n,e.processPixelBuffers()})),t.currentPass=Op.MAX_KNOWN_PASS,e.endSelection(),t._renderer.setBackground(t.originalBackground),e.invokeEvent({type:&quot;EndEvent&quot;}),!0},e.processPixelBuffers=()=>{t.props.forEach(((n,r)=>{e.isPropHit(r)&&n.processSelectorPixelBuffers(e,t.propPixels[r])}))},e.passRequired=e=>{if(e===Op.ID_HIGH24){if(t.fieldAssociation===Mp.FIELD_ASSOCIATION_POINTS)return t.maximumPointId>16777215;if(t.fieldAssociation===Mp.FIELD_ASSOCIATION_CELLS)return t.maximumCellId>16777215}return!0},e.savePixelBuffer=n=>{if(t.pixBuffer[n]=t._openGLRenderWindow.getPixelData(t.area[0],t.area[1],t.area[2],t.area[3]),!t.rawPixBuffer[n]){const e=(t.area[2]-t.area[0]+1)*(t.area[3]-t.area[1]+1)*4;t.rawPixBuffer[n]=new Uint8Array(e),t.rawPixBuffer[n].set(t.pixBuffer[n])}if(n===Op.ACTOR_PASS){if(t.captureZValues){const e=t._openGLRenderWindow.getRenderPasses();if(&quot;function&quot;==typeof e[0].requestDepth&&&quot;function&quot;==typeof e[0].getFramebuffer){const n=e[0].getFramebuffer();n.saveCurrentBindingsAndBuffers(),n.bind(),t.zBuffer=t._openGLRenderWindow.getPixelData(t.area[0],t.area[1],t.area[2],t.area[3]),n.restorePreviousBindingsAndBuffers()}}e.buildPropHitList(t.rawPixBuffer[n])}},e.buildPropHitList=e=>{let n=0;for(let r=0;r<=t.area[3]-t.area[1];r++)for(let o=0;o<=t.area[2]-t.area[0];o++){let a=Lp(o,r,e,t.area);a>0&&(a--,a in t.hitProps||(t.hitProps[a]=!0,t.propPixels[a]=[]),t.propPixels[a].push(4*n)),++n}},e.renderProp=n=>{t.currentPass===Op.ACTOR_PASS&&(e.setPropColorValueFromInt(t.props.length+1),t.props.push(n))},e.renderCompositeIndex=n=>{t.currentPass===Op.COMPOSITE_INDEX_PASS&&e.setPropColorValueFromInt(n+1)},e.renderAttributeId=e=>{e<0||(t.maxAttributeId=e>t.maxAttributeId?e:t.maxAttributeId)},e.passTypeToString=e=>Wt.enumToString(Op,e),e.isPropHit=e=>Boolean(t.hitProps[e]),e.setPropColorValueFromInt=e=>{t.propColorValue[0]=e%256/255,t.propColorValue[1]=Math.floor(e/256)%256/255,t.propColorValue[2]=Math.floor(e/65536)%256/255},e.getPixelInformation=(n,r,o)=>{const a=r<0?0:r;if(0===a){if(o[0]=n[0],o[1]=n[1],n[0]<t.area[0]||n[0]>t.area[2]||n[1]<t.area[1]||n[1]>t.area[3])return null;const e=[n[0]-t.area[0],n[1]-t.area[1]],r=Lp(e[0],e[1],t.pixBuffer[Op.ACTOR_PASS],t.area);if(r<=0||r-1>=t.props.length)return null;const a={valid:!0};a.propID=r-1,a.prop=t.props[a.propID];let i=Lp(e[0],e[1],t.pixBuffer[Op.COMPOSITE_INDEX_PASS],t.area);if((i<0||i>16777215)&&(i=0),a.compositeID=i-1,t.captureZValues){const r=4*(e[1]*(t.area[2]-t.area[0]+1)+e[0]);a.zValue=(256*t.zBuffer[r]+t.zBuffer[r+1])/65535,a.displayPosition=n}if(t.pixBuffer[Op.ID_LOW24]&&0===Dp(e[0],e[1],t.pixBuffer[Op.ID_LOW24],t.area))return a;const s=Lp(e[0],e[1],t.pixBuffer[Op.ID_LOW24],t.area),l=Lp(e[0],e[1],t.pixBuffer[Op.ID_HIGH24],t.area);return a.attributeID=Bp(s,l),a}const i=[n[0],n[1]],s=[0,0];let l=e.getPixelInformation(n,0,o);if(l&&l.valid)return l;for(let t=1;t<a;++t){for(let n=i[1]>t?i[1]-t:0;n<=i[1]+t;++n){if(s[1]=n,i[0]>=t&&(s[0]=i[0]-t,l=e.getPixelInformation(s,0,o),l&&l.valid))return l;if(s[0]=i[0]+t,l=e.getPixelInformation(s,0,o),l&&l.valid)return l}for(let n=i[0]>=t?i[0]-(t-1):0;n<=i[0]+(t-1);++n){if(s[0]=n,i[1]>=t&&(s[1]=i[1]-t,l=e.getPixelInformation(s,0,o),l&&l.valid))return l;if(s[1]=i[1]+t,l=e.getPixelInformation(s,0,o),l&&l.valid)return l}}return o[0]=n[0],o[1]=n[1],null},e.generateSelection=(n,r,o,a)=>{const i=Math.floor(n),s=Math.floor(r),l=Math.floor(o),c=Math.floor(a),u=new Map,d=[0,0];for(let n=s;n<=c;n++)for(let r=i;r<=l;r++){const o=[r,n],a=e.getPixelInformation(o,0,d);if(a&&a.valid){const e=Vp(a);if(u.has(e)){const n=u.get(e);n.pixelCount++,t.captureZValues&&a.zValue<n.info.zValue&&(n.info=a),-1===n.attributeIDs.indexOf(a.attributeID)&&n.attributeIDs.push(a.attributeID)}else u.set(e,{info:a,pixelCount:1,attributeIDs:[a.attributeID]})}}return Fp(t.fieldAssociation,u,t.captureZValues,t._renderer,t._openGLRenderWindow)},e.getRawPixelBuffer=e=>t.rawPixBuffer[e],e.getPixelBuffer=e=>t.pixBuffer[e],e.attach=(e,n)=>{t._openGLRenderWindow=e,t._renderer=n};const n=e.setArea;e.setArea=function(){return!!n(...arguments)&&(t.area[0]=Math.floor(t.area[0]),t.area[1]=Math.floor(t.area[1]),t.area[2]=Math.floor(t.area[2]),t.area[3]=Math.floor(t.area[3]),!0)}}(e,t)}var Gp={newInstance:Wt.newInstance(kp,&quot;vtkOpenGLHardwareSelector&quot;),extend:kp,...Il};const{vtkErrorMacro:Up}=Ht,{Representation:zp}=os,{ObjectType:Wp}=zu,{PassTypes:Hp}=Gp,jp={type:&quot;StartEvent&quot;},Kp={type:&quot;EndEvent&quot;};function $p(e,t,n){e[12]=(e[12]-t[0])*n[0],e[13]=(e[13]-t[1])*n[1],e[14]=(e[14]-t[2])*n[2],e[0]*=n[0],e[5]*=n[1],e[10]*=n[2]}const qp={normalMatrix:null,mcpcMatrix:null,mcwcMatrix:null};const Xp=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,qp,n),$d.extend(e,t,n),t.tmpMat3=fe(new Float64Array(9)),t.normalMatrix=fe(new Float64Array(9)),t.mcpcMatrix=m(new Float64Array(16)),t.mcvcMatrix=m(new Float64Array(16)),t.tmpColor=[],t.glyphBOBuildTime={},ht(t.glyphBOBuildTime,{mtime:0}),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLGlyph3DMapper&quot;);const n={...e};e.renderPiece=(n,r)=>{if(e.invokeEvent(jp),t.renderable.getStatic()||t.renderable.update(),t.currentInput=t.renderable.getInputData(1),e.invokeEvent(Kp),!t.currentInput)return void Up(&quot;No input!&quot;);if(!t.currentInput.getPoints||!t.currentInput.getPoints().getNumberOfValues())return;const o=t.context;t._openGLRenderWindow.getWebgl2()?(t.hardwareSupport=!0,t.extension=null):t.extension||(t.extension=t.context.getExtension(&quot;ANGLE_instanced_arrays&quot;),t.hardwareSupport=!!t.extension);const a=r.getProperty().getBackfaceCulling(),i=r.getProperty().getFrontfaceCulling();a||i?i?(t._openGLRenderWindow.enableCullFace(),o.cullFace(o.FRONT)):(t._openGLRenderWindow.enableCullFace(),o.cullFace(o.BACK)):t._openGLRenderWindow.disableCullFace(),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r)},e.multiply4x4WithOffset=(e,t,n,r)=>{const o=t[0],a=t[1],i=t[2],s=t[3],l=t[4],c=t[5],u=t[6],d=t[7],p=t[8],f=t[9],g=t[10],m=t[11],h=t[12],v=t[13],T=t[14],y=t[15];let b=n[r],x=n[r+1],C=n[r+2],S=n[r+3];e[0]=b*o+x*l+C*p+S*h,e[1]=b*a+x*c+C*f+S*v,e[2]=b*i+x*u+C*g+S*T,e[3]=b*s+x*d+C*m+S*y,b=n[r+4],x=n[r+5],C=n[r+6],S=n[r+7],e[4]=b*o+x*l+C*p+S*h,e[5]=b*a+x*c+C*f+S*v,e[6]=b*i+x*u+C*g+S*T,e[7]=b*s+x*d+C*m+S*y,b=n[r+8],x=n[r+9],C=n[r+10],S=n[r+11],e[8]=b*o+x*l+C*p+S*h,e[9]=b*a+x*c+C*f+S*v,e[10]=b*i+x*u+C*g+S*T,e[11]=b*s+x*d+C*m+S*y,b=n[r+12],x=n[r+13],C=n[r+14],S=n[r+15],e[12]=b*o+x*l+C*p+S*h,e[13]=b*a+x*c+C*f+S*v,e[14]=b*i+x*u+C*g+S*T,e[15]=b*s+x*d+C*m+S*y},e.replaceShaderNormal=(e,r,o)=>{if(t.hardwareSupport&&t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;)>0){let n=e.Vertex;t.lastBoundBO.getCABO().getNormalOffset()&&(n=td.substitute(n,&quot;//VTK::Normal::Dec&quot;,[&quot;attribute vec3 normalMC;&quot;,&quot;attribute mat3 gNormal;&quot;,&quot;uniform mat3 normalMatrix;&quot;,&quot;varying vec3 normalVCVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::Normal::Impl&quot;,[&quot;normalVCVSOutput = normalMatrix * gNormal * normalMC;&quot;]).result),e.Vertex=n}n.replaceShaderNormal(e,r,o)},e.replaceShaderClip=(e,r,o)=>{if(t.hardwareSupport){let n=e.Vertex,r=e.Fragment;if(t.renderable.getNumberOfClippingPlanes()){const e=t.renderable.getNumberOfClippingPlanes();n=td.substitute(n,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,`uniform vec4 clipPlanes[${e}];`,`varying float clipDistancesVSOutput[${e}];`]).result,n=td.substitute(n,&quot;//VTK::Clip::Impl&quot;,[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    vec4 gVertex = gMatrix * vertexMC;&quot;,&quot;    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], gVertex);&quot;,&quot;    }&quot;]).result,r=td.substitute(r,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,`varying float clipDistancesVSOutput[${e}];`]).result,r=td.substitute(r,&quot;//VTK::Clip::Impl&quot;,[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    if (clipDistancesVSOutput[planeNum] < 0.0) discard;&quot;,&quot;    }&quot;]).result}e.Vertex=n,e.Fragment=r}n.replaceShaderClip(e,r,o)},e.replaceShaderColor=(e,r,o)=>{if(t.hardwareSupport&&t.renderable.getColorArray()){let n=e.Vertex,r=e.Geometry,o=e.Fragment;const a=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);let i=[&quot;uniform float ambient;&quot;,&quot;uniform float diffuse;&quot;,&quot;uniform float specular;&quot;,&quot;uniform float opacityUniform; // the fragment opacity&quot;];a&&(i=i.concat([&quot;uniform vec3 specularColorUniform;&quot;,&quot;uniform float specularPowerUniform;&quot;]));let s=[&quot;vec3 ambientColor;&quot;,&quot;  vec3 diffuseColor;&quot;,&quot;  float opacity;&quot;];a&&(s=s.concat([&quot;  vec3 specularColor;&quot;,&quot;  float specularPower;&quot;])),s=s.concat([&quot;  opacity = opacityUniform;&quot;]),a&&(s=s.concat([&quot;  specularColor = specularColorUniform;&quot;,&quot;  specularPower = specularPowerUniform;&quot;])),t.drawingEdges||(i=i.concat([&quot;varying vec4 vertexColorVSOutput;&quot;]),n=td.substitute(n,&quot;//VTK::Color::Dec&quot;,[&quot;attribute vec4 gColor;&quot;,&quot;varying vec4 vertexColorVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorVSOutput = gColor;&quot;]).result,r=td.substitute(r,&quot;//VTK::Color::Dec&quot;,[&quot;in vec4 vertexColorVSOutput[];&quot;,&quot;out vec4 vertexColorGSOutput;&quot;]).result,r=td.substitute(r,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorGSOutput = vertexColorVSOutput[i];&quot;]).result,s=s.concat([&quot;  diffuseColor = vertexColorVSOutput.rgb;&quot;,&quot;  ambientColor = vertexColorVSOutput.rgb;&quot;,&quot;  opacity = opacity*vertexColorVSOutput.a;&quot;])),o=td.substitute(o,&quot;//VTK::Color::Impl&quot;,s).result,o=td.substitute(o,&quot;//VTK::Color::Dec&quot;,i).result,e.Vertex=n,e.Geometry=r,e.Fragment=o}n.replaceShaderColor(e,r,o)},e.replaceShaderPositionVC=(e,r,o)=>{if(t.hardwareSupport){let n=e.Vertex;t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;)>0?(n=td.substitute(n,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vec4 gVertexMC = gMatrix * vertexMC;&quot;,&quot;vertexVCVSOutput = MCVCMatrix * gVertexMC;&quot;,&quot;  gl_Position = MCPCMatrix * gVertexMC;&quot;]).result,n=td.substitute(n,&quot;//VTK::Camera::Dec&quot;,[&quot;attribute mat4 gMatrix;&quot;,&quot;uniform mat4 MCPCMatrix;&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result):(n=td.substitute(n,&quot;//VTK::Camera::Dec&quot;,[&quot;attribute mat4 gMatrix;&quot;,&quot;uniform mat4 MCPCMatrix;&quot;]).result,n=td.substitute(n,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vec4 gVertexMC = gMatrix * vertexMC;&quot;,&quot;  gl_Position = MCPCMatrix * gVertexMC;&quot;]).result),e.Vertex=n}n.replaceShaderPositionVC(e,r,o)},e.replaceShaderPicking=(e,r,o)=>{if(t.hardwareSupport){let t=e.Fragment,n=e.Vertex;n=td.substitute(n,&quot;//VTK::Picking::Dec&quot;,[&quot;attribute vec3 mapperIndexVS;&quot;,&quot;varying vec3 mapperIndexVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::Picking::Impl&quot;,&quot;  mapperIndexVSOutput = mapperIndexVS;&quot;).result,e.Vertex=n,t=td.substitute(t,&quot;//VTK::Picking::Dec&quot;,[&quot;varying vec3 mapperIndexVSOutput;&quot;,&quot;uniform vec3 mapperIndex;&quot;,&quot;uniform int picking;&quot;]).result,t=td.substitute(t,&quot;//VTK::Picking::Impl&quot;,[&quot;  vec4 pickColor = picking == 2 ? vec4(mapperIndexVSOutput,1.0) : vec4(mapperIndex,1.0);&quot;,&quot;  gl_FragData[0] = picking != 0 ? pickColor : gl_FragData[0];&quot;]).result,e.Fragment=t}else n.replaceShaderPicking(e,r,o)},e.updateGlyphShaderParameters=(n,r,o,a,i,s,l,c)=>{const u=o.getProgram();if(n){const e=t.normalMatrix,n=s,r=9*l,o=t.tmpMat3,a=e[0],i=e[1],c=e[2],d=e[3],p=e[4],f=e[5],g=e[6],m=e[7],h=e[8],v=n[r],T=n[r+1],y=n[r+2],b=n[r+3],x=n[r+4],C=n[r+5],S=n[r+6],A=n[r+7],I=n[r+8];o[0]=v*a+T*d+y*g,o[1]=v*i+T*p+y*m,o[2]=v*c+T*f+y*h,o[3]=b*a+x*d+C*g,o[4]=b*i+x*p+C*m,o[5]=b*c+x*f+C*h,o[6]=S*a+A*d+I*g,o[7]=S*i+A*p+I*m,o[8]=S*c+A*f+I*h,u.setUniformMatrix3x3(&quot;normalMatrix&quot;,t.tmpMat3)}if(e.multiply4x4WithOffset(t.tmpMat4,t.mcpcMatrix,i,16*l),u.setUniformMatrix(&quot;MCPCMatrix&quot;,t.tmpMat4),r&&(e.multiply4x4WithOffset(t.tmpMat4,t.mcvcMatrix,i,16*l),u.setUniformMatrix(&quot;MCVCMatrix&quot;,t.tmpMat4)),a){const e=a.getData();t.tmpColor[0]=e[4*l]/255,t.tmpColor[1]=e[4*l+1]/255,t.tmpColor[2]=e[4*l+2]/255,u.setUniform3fArray(&quot;ambientColorUniform&quot;,t.tmpColor),u.setUniform3fArray(&quot;diffuseColorUniform&quot;,t.tmpColor)}c&&u.setUniform3fArray(&quot;mapperIndex&quot;,c.getPropColorValue())},e.renderPieceDraw=(n,r)=>{const o=r.getProperty().getRepresentation(),a=t.context,i=r.getProperty().getEdgeVisibility()&&o===zp.SURFACE,s=t.openGLCamera.getKeyMatrices(n),l=t.openGLActor.getKeyMatrices();Te(t.normalMatrix,s.normalMatrix,l.normalMatrix),b(t.mcpcMatrix,s.wcpc,l.mcwc),b(t.mcvcMatrix,s.wcvc,l.mcwc);const c=t.renderable.getMatrixArray(),u=t.renderable.getNormalArray(),d=t.renderable.getColorArray(),p=c.length/16;let f=!1;t._openGLRenderer.getSelector()&&t._openGLRenderer.getSelector().getCurrentPass()===Hp.COMPOSITE_INDEX_PASS&&(f=!0);for(let s=t.primTypes.Start;s<t.primTypes.End;s++){const l=t.primitives[s].getCABO();if(l.getElementCount()){t.drawingEdges=i&&(s===t.primTypes.TrisEdges||s===t.primTypes.TriStripsEdges),t.lastBoundBO=t.primitives[s],t.primitives[s].updateShaders(n,r,e);const g=t.primitives[s].getProgram(),m=t.primitives[s].getOpenGLMode(o),h=g.isUniformUsed(&quot;normalMatrix&quot;),v=g.isUniformUsed(&quot;MCVCMatrix&quot;);if(t.hardwareSupport)t.extension?t.extension.drawArraysInstancedANGLE(m,0,l.getElementCount(),p):a.drawArraysInstanced(m,0,l.getElementCount(),p);else for(let n=0;n<p;++n)f&&t._openGLRenderer.getSelector().renderCompositeIndex(n),e.updateGlyphShaderParameters(h,v,t.primitives[s],d,c,u,n,f?t._openGLRenderer.getSelector():null),a.drawArrays(m,0,l.getElementCount())}}},e.setMapperShaderParameters=(e,r,o)=>{if(e.getCABO().getElementCount()&&(t.glyphBOBuildTime.getMTime()>e.getAttributeUpdateTime().getMTime()||e.getShaderSourceTime().getMTime()>e.getAttributeUpdateTime().getMTime()))return e.getProgram().isAttributeUsed(&quot;gMatrix&quot;)?e.getVAO().addAttributeMatrixWithDivisor(e.getProgram(),t.matrixBuffer,&quot;gMatrix&quot;,0,64,t.context.FLOAT,4,!1,1)||Up(&quot;Error setting gMatrix in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;gMatrix&quot;),e.getProgram().isAttributeUsed(&quot;gNormal&quot;)?e.getVAO().addAttributeMatrixWithDivisor(e.getProgram(),t.normalBuffer,&quot;gNormal&quot;,0,36,t.context.FLOAT,3,!1,1)||Up(&quot;Error setting gNormal in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;gNormal&quot;),e.getProgram().isAttributeUsed(&quot;gColor&quot;)?e.getVAO().addAttributeArrayWithDivisor(e.getProgram(),t.colorBuffer,&quot;gColor&quot;,0,4,t.context.UNSIGNED_BYTE,4,!0,1,!1)||Up(&quot;Error setting gColor in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;gColor&quot;),e.getProgram().isAttributeUsed(&quot;mapperIndexVS&quot;)?e.getVAO().addAttributeArrayWithDivisor(e.getProgram(),t.pickBuffer,&quot;mapperIndexVS&quot;,0,4,t.context.UNSIGNED_BYTE,4,!0,1,!1)||Up(&quot;Error setting mapperIndexVS in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;mapperIndexVS&quot;),n.setMapperShaderParameters(e,r,o),void e.getAttributeUpdateTime().modified();n.setMapperShaderParameters(e,r,o)},e.getNeedToRebuildBufferObjects=(e,r)=>(t.renderable.buildArrays(),t.VBOBuildTime.getMTime()<t.renderable.getBuildTime().getMTime()||n.getNeedToRebuildBufferObjects(e,r)),e.getNeedToRebuildShaders=(e,r,o)=>!!(n.getNeedToRebuildShaders(e,r,o)||e.getShaderSourceTime().getMTime()<t.renderable.getMTime()||e.getShaderSourceTime().getMTime()<t.currentInput.getMTime()),e.buildBufferObjects=(e,r)=>{const o=t.renderable.getMatrixArray(),a=t.renderable.getInputData(0).getPoints(),{useShiftAndScale:i,coordShift:s,coordScale:l}=Wu(a);if(t.hardwareSupport){const e=t.renderable.getNormalArray(),n=t.renderable.getColorArray();if(t.matrixBuffer||(t.matrixBuffer=zu.newInstance(),t.matrixBuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.normalBuffer=zu.newInstance(),t.normalBuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.colorBuffer=zu.newInstance(),t.colorBuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.pickBuffer=zu.newInstance(),t.pickBuffer.setOpenGLRenderWindow(t._openGLRenderWindow)),i){const e=o.buffer;for(let t=0;t<o.byteLength;t+=64)$p(new Float32Array(e,t,16),s,l)}if(t.renderable.getBuildTime().getMTime()>t.glyphBOBuildTime.getMTime()){t.matrixBuffer.upload(o,Wp.ARRAY_BUFFER),t.normalBuffer.upload(e,Wp.ARRAY_BUFFER),n?t.colorBuffer.upload(n.getData(),Wp.ARRAY_BUFFER):t.colorBuffer.releaseGraphicsResources();const r=o.length/16,a=new Uint8Array(4*r);for(let e=0;e<r;++e){let t=e+1;const n=4*e;a[n]=t%256,t-=a[n],t/=256,a[n+1]=t%256,t-=a[n+1],t/=256,a[n+2]=t%256,a[n+3]=255}t.pickBuffer.upload(a,Wp.ARRAY_BUFFER),t.glyphBOBuildTime.modified()}}if(n.buildBufferObjects(e,r),i)for(let e=ad.Start;e<ad.End;e++)t.primitives[e].getCABO().setCoordShiftAndScale(s,l)}}(e,t)}),&quot;vtkOpenGLGlyph3DMapper&quot;);Jt(&quot;vtkGlyph3DMapper&quot;,Xp);const{vtkErrorMacro:Yp}=Wt;class Zp{constructor(){this.segmentMapping={},this.segments=[null],this.faces=[]}addSegment(e){const t=e[0],n=e[e.length-1];if(t===n||e.length<2)return;const r=this.segmentMapping[t],o=this.segmentMapping[n];if(void 0!==r&&void 0!==o)if(Math.abs(r)===Math.abs(o)){const a=r<o?o:r,i=this.segments[a];if(r>0)for(let t=1;t<e.length-1;t++)i.push(e[t]);else for(let t=1;t<e.length-1;t++)i.unshift(e[e.length-1-t]);this.faces.push(i),this.segments[a]=null,this.segmentMapping[t]=void 0,this.segmentMapping[n]=void 0}else{const t=Math.abs(r),n=Math.abs(o),a=this.segments[t],i=this.segments[n];this.segments[t]=null,this.segments[n]=null,this.segmentMapping[a[0]]=void 0,this.segmentMapping[i[0]]=void 0,this.segmentMapping[a[a.length-1]]=void 0,this.segmentMapping[i[i.length-1]]=void 0,this.addSegment(e),this.addSegment(a),this.addSegment(i)}else if(void 0!==r){if(r>0){const t=this.segments[r];for(let n=1;n<e.length;n++)t.push(e[n]);this.segmentMapping[n]=r}else{const t=this.segments[-r];this.segmentMapping[n]=r;for(let n=1;n<e.length;n++)t.unshift(e[n])}this.segmentMapping[t]=void 0}else if(void 0!==o){if(o>0){const n=this.segments[o];for(let t=1;t<e.length;t++)n.push(e[e.length-1-t]);this.segmentMapping[t]=o}else{const n=this.segments[-o];this.segmentMapping[t]=o;for(let t=1;t<e.length;t++)n.unshift(e[e.length-t-1])}this.segmentMapping[n]=void 0}else{const r=this.segments.length;this.segments.push(e),this.segmentMapping[t]=-r,this.segmentMapping[n]=r}}}const Qp={};function Jp(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Qp,n),Wt.obj(e,t),Wt.algo(e,t,1,1),function(e,t){t.classHierarchy.push(&quot;vtkClosedPolyLineToSurfaceFilter&quot;),e.requestData=(e,t)=>{const n=e[0];if(!n)return void Yp(&quot;Invalid or missing input&quot;);const r=t[0]?.initialize()||gu.newInstance();r.shallowCopy(n);const o=new Zp,a=n.getLines().getData();let i=0;for(;i<a.length;){const e=a[i++],t=[];for(let n=0;n<e;n++)t.push(a[i+n]);o.addSegment(t),i+=e}const{faces:s}=o;let l=s.length;for(let e=0;e<s.length;e++)l+=s[e].length;const c=new Uint16Array(l);i=0;for(let e=0;e<s.length;e++){const t=s[e];c[i++]=t.length;for(let e=0;e<t.length;e++)c[i++]=t[e]}r.setPolys(Kl.newInstance({values:c,name:&quot;faces&quot;})),t[0]=r}}(e,t)}var ef={newInstance:Wt.newInstance(Jp,&quot;vtkClosedPolyLineToSurfaceFilter&quot;),extend:Jp};const{vtkErrorMacro:tf}=Ht;function nf(e,t){t.classHierarchy.push(&quot;vtkCutter&quot;);const n={...e};e.getMTime=()=>{let e=n.getMTime();return t.cutFunction?(e=Math.max(e,t.cutFunction.getMTime()),e):e},e.requestData=(e,n)=>{const r=e[0];if(!r)return void tf(&quot;Invalid or missing input&quot;);if(!t.cutFunction)return void tf(&quot;Missing cut function&quot;);const o=n[0]?.initialize()||gu.newInstance();(function(e,n){const r=e.getPoints(),o=r.getData(),a=e.getPointData(),i=r.getNumberOfPoints(),s=[],l=[],c=[],u={},d=a.getNumberOfArrays();for(let e=0;e<d;e++)u[a.getArrayName(e)]=[];(!t.cutScalars||t.cutScalars.length<i)&&(t.cutScalars=new Float32Array(i));let p=0,f=0;for(;p<o.length;)t.cutScalars[f++]=t.cutFunction.evaluateFunction(o[p++],o[p++],o[p++]);const g=[],m=new Array(3),h=new Array(3),v=[];for(const n=function(e){const t=e.getPolys().getData(),n=e.getStrips().getData(),r={cellSize:0,cell:[],done:!1,polyIdx:0,stripIdx:0,remainingStripLength:0,next(){if(r.polyIdx<t.length){r.cellSize=t[r.polyIdx];const e=r.polyIdx+1,n=e+r.cellSize;r.polyIdx=n;let o=0;for(let a=e;a<n;++a)r.cell[o++]=t[a]}else if(r.stripIdx<n.length){r.cellSize=3,0===r.remainingStripLength&&(r.remainingStripLength=n[r.stripIdx]-2,r.stripIdx+=3);const e=r.stripIdx-2,t=r.stripIdx+1;r.stripIdx++,r.remainingStripLength--;let o=0;for(let a=e;a<t;++a)r.cell[o++]=n[a]}else{if(r.done)throw new Error(&quot;Iterator is done&quot;);r.done=!0}}};return r.next(),r}(e);!n.done;n.next()){if(n.cellSize<=2)continue;for(let e=0;e<n.cellSize;)v[e]=t.cutScalars[n.cell[e++]];const e=v[0]>0;let r=!0;for(let t=1;t<n.cell.length;t++)if(v[t]>0!==e){r=!1;break}if(r)continue;const i=[];for(let e=0;e<n.cellSize;e++){const r=e+1===n.cellSize?0:e+1,s=v[e]>0;if(v[r]>0===s)continue;let l=e,c=r,u=v[c]-v[l];u<=0&&(l=r,c=e,u*=-1);let p=0;0!==u&&(p=(t.cutValue-v[l])/u);const f=n.cell[l],g=n.cell[c];m[0]=o[3*f],m[1]=o[3*f+1],m[2]=o[3*f+2],h[0]=o[3*g],h[1]=o[3*g+1],h[2]=o[3*g+2];const T=[m[0]+p*(h[0]-m[0]),m[1]+p*(h[1]-m[1]),m[2]+p*(h[2]-m[2])],y={};for(let e=0;e<d;e++){const t=a.getArrayByIndex(e),n=a.getArrayName(e),r=t.getData(),o=t.getNumberOfComponents(),i=new Array(o);for(let e=0;e<o;e++){const t=r[o*f+e],n=r[o*g+e];i.push(t+p*(n-t))}y[n]=i}i.push({pointEdge1:f,pointEdge2:g,intersectedPoint:T,intersectedArrays:y,newPointID:-1})}for(let e=0;e<i.length;e++){const t=i[e];let n=!1;for(let r=0;r<g.length;r++){const o=g[r],a=t.pointEdge1===o.pointEdge1&&t.pointEdge2===o.pointEdge2,s=t.intersectedPoint[0]===o.intersectedPoint[0]&&t.intersectedPoint[1]===o.intersectedPoint[1]&&t.intersectedPoint[2]===o.intersectedPoint[2];if(a||s){n=!0,i[e].newPointID=g[r].newPointID;break}}n||(s.push(t.intersectedPoint[0]),s.push(t.intersectedPoint[1]),s.push(t.intersectedPoint[2]),Object.keys(t.intersectedArrays).forEach((e=>{u[e].push(...t.intersectedArrays[e])})),i[e].newPointID=s.length/3-1,g.push(i[e]))}const p=i.length;2===p?l.push(p,i[0].newPointID,i[1].newPointID):p>2&&(c.push(p),i.forEach((e=>{c.push(e.newPointID)})))}n.getPoints().setData(it(r.getDataType(),s),3);const T=n.getPointData();for(let e=0;e<d;e++){const t=a.getArrayName(e),n=xs.newInstance({name:t,dataType:a.getArrayByIndex(e).getDataType(),values:u[t],numberOfComponents:a.getArrayByIndex(e).getNumberOfComponents()});T.addArray(n)}0!==l.length&&n.getLines().setData(Uint16Array.from(l)),0!==c.length&&n.getPolys().setData(Uint16Array.from(c))})(r,o),n[0]=o}}const rf={cutFunction:null,cutScalars:null,cutValue:0};function of(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,rf,n),ht(e,t),Ot(e,t,1,1),Ct(e,t,[&quot;cutFunction&quot;,&quot;cutValue&quot;]),nf(e,t)}var af={newInstance:Mt(of,&quot;vtkCutter&quot;),extend:of};const sf=e=>e,lf=1e-6;class cf{constructor(){let e=arguments.length>0&&void 0!==arguments[0]&&arguments[0];this.matrix=m(new Float64Array(16)),this.tmp=new Float64Array(3),this.angleConv=e?c:sf}rotateFromDirections(e,t){const n=new Float64Array(3),r=new Float64Array(3),o=new Float64Array(16);hn(n,e[0],e[1],e[2]),hn(r,t[0],t[1],t[2]),Cn(n,n),Cn(r,r);const a=Sn(n,r);return a>=1||(An(this.tmp,n,r),gn(this.tmp)<lf&&(An(this.tmp,[1,0,0],e),gn(this.tmp)<lf&&An(this.tmp,[0,1,0],e)),R(o,Math.acos(a),this.tmp),b(this.matrix,this.matrix,o)),this}rotate(e,t){return hn(this.tmp,...t),Cn(this.tmp,this.tmp),S(this.matrix,this.matrix,this.angleConv(e),this.tmp),this}rotateX(e){return A(this.matrix,this.matrix,this.angleConv(e)),this}rotateY(e){return I(this.matrix,this.matrix,this.angleConv(e)),this}rotateZ(e){return w(this.matrix,this.matrix,this.angleConv(e)),this}translate(e,t,n){return hn(this.tmp,e,t,n),x(this.matrix,this.matrix,this.tmp),this}scale(e,t,n){return hn(this.tmp,e,t,n),C(this.matrix,this.matrix,this.tmp),this}multiply(e){return b(this.matrix,this.matrix,e),this}multiply3x3(e){return b(this.matrix,this.matrix,[e[0],e[1],e[2],0,e[3],e[4],e[5],0,e[6],e[7],e[8],0,0,0,0,1]),this}invert(){return v(this.matrix,this.matrix),this}identity(){return m(this.matrix),this}apply(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:-1;if(Xo(ao,this.matrix))return this;const r=-1===n?e.length:t+3*n;for(let n=t;n<r;n+=3)hn(this.tmp,e[n],e[n+1],e[n+2]),In(this.tmp,this.tmp,this.matrix),e[n]=this.tmp[0],e[n+1]=this.tmp[1],e[n+2]=this.tmp[2];return this}getMatrix(){return this.matrix}setMatrix(e){return e&&16===e.length&&p(this.matrix,e),this}}var uf=function(){return new cf(!0)},df=function(){return new cf(!1)};const pf=[2,0,1,2,2,3,2,4,5,2,6,7,2,0,2,2,1,3,2,4,6,2,5,7,2,0,4,2,1,5,2,2,6,2,3,7],ff=[4,0,1,3,2,4,4,6,7,5,4,8,10,11,9,4,12,13,15,14,4,16,18,19,17,4,20,21,23,22],gf={xLength:1,yLength:1,zLength:1,pointType:&quot;Float64Array&quot;,generate3DTextureCoordinates:!1,generateFaces:!0,generateLines:!1};function mf(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,gf,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;xLength&quot;,&quot;yLength&quot;,&quot;zLength&quot;,&quot;generate3DTextureCoordinates&quot;,&quot;generateFaces&quot;,&quot;generateLines&quot;]),Wt.setGetArray(e,t,[&quot;center&quot;,&quot;rotations&quot;],3),Wt.setGetArray(e,t,[&quot;matrix&quot;],16),t._polys=Kl.newInstance({values:Uint16Array.from(ff)}),t._lineCells=Kl.newInstance({values:Uint16Array.from(pf)}),Wt.moveToProtected(e,t,[&quot;polys&quot;,&quot;lineCells&quot;]),Wt.algo(e,t,0,1),function(e,t){t.classHierarchy.push(&quot;vtkCubeSource&quot;),e.requestData=(e,n)=>{const r=n[0]?.initialize()||gu.newInstance();n[0]=r;const o=Wt.newTypedArray(t.pointType,72);r.getPoints().setData(o,3);const a=Wt.newTypedArray(t.pointType,72),i=xs.newInstance({name:&quot;Normals&quot;,values:a,numberOfComponents:3});r.getPointData().setNormals(i);let s=2;!0===t.generate3DTextureCoordinates&&(s=3);const l=Wt.newTypedArray(t.pointType,24*s),c=xs.newInstance({name:&quot;TextureCoordinates&quot;,values:l,numberOfComponents:s});r.getPointData().setTCoords(c);const u=[0,0,0],d=[0,0,0],p=[0,0];let f=0;u[0]=-t.xLength/2,d[0]=-1,d[1]=0,d[2]=0;for(let e=0;e<2;e++){u[1]=-t.yLength/2;for(let n=0;n<2;n++){p[1]=u[1]+.5,u[2]=-t.zLength/2;for(let r=0;r<2;r++)p[0]=(u[2]+.5)*(1-2*e),o[3*f]=u[0],o[3*f+1]=u[1],o[3*f+2]=u[2],a[3*f]=d[0],a[3*f+1]=d[1],a[3*f+2]=d[2],2===s?(l[f*s]=p[0],l[f*s+1]=p[1]):(l[f*s]=2*e-1,l[f*s+1]=2*n-1,l[f*s+2]=2*r-1),f++,u[2]+=t.zLength;u[1]+=t.yLength}u[0]+=t.xLength,d[0]+=2}u[1]=-t.yLength/2,d[1]=-1,d[0]=0,d[2]=0;for(let e=0;e<2;e++){u[0]=-t.xLength/2;for(let n=0;n<2;n++){p[0]=(u[0]+.5)*(2*e-1),u[2]=-t.zLength/2;for(let r=0;r<2;r++)p[1]=-1*(u[2]+.5),o[3*f]=u[0],o[3*f+1]=u[1],o[3*f+2]=u[2],a[3*f]=d[0],a[3*f+1]=d[1],a[3*f+2]=d[2],2===s?(l[f*s]=p[0],l[f*s+1]=p[1]):(l[f*s]=2*n-1,l[f*s+1]=2*e-1,l[f*s+2]=2*r-1),f++,u[2]+=t.zLength;u[0]+=t.xLength}u[1]+=t.yLength,d[1]+=2}u[2]=-t.zLength/2,d[2]=-1,d[0]=0,d[1]=0;for(let e=0;e<2;e++){u[1]=-t.yLength/2;for(let n=0;n<2;n++){p[1]=u[1]+.5,u[0]=-t.xLength/2;for(let r=0;r<2;r++)p[0]=(u[0]+.5)*(2*e-1),o[3*f]=u[0],o[3*f+1]=u[1],o[3*f+2]=u[2],a[3*f]=d[0],a[3*f+1]=d[1],a[3*f+2]=d[2],2===s?(l[f*s]=p[0],l[f*s+1]=p[1]):(l[f*s]=2*r-1,l[f*s+1]=2*n-1,l[f*s+2]=2*e-1),f++,u[0]+=t.xLength;u[1]+=t.yLength}u[2]+=t.zLength,d[2]+=2}if(t.rotations&&uf().rotateX(t.rotations[0]).rotateY(t.rotations[1]).rotateZ(t.rotations[2]).apply(o).apply(a),t.center&&df().translate(...t.center).apply(o),t.matrix){df().setMatrix(t.matrix).apply(o);const e=[t.matrix[0],t.matrix[1],t.matrix[2],0,t.matrix[4],t.matrix[5],t.matrix[6],0,t.matrix[8],t.matrix[9],t.matrix[10],0,0,0,0,1];df().setMatrix(e).apply(a)}t.generateFaces?r.getPolys().deepCopy(t._polys):r.getPolys().initialize(),t.generateLines?(r.getLines().deepCopy(t._lineCells),r.getPointData().setNormals(null)):r.getLines().initialize(),r.modified()},e.setBounds=function(){let t=[];if(Array.isArray(arguments.length<=0?void 0:arguments[0]))t=arguments.length<=0?void 0:arguments[0];else for(let e=0;e<arguments.length;e++)t.push(e<0||arguments.length<=e?void 0:arguments[e]);6===t.length&&(e.setXLength(t[1]-t[0]),e.setYLength(t[3]-t[2]),e.setZLength(t[5]-t[4]),e.setCenter([(t[0]+t[1])/2,(t[2]+t[3])/2,(t[4]+t[5])/2]))}}(e,t)}var hf={newInstance:Wt.newInstance(mf,&quot;vtkCubeSource&quot;),extend:mf};const{vtkErrorMacro:vf}=Wt,Tf={};function yf(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Tf,n),Wt.obj(e,t),Wt.algo(e,t,1,1),t._cubeSource=hf.newInstance(),Wt.moveToProtected(e,t,[&quot;cubeSource&quot;,&quot;tmpOut&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkImageDataOutlineFilter&quot;);const n={...e};e.requestData=(e,n)=>{const r=e[0];if(!r||!r.isA(&quot;vtkImageData&quot;))return void vf(&quot;Invalid or missing input&quot;);const o=r.getSpatialExtent();o?(t._cubeSource.setBounds(o),t._cubeSource.setMatrix(r.getIndexToWorld()),n[0]=t._cubeSource.getOutputData()):vf(&quot;Unable to fetch spatial extents of input image.&quot;)},e.getMTime=()=>Math.max(n.getMTime(),t._cubeSource.getMTime()),e.setGenerateFaces=t._cubeSource.setGenerateFaces,e.setGenerateLines=t._cubeSource.setGenerateLines,e.getGenerateFaces=t._cubeSource.getGenerateFaces,e.getGenerateLines=t._cubeSource.getGenerateLines}(e,t)}var bf={newInstance:Wt.newInstance(yf,&quot;vtkImageDataOutlineFilter&quot;),extend:yf};const{vtkWarningMacro:xf}=Wt;let Cf;const Sf={preMultiplyFlag:!1,matrix:[...ao]};function Af(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Sf,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;preMultiplyFlag&quot;]),Wt.setGetArray(e,t,[&quot;matrix&quot;],16),function(e,t){t.classHierarchy.push(&quot;vtkAbstractTransform&quot;,&quot;vtkHomogeneousTransform&quot;,&quot;vtkTransform&quot;),e.transformPoint=(e,n)=>(In(n,e,t.matrix),n),e.transformPoints=(e,n)=>{const r=new Float64Array(3),o=new Float64Array(3);for(let a=0;a<e.length;a+=3)r[0]=e[a],r[1]=e[a+1],r[2]=e[a+2],In(o,r,t.matrix),n[a]=o[0],n[a+1]=o[1],n[a+2]=o[2];return n},e.preMultiply=()=>{e.setPreMultiplyFlag(!0)},e.postMultiply=()=>{e.setPreMultiplyFlag(!1)},e.transformMatrix=(e,n)=>(t.preMultiplyFlag?b(n,t.matrix,e):b(n,e,t.matrix),n),e.transformMatrices=(e,n)=>{const r=new Float64Array(16),o=new Float64Array(16),a=t.preMultiplyFlag?()=>b(o,t.matrix,r):()=>b(o,r,t.matrix);for(let t=0;t<e.length;t+=16){for(let n=0;n<16;++n)r[n]=e[t+n];a();for(let e=0;e<16;++e)n[t+e]=o[e]}return n},e.getInverse=()=>Cf({matrix:Da.invertMatrix(Array.from(t.matrix),[],4),preMultiplyFlag:t.preMultiplyFlag}),e.translate=(n,r,o)=>{if(0===n&&0===r&&0===o)return;const a=u();O(a,[n,r,o]),t.preMultiplyFlag?b(t.matrix,t.matrix,a):b(t.matrix,a,t.matrix),e.modified()},e.rotateWXYZ=(n,r,o,a)=>{if(0===r&&0===o&&0===a)return void xf(&quot;No rotation applied, axis is zero vector.&quot;);if(0===n)return;const i=Da.radiansFromDegrees(n),s=Ba();Na(s,[r,o,a],i);const l=new Float64Array(16);G(l,s),t.preMultiplyFlag?b(t.matrix,t.matrix,l):b(t.matrix,l,t.matrix),e.modified()},e.rotateX=t=>{e.rotateWXYZ(t,1,0,0)},e.rotateY=t=>{e.rotateWXYZ(t,0,1,0)},e.rotateZ=t=>{e.rotateWXYZ(t,0,0,1)},e.scale=(n,r,o)=>{if(1===n&&1===r&&1===o)return;const a=u();P(a,[n,r,o]),t.preMultiplyFlag?b(t.matrix,t.matrix,a):b(t.matrix,a,t.matrix),e.modified()},e.transformNormal=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];const o=le(se(),t.matrix),a=se();me(a,o);const i=se();return ge(i,a),e.transformVector(n,r,i),Da.normalize(r),r},e.transformNormals=(n,r)=>{const o=n.getData(),a=r.getData(),i=[0,0,0],s=le(se(),t.matrix),l=se();me(l,s);const c=se();ge(c,l);for(let t=0;t<o.length;t+=3)i[0]=o[t],i[1]=o[t+1],i[2]=o[t+2],e.transformVector(i,i,c),Da.normalize(i),a[t]=i[0],a[t+1]=i[1],a[t+2]=i[2]},e.transformVector=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return wn(n,e,(arguments.length>2&&void 0!==arguments[2]?arguments[2]:null)||le(se(),t.matrix)),n},e.transformVectors=(t,n)=>{const r=t.getData(),o=n.getData(),a=[0,0,0];for(let t=0;t<r.length;t+=3)a[0]=r[t],a[1]=r[t+1],a[2]=r[t+2],e.transformVector(a,a),Da.normalize(a),o[t]=a[0],o[t+1]=a[1],o[t+2]=a[2]},e.transformPointsNormalsVectors=function(t,n,r,o,a,i){let s=arguments.length>6&&void 0!==arguments[6]?arguments[6]:null,l=arguments.length>7&&void 0!==arguments[7]?arguments[7]:null;const c=t.getNumberOfPoints(),u=s?.length??0,d=new Float64Array(3),p=new Float64Array(3),f=new Float64Array(3),g=new Float64Array(3);let m=!1,h=!1,v=!1;const T=[];for(let y=0;y<c;y++){if(t.getPoint(y,d),p.set(d),e.transformPoint(d,d),n.setPoint(y,...d),Da.areEquals(p,d)||(m=!0),a){const t=a.getData(),n=i.getData();d[0]=t[3*y],d[1]=t[3*y+1],d[2]=t[3*y+2],f.set(d),e.transformVector(d,d),n[3*y]=d[0],n[3*y+1]=d[1],n[3*y+2]=d[2],Da.areEquals(f,d)||(h=!0)}if(r){const t=r.getData(),n=o.getData();d[0]=t[3*y],d[1]=t[3*y+1],d[2]=t[3*y+2],g.set(d),e.transformNormal(d,d),n[3*y]=d[0],n[3*y+1]=d[1],n[3*y+2]=d[2],Da.areEquals(g,d)||(v=!0)}if(s)for(let t=0;t<u;t++){const n=s[t].getData(),r=l[t].getData();d[0]=n[3*y],d[1]=n[3*y+1],d[2]=n[3*y+2],f.set(d),e.transformVector(d,d),r[3*y]=d[0],r[3*y+1]=d[1],r[3*y+2]=d[2],Da.arrayEqual(f,d)||T.includes(t)||T.push(t)}}m&&n.modified(),h&&i.modified(),v&&o.modified(),T.forEach((e=>l[e].modified()))}}(e,t)}Cf=Wt.newInstance(Af,&quot;vtkTransform&quot;);var If={newInstance:Cf,extend:Af};function wf(e,t,n){return e.length>0?`${e.map((e=>e?.getMTime()??&quot;x&quot;)).join(&quot;/&quot;)}-${t}-${n}`:&quot;0&quot;}function Of(e,t){return`${t.getMTime()}`}const Pf={NEAREST:0,LINEAR:1};var Rf={InterpolationType:Pf};const{vtkErrorMacro:Mf}=Ht;function Ef(e,t,n){return t.identity(n),e.reduce(((e,n,r)=>0===r?n?t.copy(e,n):t.identity(e):n?t.multiply(e,e,n):e),n)}const Vf={VBOBuildTime:{},VBOBuildString:null,haveSeenDepthRequest:!1,lastHaveSeenDepthRequest:!1,lastIndependentComponents:!1,lastNumberOfComponents:0,lastMultiTexturePerVolumeEnabled:!1,lastSlabThickness:0,lastSlabTrapezoidIntegration:0,lastSlabType:-1,scalarTextures:[],_scalarTexturesCore:[],colorTexture:null,_colorTextureCore:null,pwfTexture:null,_pwfTextureCore:null,_externalOpenGLTexture:!1,resliceGeom:null,resliceGeomUpdateString:null,tris:null};const Df=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Vf,n),qt.extend(e,t,n),Ed(e,t,n),Vd(e,t,n),t.tris=ld.newInstance(),t.scalarTextures=[],t.colorTexture=null,t.pwfTexture=null,t.VBOBuildTime={},ht(t.VBOBuildTime),t.tmpMat4=m(new Float64Array(16)),t.outlineFilter=bf.newInstance(),t.outlineFilter.setGenerateFaces(!0),t.outlineFilter.setGenerateLines(!1),t.cubePolyData=gu.newInstance(),t.cutter=af.newInstance(),t.lineToSurfaceFilter=ef.newInstance(),t.transform=If.newInstance(),Tt(e,t,[&quot;scalarTextures&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLImageResliceMapper&quot;);const n=new Map;function o(t,r,o){r!==o&&(function(t,r){if(!r)return;const o=(n.get(r)??0)-1;o<=0?(t.unregisterGraphicsResourceUser(r,e),n.delete(r)):n.set(r,o)}(t,r),function(t,r){if(!r)return;const o=n.get(r)??0,a=o+1;n.set(r,a),o<=0&&t.registerGraphicsResourceUser(r,e)}(t,o))}function a(t){[...n.keys()].forEach((n=>t.unregisterGraphicsResourceUser(n,e)))}e.buildPass=n=>{if(n){t.currentRenderPass=null,t._openGLImageSlice=e.getFirstAncestorOfType(&quot;vtkOpenGLImageSlice&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;);const n=t._openGLRenderer.getRenderable();t._openGLCamera=t._openGLRenderer.getViewNodeFor(n.getActiveCamera());const r=t._openGLRenderWindow;t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),r&&!r.isDeleted()&&r!==t._openGLRenderWindow&&a(r),t.context=t._openGLRenderWindow.getContext(),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow)}},e.translucentPass=(n,r)=>{n&&(t.currentRenderPass=r,e.render())},e.zBufferPass=n=>{n&&(t.haveSeenDepthRequest=!0,t.renderDepth=!0,e.render(),t.renderDepth=!1)},e.opaqueZBufferPass=t=>e.zBufferPass(t),e.opaquePass=t=>{t&&e.render()},e.getCoincidentParameters=(e,n)=>t.renderable.getResolveCoincidentTopology()==gl.PolygonOffset?t.renderable.getCoincidentTopologyPolygonOffsetParameters():null,e.render=()=>{const n=t._openGLImageSlice.getRenderable(),r=t._openGLRenderer.getRenderable();e.renderPiece(r,n)},e.renderPiece=(n,r)=>{e.invokeEvent({type:&quot;StartEvent&quot;}),t.renderable.update();const o=t.renderable.getNumberOfInputPorts();t.currentValidInputs=[];for(let e=0;e<o;++e){const n=t.renderable.getInputData(e);n&&!n.isDeleted()&&t.currentValidInputs.push({imageData:n,inputIndex:e})}const a=t.currentValidInputs.length;if(a<=0)return void Mf(&quot;No input!&quot;);const i=t.currentValidInputs[0].imageData.getPointData().getScalars();t.multiTexturePerVolumeEnabled=a>1,t.numberOfComponents=t.multiTexturePerVolumeEnabled?a:i.getNumberOfComponents(),e.updateResliceGeometry(),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r),e.invokeEvent({type:&quot;EndEvent&quot;})},e.renderPieceStart=(n,r)=>{e.updateBufferObjects(n,r);const o=r.getProperties();t.currentValidInputs.forEach((e=>{let{inputIndex:n}=e;const r=o[n].getInterpolationType(),a=t.scalarTextures[n];r===Pf.NEAREST?(a.setMinificationFilter(ud.NEAREST),a.setMagnificationFilter(ud.NEAREST)):(a.setMinificationFilter(ud.LINEAR),a.setMagnificationFilter(ud.LINEAR))}));const a=t.currentValidInputs[0];o[a.inputIndex].getInterpolationType()===Pf.NEAREST?(t.colorTexture.setMinificationFilter(ud.NEAREST),t.colorTexture.setMagnificationFilter(ud.NEAREST),t.pwfTexture.setMinificationFilter(ud.NEAREST),t.pwfTexture.setMagnificationFilter(ud.NEAREST)):(t.colorTexture.setMinificationFilter(ud.LINEAR),t.colorTexture.setMagnificationFilter(ud.LINEAR),t.pwfTexture.setMinificationFilter(ud.LINEAR),t.pwfTexture.setMagnificationFilter(ud.LINEAR)),t.lastBoundBO=null},e.renderPieceDraw=(n,r)=>{const o=t.context,a=[...t.scalarTextures,t.colorTexture,t.pwfTexture];a.forEach((e=>e.activate())),e.updateShaders(t.tris,n,r),o.drawArrays(o.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release(),a.forEach((e=>e.deactivate()))},e.renderPieceFinish=(e,t)=>{},e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n)},e.getNeedToRebuildBufferObjects=(n,r)=>t.VBOBuildTime.getMTime()<e.getMTime()||t.VBOBuildTime.getMTime()<r.getMTime()||t.VBOBuildTime.getMTime()<t.renderable.getMTime()||t.VBOBuildTime.getMTime()<r.getProperty(t.currentValidInputs[0].inputIndex)?.getMTime()||t.currentValidInputs.some((e=>{let{imageData:n}=e;return t.VBOBuildTime.getMTime()<n.getMTime()}))||t.VBOBuildTime.getMTime()<t.resliceGeom.getMTime()||t.scalarTextures.length!==t.currentValidInputs.length||!t.scalarTextures.every((e=>!!e?.getHandle()))||!t.colorTexture?.getHandle()||!t.pwfTexture?.getHandle(),e.buildBufferObjects=(e,n)=>{const r=n.getProperties();t.currentValidInputs.forEach(((e,n)=>{let{imageData:a}=e;const i=a.getPointData().getScalars(),s=t._openGLRenderWindow.getGraphicsResourceForObject(i),l=Of(0,i),c=!s?.oglObject?.getHandle()||s?.hash!==l,u=r[n],d=u.getUpdatedExtents(),p=!!d.length;if(c&&!p){const e=Pd.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow);const r=a.getDimensions();e.setOglNorm16Ext(t.context.getExtension(&quot;EXT_texture_norm16&quot;)),e.resetFormatAndType(),e.create3DFilterableFromDataArray({width:r[0],height:r[1],depth:r[2],dataArray:i}),t._openGLRenderWindow.setGraphicsResourceForObject(i,e,l),t.scalarTextures[n]=e}else t.scalarTextures[n]=s.oglObject;if(p){u.setUpdatedExtents([]);const e=a.getDimensions();t.scalarTextures[n].create3DFilterableFromDataArray({width:e[0],height:e[1],depth:e[2],dataArray:i,updatedExtents:d})}o(t._openGLRenderWindow,t._scalarTexturesCore[n],i),t._scalarTexturesCore[n]=i}));const a=t.currentValidInputs[0],i=r[a.inputIndex],s=i.getIndependentComponents(),l=s?t.numberOfComponents:1,c=s?2*l:1,u=[];for(let e=0;e<l;++e)u.push(i.getRGBTransferFunction(e));const d=wf(u,s,l),p=i.getRGBTransferFunction(),f=t._openGLRenderWindow.getGraphicsResourceForObject(p);if(f?.oglObject?.getHandle()&&f?.hash===d)t.colorTexture=f.oglObject;else{let e=t.renderable.getColorTextureWidth();e<=0&&(e=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const n=new Uint8ClampedArray(e*c*3),r=Pd.newInstance();if(r.setOpenGLRenderWindow(t._openGLRenderWindow),p){const t=new Float32Array(3*e);for(let r=0;r<l;r++){const o=i.getRGBTransferFunction(r),a=o.getRange();if(o.getTable(a[0],a[1],e,t,1),s)for(let o=0;o<3*e;o++)n[r*e*6+o]=255*t[o],n[r*e*6+o+3*e]=255*t[o];else for(let o=0;o<3*e;o++)n[r*e*3+o]=255*t[o]}r.resetFormatAndType(),r.create2DFromRaw({width:e,height:c,numComps:3,dataType:cs.UNSIGNED_CHAR,data:n})}else{for(let t=0;t<3*e;++t){const r=255*t/(3*(e-1));for(let o=0;o<c;++o)n[o*e*3+t+0]=r,n[o*e*3+t+1]=r,n[o*e*3+t+2]=r}r.resetFormatAndType(),r.create2DFromRaw({width:e,height:1,numComps:3,dataType:cs.UNSIGNED_CHAR,data:n})}p&&t._openGLRenderWindow.setGraphicsResourceForObject(p,r,d),t.colorTexture=r}o(t._openGLRenderWindow,t._colorTextureCore,p),t._colorTextureCore=p;const g=[];for(let e=0;e<l;++e)g.push(i.getPiecewiseFunction(e));const m=wf(g,s,l),h=i.getPiecewiseFunction(),v=t._openGLRenderWindow.getGraphicsResourceForObject(h);if(v?.oglObject?.getHandle()&&v?.hash===m)t.pwfTexture=v.oglObject;else{let e=t.renderable.getOpacityTextureWidth();e<=0&&(e=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const n=e*c,r=new Uint8ClampedArray(n),o=Pd.newInstance();if(o.setOpenGLRenderWindow(t._openGLRenderWindow),h){const t=new Float32Array(n),r=new Float32Array(e);for(let n=0;n<l;++n){const o=i.getPiecewiseFunction(n);if(null===o)t.fill(1);else{const a=o.getRange();if(o.getTable(a[0],a[1],e,r,1),s)for(let o=0;o<e;o++)t[n*e*2+o]=r[o],t[n*e*2+o+e]=r[o];else for(let n=0;n<e;n++)t[n]=r[n]}}o.resetFormatAndType(),o.create2DFromRaw({width:e,height:c,numComps:1,dataType:cs.FLOAT,data:t})}else r.fill(255),o.resetFormatAndType(),o.create2DFromRaw({width:e,height:c,numComps:1,dataType:cs.UNSIGNED_CHAR,data:r});h&&t._openGLRenderWindow.setGraphicsResourceForObject(h,o,m),t.pwfTexture=o}o(t._openGLRenderWindow,t._pwfTextureCore,h),t._pwfTextureCore=h;const T=`${t.resliceGeom.getMTime()}A${t.renderable.getSlabThickness()}`;if(!t.tris.getCABO().getElementCount()||t.VBOBuildString!==T){const e=xs.newInstance({numberOfComponents:3,values:t.resliceGeom.getPoints().getData()});e.setName(&quot;points&quot;);const n=xs.newInstance({numberOfComponents:1,values:t.resliceGeom.getPolys().getData()}),r={points:e,cellOffset:0};if(t.renderable.getSlabThickness()>0){const e=t.resliceGeom.getPointData().getNormals();e?r.normals=e:Mf(&quot;Slab mode requested without normals&quot;)}t.tris.getCABO().createVBO(n,&quot;polys&quot;,Zi.SURFACE,r)}t.VBOBuildString=T,t.VBOBuildTime.modified()},e.updateShaders=(n,r,o)=>{if(t.lastBoundBO=n,e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};e.buildShaders(a,r,o);const i=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==n.getProgram()&&(n.setProgram(i),n.getVAO().releaseGraphicsResources()),n.getShaderSourceTime().modified()}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(n.getProgram());n.getVAO().bind(),e.setMapperShaderParameters(n,r,o),e.setCameraShaderParameters(n,r,o),e.setPropertyShaderParameters(n,r,o)},e.setMapperShaderParameters=(n,r,o)=>{const a=n.getProgram(),i=t.currentValidInputs[0].imageData;if(n.getCABO().getElementCount()&&(t.VBOBuildTime.getMTime()>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())){t.scalarTextures.forEach(((e,t)=>{a.setUniformi(`volumeTexture[${t}]`,e.getTextureUnit())})),a.isAttributeUsed(&quot;vertexWC&quot;)&&(n.getVAO().addAttributeArray(a,n.getCABO(),&quot;vertexWC&quot;,n.getCABO().getVertexOffset(),n.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||Mf(&quot;Error setting vertexWC in shader VAO.&quot;)),a.isAttributeUsed(&quot;normalWC&quot;)&&(n.getVAO().addAttributeArray(a,n.getCABO(),&quot;normalWC&quot;,n.getCABO().getNormalOffset(),n.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||Mf(&quot;Error setting normalWC in shader VAO.&quot;)),a.isUniformUsed(&quot;slabThickness&quot;)&&a.setUniformf(&quot;slabThickness&quot;,t.renderable.getSlabThickness()),a.isUniformUsed(&quot;spacing&quot;)&&a.setUniform3fv(&quot;spacing&quot;,i.getSpacing()),a.isUniformUsed(&quot;slabType&quot;)&&a.setUniformi(&quot;slabType&quot;,t.renderable.getSlabType()),a.isUniformUsed(&quot;slabType&quot;)&&a.setUniformi(&quot;slabType&quot;,t.renderable.getSlabType()),a.isUniformUsed(&quot;slabTrapezoid&quot;)&&a.setUniformi(&quot;slabTrapezoid&quot;,t.renderable.getSlabTrapezoidIntegration());const e=n.getCABO().getCoordShiftAndScaleEnabled()?n.getCABO().getInverseShiftAndScaleMatrix():null;if(a.isUniformUsed(&quot;WCTCMatrix&quot;)){const n=i.getDimensions();p(t.tmpMat4,i.getIndexToWorld()),x(t.tmpMat4,t.tmpMat4,[-.5,-.5,-.5]),C(t.tmpMat4,t.tmpMat4,n),v(t.tmpMat4,t.tmpMat4),e&&b(t.tmpMat4,t.tmpMat4,e),a.setUniformMatrix(&quot;WCTCMatrix&quot;,t.tmpMat4)}a.isUniformUsed(&quot;vboScaling&quot;)&&a.setUniform3fv(&quot;vboScaling&quot;,n.getCABO().getCoordScale()??[1,1,1]),n.getAttributeUpdateTime().modified()}if(t.haveSeenDepthRequest&&n.getProgram().setUniformi(&quot;depthRequest&quot;,t.renderDepth?1:0),n.getProgram().isUniformUsed(&quot;coffset&quot;)){const t=e.getCoincidentParameters(r,o);n.getProgram().setUniformf(&quot;coffset&quot;,t.offset),n.getProgram().isUniformUsed(&quot;cfactor&quot;)&&n.getProgram().setUniformf(&quot;cfactor&quot;,t.factor)}},e.setCameraShaderParameters=(e,n,o)=>{const a=t._openGLCamera.getKeyMatrices(n),i=t._openGLImageSlice.getKeyMatrices(),s=e.getCABO().getCoordShiftAndScaleEnabled()?e.getCABO().getInverseShiftAndScaleMatrix():null,l=e.getProgram();l.isUniformUsed(&quot;MCPCMatrix&quot;)&&(m(t.tmpMat4),l.setUniformMatrix(&quot;MCPCMatrix&quot;,Ef([a.wcpc,i.mcwc,s],r,t.tmpMat4))),l.isUniformUsed(&quot;MCVCMatrix&quot;)&&(m(t.tmpMat4),l.setUniformMatrix(&quot;MCVCMatrix&quot;,Ef([a.wcvc,i.mcwc,s],r,t.tmpMat4)))},e.setPropertyShaderParameters=(e,n,r)=>{const o=e.getProgram(),a=r.getProperty(t.currentValidInputs[0].inputIndex),i=a.getOpacity();o.setUniformf(&quot;opacity&quot;,i);const s=t.numberOfComponents,l=a.getIndependentComponents();if(l)for(let e=0;e<s;++e)o.setUniformf(`mix${e}`,a.getComponentWeight(e));for(let e=0;e<s;e++){const n=t.multiTexturePerVolumeEnabled,r=n?e:0,i=n?0:e,s=t.scalarTextures[r].getVolumeInfo(),c=s.scale[i],u=s.offset[i],d=l?e:0;let p=a.getColorWindow(),f=a.getColorLevel();const g=a.getRGBTransferFunction(d);if(g&&a.getUseLookupTableScalarRange()){const e=g.getRange();p=e[1]-e[0],f=.5*(e[1]+e[0])}const m=c/p,h=(u-f)/p+.5;o.setUniformf(`cshift${e}`,h),o.setUniformf(`cscale${e}`,m);let v=1,T=0;const y=a.getPiecewiseFunction(d);if(y){const e=y.getRange(),t=e[1]-e[0];v=c/t,T=(u-.5*(e[0]+e[1]))/t+.5}o.setUniformf(`pwfshift${e}`,T),o.setUniformf(`pwfscale${e}`,v)}const c=t.colorTexture.getTextureUnit();o.setUniformi(&quot;colorTexture1&quot;,c);const u=t.pwfTexture.getTextureUnit();o.setUniformi(&quot;pwfTexture1&quot;,u),o.setUniform4fv(&quot;backgroundColor&quot;,t.renderable.getBackgroundColor())},e.getNeedToRebuildShaders=(e,n,r)=>{const o=r.getProperty(t.currentValidInputs[0].inputIndex).getIndependentComponents(),a=t.renderable.getSlabThickness(),i=t.renderable.getSlabType(),s=t.renderable.getSlabTrapezoidIntegration();let l=!1;return(!t.currentRenderPass&&t.lastRenderPassShaderReplacement||t.currentRenderPass&&t.currentRenderPass.getShaderReplacement()!==t.lastRenderPassShaderReplacement)&&(l=!0),!(!l&&t.lastHaveSeenDepthRequest===t.haveSeenDepthRequest&&t.lastNumberOfComponents===t.numberOfComponents&&t.lastMultiTexturePerVolumeEnabled===t.multiTexturePerVolumeEnabled&&0!==e.getProgram()?.getHandle()&&t.lastIndependentComponents===o&&t.lastSlabThickness===a&&t.lastSlabType===i&&t.lastSlabTrapezoidIntegration===s||(t.lastHaveSeenDepthRequest=t.haveSeenDepthRequest,t.lastNumberOfComponents=t.numberOfComponents,t.lastMultiTexturePerVolumeEnabled=t.multiTexturePerVolumeEnabled,t.lastIndependentComponents=o,t.lastSlabThickness=a,t.lastSlabType=i,t.lastSlabTrapezoidIntegration=s,0))},e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkImageResliceMapperVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\n// all variables that represent positions or directions have a suffix\\n// indicating the coordinate system they are in. The possible values are\\n// MC - Model coordinates\\n// WC - World coordinates\\n// VC - View coordinates\\n// DC - Display coordinates\\n// TC - Texture coordinates\\n\\n// frag position in VC\\n//VTK::PositionVC::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\n// camera and actor matrix values\\n//VTK::Camera::Dec\\n\\nvoid main()\\n{\\n  //VTK::PositionVC::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Picking::Impl\\n}\\n&quot;,e.Fragment=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkImageResliceMapperFS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// Template for the gpu image mapper fragment shader\\n\\n// VC position of this fragment\\n//VTK::PositionVC::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\n// handle coincident offsets\\n//VTK::Coincident::Dec\\n\\n//VTK::ZBuffer::Dec\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nvoid main()\\n{\\n  // VC position of this fragment. This should not branch/return/discard.\\n  //VTK::PositionVC::Impl\\n\\n  // Place any calls that require uniform flow (e.g. dFdx) here.\\n  //VTK::UniformFlow::Impl\\n\\n  // Set gl_FragDepth here (gl_FragCoord.z by default)\\n  //VTK::Depth::Impl\\n\\n  // Early depth peeling abort:\\n  //VTK::DepthPeeling::PreColor\\n\\n  //VTK::TCoord::Impl\\n\\n  if (gl_FragData[0].a <= 0.0)\\n    {\\n    discard;\\n    }\\n\\n  //VTK::DepthPeeling::Impl\\n\\n  //VTK::Picking::Impl\\n\\n  // handle coincident offsets\\n  //VTK::Coincident::Impl\\n\\n  //VTK::ZBuffer::Impl\\n\\n  //VTK::RenderPassFragmentShader::Impl\\n}\\n&quot;,e.Geometry=&quot;&quot;},e.replaceShaderValues=(n,r,o)=>{if(e.replaceShaderTCoord(n,r,o),e.replaceShaderPositionVC(n,r,o),t.haveSeenDepthRequest){let e=n.Fragment;e=td.substitute(e,&quot;//VTK::ZBuffer::Dec&quot;,&quot;uniform int depthRequest;&quot;).result,e=td.substitute(e,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float iz = floor(gl_FragCoord.z*65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result,n.Fragment=e}e.replaceShaderCoincidentOffset(n,r,o)},e.replaceShaderTCoord=(e,n,r)=>{let o=e.Vertex;const a=e.Geometry;let i=e.Fragment;const s=t.renderable.getSlabThickness();o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;uniform mat4 WCTCMatrix;&quot;,&quot;out vec3 fragTexCoord;&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;fragTexCoord = (WCTCMatrix * vertexWC).xyz;&quot;]).result;const l=t.numberOfComponents,c=r.getProperty(t.currentValidInputs[0].inputIndex).getIndependentComponents();let u=[&quot;in vec3 fragTexCoord;&quot;,`uniform highp sampler3D volumeTexture[${t.scalarTextures.length}];`,&quot;uniform mat4 WCTCMatrix;&quot;,&quot;uniform float cshift0;&quot;,&quot;uniform float cscale0;&quot;,&quot;uniform float pwfshift0;&quot;,&quot;uniform float pwfscale0;&quot;,&quot;uniform sampler2D colorTexture1;&quot;,&quot;uniform sampler2D pwfTexture1;&quot;,&quot;uniform float opacity;&quot;,&quot;uniform vec4 backgroundColor;&quot;];if(u.push(&quot;vec4 rawSampleTexture(vec3 pos) {&quot;),t.multiTexturePerVolumeEnabled){u.push(&quot;vec4 rawSample;&quot;);for(let e=0;e<t.scalarTextures.length;++e)u.push(`rawSample[${e}] = texture(volumeTexture[${e}], pos)[0];`);u.push(&quot;return rawSample;&quot;,&quot;}&quot;)}else u.push(&quot;return texture(volumeTexture[0], pos);&quot;,&quot;}&quot;);if(c){for(let e=1;e<l;e++)u=u.concat([`uniform float cshift${e};`,`uniform float cscale${e};`,`uniform float pwfshift${e};`,`uniform float pwfscale${e};`]);switch(l){case 1:u=u.concat([&quot;uniform float mix0;&quot;,&quot;#define height0 0.5&quot;]);break;case 2:u=u.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;#define height0 0.25&quot;,&quot;#define height1 0.75&quot;]);break;case 3:u=u.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;#define height0 0.17&quot;,&quot;#define height1 0.5&quot;,&quot;#define height2 0.83&quot;]);break;case 4:u=u.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;uniform float mix3;&quot;,&quot;#define height0 0.125&quot;,&quot;#define height1 0.375&quot;,&quot;#define height2 0.625&quot;,&quot;#define height3 0.875&quot;]);break;default:Mf(&quot;Unsupported number of independent coordinates.&quot;)}}s>0&&(u=u.concat([&quot;uniform vec3 spacing;&quot;,&quot;uniform float slabThickness;&quot;,&quot;uniform int slabType;&quot;,&quot;uniform int slabTrapezoid;&quot;,&quot;uniform vec3 vboScaling;&quot;]),u=u.concat([&quot;vec4 compositeValue(vec4 currVal, vec4 valToComp, int trapezoid)&quot;,&quot;{&quot;,&quot;  vec4 retVal = vec4(1.0);&quot;,&quot;  if (slabType == 0) // min&quot;,&quot;  {&quot;,&quot;    retVal = min(currVal, valToComp);&quot;,&quot;  }&quot;,&quot;  else if (slabType == 1) // max&quot;,&quot;  {&quot;,&quot;    retVal = max(currVal, valToComp);&quot;,&quot;  }&quot;,&quot;  else if (slabType == 3) // sum&quot;,&quot;  {&quot;,&quot;    retVal = currVal + (trapezoid > 0 ? 0.5 * valToComp : valToComp); &quot;,&quot;  }&quot;,&quot;  else // mean&quot;,&quot;  {&quot;,&quot;    retVal = currVal + (trapezoid > 0 ? 0.5 * valToComp : valToComp); &quot;,&quot;  }&quot;,&quot;  return retVal;&quot;,&quot;}&quot;])),i=td.substitute(i,&quot;//VTK::TCoord::Dec&quot;,u).result;let d=[&quot;if (any(greaterThan(fragTexCoord, vec3(1.0))) || any(lessThan(fragTexCoord, vec3(0.0))))&quot;,&quot;{&quot;,&quot;  // set the background color and exit&quot;,&quot;  gl_FragData[0] = backgroundColor;&quot;,&quot;  return;&quot;,&quot;}&quot;,&quot;vec4 tvalue = rawSampleTexture(fragTexCoord);&quot;];if(s>0&&(d=d.concat([&quot;// Get the first and last samples&quot;,&quot;int numSlices = 1;&quot;,&quot;float scaling = min(min(spacing.x, spacing.y), spacing.z) * 0.5;&quot;,&quot;vec3 normalxspacing = scaling * normalWCVSOutput;&quot;,&quot;float distTraveled = length(normalxspacing);&quot;,&quot;int trapezoid = 0;&quot;,&quot;while (distTraveled < slabThickness * 0.5)&quot;,&quot;{&quot;,&quot;  distTraveled += length(normalxspacing);&quot;,&quot;  float fnumSlices = float(numSlices);&quot;,&quot;  if (distTraveled > slabThickness * 0.5)&quot;,&quot;  {&quot;,&quot;    // Before stepping outside the slab, sample at the boundaries&quot;,&quot;    normalxspacing = normalWCVSOutput * slabThickness * 0.5 / fnumSlices;&quot;,&quot;    trapezoid = slabTrapezoid;&quot;,&quot;  }&quot;,&quot;  vec3 fragTCoordNeg = (WCTCMatrix * vec4(vertexWCVSOutput.xyz - fnumSlices * normalxspacing * vboScaling, 1.0)).xyz;&quot;,&quot;  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))&quot;,&quot;  {&quot;,&quot;    vec4 newVal = rawSampleTexture(fragTCoordNeg);&quot;,&quot;    tvalue = compositeValue(tvalue, newVal, trapezoid);&quot;,&quot;    numSlices += 1;&quot;,&quot;  }&quot;,&quot;  vec3 fragTCoordPos = (WCTCMatrix * vec4(vertexWCVSOutput.xyz + fnumSlices * normalxspacing * vboScaling, 1.0)).xyz;&quot;,&quot;  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))&quot;,&quot;  {&quot;,&quot;    vec4 newVal = rawSampleTexture(fragTCoordPos);&quot;,&quot;    tvalue = compositeValue(tvalue, newVal, trapezoid);&quot;,&quot;    numSlices += 1;&quot;,&quot;  }&quot;,&quot;}&quot;,&quot;// Finally, if slab type is *mean*, divide the sum by the numSlices&quot;,&quot;if (slabType == 2)&quot;,&quot;{&quot;,&quot;  tvalue = tvalue / float(numSlices);&quot;,&quot;}&quot;])),c){const e=[&quot;r&quot;,&quot;g&quot;,&quot;b&quot;,&quot;a&quot;];for(let t=0;t<l;++t)d=d.concat([`vec3 tcolor${t} = texture2D(colorTexture1, vec2(tvalue.${e[t]} * cscale${t} + cshift${t}, height${t})).rgb;`,`float compWeight${t} = mix${t} * texture2D(pwfTexture1, vec2(tvalue.${e[t]} * pwfscale${t} + pwfshift${t}, height${t})).r;`]);switch(l){case 1:d=d.concat([&quot;gl_FragData[0] = vec4(tcolor0.rgb, compWeight0 * opacity);&quot;]);break;case 2:d=d.concat([&quot;float weightSum = compWeight0 + compWeight1;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum))), opacity);&quot;]);break;case 3:d=d.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum))), opacity);&quot;]);break;case 4:d=d.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2 + compWeight3;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum)) + (tcolor3.rgb * (compWeight3 / weightSum))), opacity);&quot;]);break;default:Mf(&quot;Unsupported number of independent coordinates.&quot;)}}else switch(l){case 1:d=d.concat([&quot;// Dependent components&quot;,&quot;float intensity = tvalue.r;&quot;,&quot;vec3 tcolor = texture2D(colorTexture1, vec2(intensity * cscale0 + cshift0, 0.5)).rgb;&quot;,&quot;float scalarOpacity = texture2D(pwfTexture1, vec2(intensity * pwfscale0 + pwfshift0, 0.5)).r;&quot;,&quot;gl_FragData[0] = vec4(tcolor, scalarOpacity * opacity);&quot;]);break;case 2:d=d.concat([&quot;float intensity = tvalue.r*cscale0 + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(intensity, 0.5)).rgb, pwfscale0*tvalue.g + pwfshift0);&quot;]);break;case 3:d=d.concat([&quot;vec4 tcolor = cscale0*tvalue + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, opacity);&quot;]);break;default:d=d.concat([&quot;vec4 tcolor = cscale0*tvalue + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, tcolor.a);&quot;])}i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,d).result,e.Vertex=o,e.Fragment=i,e.Geometry=a},e.replaceShaderPositionVC=(n,r,o)=>{let a=n.Vertex;const i=n.Geometry;let s=n.Fragment;const l=t.renderable.getSlabThickness();let c=[&quot;attribute vec4 vertexWC;&quot;];c=c.concat([`//${e.getMTime()}${t.resliceGeomUpdateString}`]),l>0&&(c=c.concat([&quot;attribute vec3 normalWC;&quot;,&quot;varying vec3 normalWCVSOutput;&quot;,&quot;varying vec4 vertexWCVSOutput;&quot;])),a=td.substitute(a,&quot;//VTK::PositionVC::Dec&quot;,c).result;let u=[&quot;gl_Position = MCPCMatrix * vertexWC;&quot;];l>0&&(u=u.concat([&quot;normalWCVSOutput = normalWC;&quot;,&quot;vertexWCVSOutput = vertexWC;&quot;])),a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,u).result,a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result;let d=[];l>0&&(d=d.concat([&quot;varying vec3 normalWCVSOutput;&quot;,&quot;varying vec4 vertexWCVSOutput;&quot;])),s=td.substitute(s,&quot;//VTK::PositionVC::Dec&quot;,d).result,n.Vertex=a,n.Geometry=i,n.Fragment=s},e.updateResliceGeometry=()=>{let e=&quot;&quot;;const n=t.currentValidInputs[0].imageData,r=n?.getBounds();let o=!0,a=2;const i=t.renderable.getSlicePolyData(),s=t.renderable.getSlicePlane();if(i)e=e.concat(`PolyData${i.getMTime()}`);else if(s){e=e.concat(`Plane${s.getMTime()}`);const t=se();n&&(e=e.concat(`Image${n.getMTime()}`),pe(t,...n.getDirection()),me(t,t));const r=[...s.getNormal()];wn(r,r,t),[o,a]=function(e){Da.normalize(e);const t=[0,0,0];for(let r=0;r<3;++r){(n=t)[0]=0,n[1]=0,n[2]=0,t[r]=1;const o=Da.dot(e,t);if(o<-.999999||o>.999999)return[!0,r]}var n;return[!1,2]}(r)}else{const o=ei.newInstance();o.setNormal(0,0,1);let a=[0,1,0,1,0,1];n&&(a=r),o.setOrigin(a[0],a[2],.5*(a[5]+a[4])),t.renderable.setSlicePlane(o),e=e.concat(`Plane${s?.getMTime()}`),n&&(e=e.concat(`Image${n.getMTime()}`))}if(!t.resliceGeom||t.resliceGeomUpdateString!==e){if(i)t.resliceGeom||(t.resliceGeom=gu.newInstance()),t.resliceGeom.getPoints().setData(i.getPoints().getData(),3),t.resliceGeom.getPolys().setData(i.getPolys().getData(),1),t.resliceGeom.getPointData().setNormals(i.getPointData().getNormals());else if(s)if(o){const e=new Float32Array(12),r=n.worldToIndex(s.getOrigin(),[0,0,0]),o=[(a+1)%3,(a+2)%3].sort(),i=n.getSpatialExtent();let l=0;for(let t=0;t<2;++t)for(let n=0;n<2;++n)e[l+a]=r[a],e[l+o[0]]=i[2*o[0]+n],e[l+o[1]]=i[2*o[1]+t],l+=3;t.transform.setMatrix(n.getIndexToWorld()),t.transform.transformPoints(e,e);const c=new Uint16Array(8);c[0]=3,c[1]=0,c[2]=1,c[3]=3,c[4]=3,c[5]=0,c[6]=3,c[7]=2;const u=s.getNormal();Da.normalize(u);const d=new Float32Array(12);for(let e=0;e<4;++e)d[3*e]=u[0],d[3*e+1]=u[1],d[3*e+2]=u[2];t.resliceGeom||(t.resliceGeom=gu.newInstance()),t.resliceGeom.getPoints().setData(e,3),t.resliceGeom.getPolys().setData(c,1);const p=xs.newInstance({numberOfComponents:3,values:d,name:&quot;Normals&quot;});t.resliceGeom.getPointData().setNormals(p)}else{t.outlineFilter.setInputData(n),t.cutter.setInputConnection(t.outlineFilter.getOutputPort()),t.cutter.setCutFunction(s),t.lineToSurfaceFilter.setInputConnection(t.cutter.getOutputPort()),t.lineToSurfaceFilter.update(),t.resliceGeom||(t.resliceGeom=gu.newInstance());const e=t.lineToSurfaceFilter.getOutputData();t.resliceGeom.getPoints().setData(e.getPoints().getData(),3),t.resliceGeom.getPolys().setData(e.getPolys().getData(),1),t.resliceGeom.getPointData().setNormals(e.getPointData().getNormals());const r=s.getNormal(),o=t.resliceGeom.getNumberOfPoints();Da.normalize(r);const a=new Float32Array(3*o);for(let e=0;e<o;++e)a[3*e]=r[0],a[3*e+1]=r[1],a[3*e+2]=r[2];const i=xs.newInstance({numberOfComponents:3,values:a,name:&quot;Normals&quot;});t.resliceGeom.getPointData().setNormals(i)}else Mf(&quot;Something went wrong.&quot;,&quot;A default slice plane should have been created in the beginning of&quot;,&quot;updateResliceGeometry.&quot;);t.resliceGeomUpdateString=e,t.resliceGeom?.modified()}},e.setScalarTextures=e=>{t.scalarTextures=[...e],t._externalOpenGLTexture=!0},e.delete=Et((()=>{t._openGLRenderWindow&&a(t._openGLRenderWindow)}),e.delete)}(e,t)}),&quot;vtkOpenGLImageResliceMapper&quot;);Jt(&quot;vtkImageResliceMapper&quot;,Df);var Lf={SlicingMode:{NONE:-1,I:0,J:1,K:2,X:3,Y:4,Z:5}};const{vtkErrorMacro:Bf}=Ht,{SlicingMode:Nf}=Lf;function Ff(e){const t=e.split(&quot;\\n&quot;),n=[];for(let e=0;e<t.length;++e){const r=t[e].trim();r.length>0&&n.push(r)}return n}const _f={VBOBuildTime:0,VBOBuildString:null,openGLTexture:null,tris:null,imagemat:null,imagematinv:null,colorTexture:null,pwfTexture:null,labelOutlineThicknessTexture:null,labelOutlineOpacityTexture:null,lastHaveSeenDepthRequest:!1,haveSeenDepthRequest:!1,lastTextureComponents:0};const kf=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,_f,n),qt.extend(e,t,n),Ed(e,t,n),Vd(e,t,n),t.tris=ld.newInstance(),t.imagemat=m(new Float64Array(16)),t.imagematinv=m(new Float64Array(16)),t.projectionToWorld=m(new Float64Array(16)),t.idxToView=m(new Float64Array(16)),t.idxNormalMatrix=fe(new Float64Array(9)),t.modelToView=m(new Float64Array(16)),t.projectionToView=m(new Float64Array(16)),Ct(e,t,[]),t.VBOBuildTime={},ht(t.VBOBuildTime),function(e,t){function n(n){t.openGLTexture.releaseGraphicsResources(n),[t._colorTransferFunc,t._pwFunc,t._labelOutlineThicknessArray,t._labelOutlineOpacity].forEach((t=>n.unregisterGraphicsResourceUser(t,e)))}t.classHierarchy.push(&quot;vtkOpenGLImageMapper&quot;),e.buildPass=r=>{if(r){t.currentRenderPass=null,t.openGLImageSlice=e.getFirstAncestorOfType(&quot;vtkOpenGLImageSlice&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;);const r=t._openGLRenderWindow;t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),r&&!r.isDeleted()&&r!==t._openGLRenderWindow&&n(r),t.context=t._openGLRenderWindow.getContext(),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow);const o=t._openGLRenderer.getRenderable();t.openGLCamera=t._openGLRenderer.getViewNodeFor(o.getActiveCamera()),t.renderable.isA(&quot;vtkImageMapper&quot;)&&t.renderable.getSliceAtFocalPoint()&&t.renderable.setSliceFromCamera(o.getActiveCamera())}},e.translucentPass=(n,r)=>{n&&(t.currentRenderPass=r,e.render())},e.zBufferPass=n=>{n&&(t.haveSeenDepthRequest=!0,t.renderDepth=!0,e.render(),t.renderDepth=!1)},e.opaqueZBufferPass=t=>e.zBufferPass(t),e.opaquePass=t=>{t&&e.render()},e.getCoincidentParameters=(e,n)=>t.renderable.getResolveCoincidentTopology()==gl.PolygonOffset?t.renderable.getCoincidentTopologyPolygonOffsetParameters():null,e.render=()=>{const n=t.openGLImageSlice.getRenderable(),r=t._openGLRenderer.getRenderable();e.renderPiece(r,n)},e.getShaderTemplate=(e,t,n)=>{e.Vertex=Rd,e.Fragment=Md,e.Geometry=&quot;&quot;},e.replaceShaderValues=(n,r,o)=>{let a=n.Vertex,i=n.Fragment;a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;  gl_Position = MCPCMatrix * vertexMC;&quot;]).result,a=td.substitute(a,&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCVSOutput = tcoordMC;&quot;).result,a=td.substitute(a,&quot;//VTK::TCoord::Dec&quot;,&quot;attribute vec2 tcoordMC; varying vec2 tcoordVCVSOutput;&quot;).result;const s=t.openGLTexture.getComponents(),l=o.getProperty().getIndependentComponents();let c=[&quot;varying vec2 tcoordVCVSOutput;&quot;,&quot;uniform float cshift0;&quot;,&quot;uniform float cscale0;&quot;,&quot;uniform float pwfshift0;&quot;,&quot;uniform float pwfscale0;&quot;,&quot;uniform sampler2D texture1;&quot;,&quot;uniform sampler2D colorTexture1;&quot;,&quot;uniform sampler2D pwfTexture1;&quot;,&quot;uniform float opacity;&quot;];if(o.getProperty().getUseLabelOutline()&&(c=c.concat([&quot;uniform sampler2D labelOutlineTexture1;&quot;,&quot;uniform sampler2D labelOutlineOpacityTexture1;&quot;])),l){for(let e=1;e<s;e++)c=c.concat([`uniform float cshift${e};`,`uniform float cscale${e};`,`uniform float pwfshift${e};`,`uniform float pwfscale${e};`]);switch(s){case 1:c=c.concat([&quot;uniform float mix0;&quot;,&quot;#define height0 0.5&quot;]);break;case 2:c=c.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;#define height0 0.25&quot;,&quot;#define height1 0.75&quot;]);break;case 3:c=c.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;#define height0 0.17&quot;,&quot;#define height1 0.5&quot;,&quot;#define height2 0.83&quot;]);break;case 4:c=c.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;uniform float mix3;&quot;,&quot;#define height0 0.125&quot;,&quot;#define height1 0.375&quot;,&quot;#define height2 0.625&quot;,&quot;#define height3 0.875&quot;]);break;default:Bf(&quot;Unsupported number of independent coordinates.&quot;)}}if(i=td.substitute(i,&quot;//VTK::TCoord::Dec&quot;,c).result,!0===o.getProperty().getUseLabelOutline()&&(i=td.substitute(i,&quot;//VTK::LabelOutline::Dec&quot;,[&quot;uniform float vpWidth;&quot;,&quot;uniform float vpHeight;&quot;,&quot;uniform float vpOffsetX;&quot;,&quot;uniform float vpOffsetY;&quot;,&quot;uniform mat4 PCWCMatrix;&quot;,&quot;uniform mat4 vWCtoIDX;&quot;,&quot;uniform ivec3 imageDimensions;&quot;,&quot;uniform int sliceAxis;&quot;]).result,i=td.substitute(i,&quot;//VTK::ImageLabelOutlineOn&quot;,&quot;#define vtkImageLabelOutlineOn&quot;).result,i=td.substitute(i,&quot;//VTK::LabelOutlineHelperFunction&quot;,[&quot;#ifdef vtkImageLabelOutlineOn&quot;,&quot;vec3 fragCoordToIndexSpace(vec4 fragCoord) {&quot;,&quot;  vec4 pcPos = vec4(&quot;,&quot;    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,&quot;,&quot;    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,&quot;,&quot;    (fragCoord.z - 0.5) * 2.0,&quot;,&quot;    1.0);&quot;,&quot;&quot;,&quot;  vec4 worldCoord = PCWCMatrix * pcPos;&quot;,&quot;  vec4 vertex = (worldCoord/worldCoord.w);&quot;,&quot;&quot;,&quot;  vec3 index = (vWCtoIDX * vertex).xyz;&quot;,&quot;&quot;,&quot;  // half voxel fix for labelmapOutline&quot;,&quot;  return (index + vec3(0.5)) / vec3(imageDimensions);&quot;,&quot;}&quot;,&quot;vec2 getSliceCoords(vec3 coord, int axis) {&quot;,&quot;  if (axis == 0) return coord.yz;&quot;,&quot;  if (axis == 1) return coord.xz;&quot;,&quot;  if (axis == 2) return coord.xy;&quot;,&quot;}&quot;,&quot;#endif&quot;]).result),l){const e=[&quot;r&quot;,&quot;g&quot;,&quot;b&quot;,&quot;a&quot;];let t=[&quot;vec4 tvalue = texture2D(texture1, tcoordVCVSOutput);&quot;];for(let n=0;n<s;n++)t=t.concat([`vec3 tcolor${n} = mix${n} * texture2D(colorTexture1, vec2(tvalue.${e[n]} * cscale${n} + cshift${n}, height${n})).rgb;`,`float compWeight${n} = mix${n} * texture2D(pwfTexture1, vec2(tvalue.${e[n]} * pwfscale${n} + pwfshift${n}, height${n})).r;`]);switch(s){case 1:t=t.concat([&quot;gl_FragData[0] = vec4(tcolor0.rgb, opacity);&quot;]);break;case 2:t=t.concat([&quot;float weightSum = compWeight0 + compWeight1;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum))), opacity);&quot;]);break;case 3:t=t.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum))), opacity);&quot;]);break;case 4:t=t.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2 + compWeight3;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum)) + (tcolor3.rgb * (compWeight3 / weightSum))), opacity);&quot;]);break;default:Bf(&quot;Unsupported number of independent coordinates.&quot;)}i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,t).result}else switch(s){case 1:i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[...Ff(&quot;\\n                #ifdef vtkImageLabelOutlineOn\\n                  vec3 centerPosIS = fragCoordToIndexSpace(gl_FragCoord);\\n                  float centerValue = texture2D(texture1, getSliceCoords(centerPosIS, sliceAxis)).r;\\n                  bool pixelOnBorder = false;\\n                  vec3 tColor = texture2D(colorTexture1, vec2(centerValue * cscale0 + cshift0, 0.5)).rgb;\\n                  float scalarOpacity = texture2D(pwfTexture1, vec2(centerValue * pwfscale0 + pwfshift0, 0.5)).r;\\n                  float opacityToUse = scalarOpacity * opacity;\\n                  int segmentIndex = int(centerValue * 255.0);\\n                  float textureCoordinate = float(segmentIndex - 1) / 1024.0;\\n                  float textureValue = texture2D(labelOutlineTexture1, vec2(textureCoordinate, 0.5)).r;\\n                  float outlineOpacity = texture2D(labelOutlineOpacityTexture1, vec2(textureCoordinate, 0.5)).r;\\n                  int actualThickness = int(textureValue * 255.0);\\n\\n                  if (segmentIndex == 0){\\n                    gl_FragData[0] = vec4(0.0, 0.0, 0.0, 0.0);\\n                    return;\\n                  }\\n\\n                  for (int i = -actualThickness; i <= actualThickness; i++) {\\n                    for (int j = -actualThickness; j <= actualThickness; j++) {\\n                      if (i == 0 || j == 0) {\\n                        continue;\\n                      }\\n                      vec4 neighborPixelCoord = vec4(gl_FragCoord.x + float(i),\\n                        gl_FragCoord.y + float(j),\\n                        gl_FragCoord.z, gl_FragCoord.w);\\n                      vec3 neighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);\\n                      float value = texture2D(texture1, getSliceCoords(neighborPosIS, sliceAxis)).r;\\n                      if (value != centerValue) {\\n                        pixelOnBorder = true;\\n                        break;\\n                      }\\n                    }\\n                    if (pixelOnBorder == true) {\\n                      break;\\n                    }\\n                  }\\n                  if (pixelOnBorder == true) {\\n                    gl_FragData[0] = vec4(tColor, outlineOpacity);\\n                  }\\n                  else {\\n                    gl_FragData[0] = vec4(tColor, opacityToUse);\\n                  }\\n                #else\\n                  float intensity = texture2D(texture1, tcoordVCVSOutput).r;\\n                  vec3 tcolor = texture2D(colorTexture1, vec2(intensity * cscale0 + cshift0, 0.5)).rgb;\\n                  float scalarOpacity = texture2D(pwfTexture1, vec2(intensity * pwfscale0 + pwfshift0, 0.5)).r;\\n                  gl_FragData[0] = vec4(tcolor, scalarOpacity * opacity);\\n                #endif\\n                &quot;)]).result;break;case 2:i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[&quot;vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);&quot;,&quot;float intensity = tcolor.r*cscale0 + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(intensity, 0.5)).rgb, pwfscale0*tcolor.g + pwfshift0);&quot;]).result;break;case 3:i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[&quot;vec4 tcolor = cscale0*texture2D(texture1, tcoordVCVSOutput.st) + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, opacity);&quot;]).result;break;default:i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[&quot;vec4 tcolor = cscale0*texture2D(texture1, tcoordVCVSOutput.st) + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, tcolor.a);&quot;]).result}t.haveSeenDepthRequest&&(i=td.substitute(i,&quot;//VTK::ZBuffer::Dec&quot;,&quot;uniform int depthRequest;&quot;).result,i=td.substitute(i,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float iz = floor(gl_FragCoord.z*65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result),n.Vertex=a,n.Fragment=i,e.replaceShaderClip(n,r,o),e.replaceShaderCoincidentOffset(n,r,o)},e.replaceShaderClip=(e,n,r)=>{let o=e.Vertex,a=e.Fragment;if(t.renderable.getNumberOfClippingPlanes()){let e=t.renderable.getNumberOfClippingPlanes();e>6&&(et(&quot;OpenGL has a limit of 6 clipping planes&quot;),e=6),o=td.substitute(o,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,&quot;uniform vec4 clipPlanes[6];&quot;,&quot;varying float clipDistancesVSOutput[6];&quot;]).result,o=td.substitute(o,&quot;//VTK::Clip::Impl&quot;,[&quot;for (int planeNum = 0; planeNum < 6; planeNum++)&quot;,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], vertexMC);&quot;,&quot;    }&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,&quot;varying float clipDistancesVSOutput[6];&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Impl&quot;,[&quot;for (int planeNum = 0; planeNum < 6; planeNum++)&quot;,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    if (clipDistancesVSOutput[planeNum] < 0.0) discard;&quot;,&quot;    }&quot;]).result}e.Vertex=o,e.Fragment=a},e.getNeedToRebuildShaders=(e,n,r)=>{const o=t.openGLTexture.getComponents(),a=r.getProperty().getIndependentComponents();let i=!1;return(!t.currentRenderPass&&t.lastRenderPassShaderReplacement||t.currentRenderPass&&t.currentRenderPass.getShaderReplacement()!==t.lastRenderPassShaderReplacement)&&(i=!0),!!(i||t.lastHaveSeenDepthRequest!==t.haveSeenDepthRequest||0===e.getProgram()?.getHandle()||e.getShaderSourceTime().getMTime()<t.renderable.getMTime()||e.getShaderSourceTime().getMTime()<t.currentInput.getMTime()||e.getShaderSourceTime().getMTime()<r.getProperty().getMTime()||t.lastTextureComponents!==o||t.lastIndependentComponents!==a)&&(t.lastHaveSeenDepthRequest=t.haveSeenDepthRequest,t.lastTextureComponents=o,t.lastIndependentComponents=a,!0)},e.updateShaders=(n,r,o)=>{if(t.lastBoundBO=n,e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};e.buildShaders(a,r,o);const i=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==n.getProgram()&&(n.setProgram(i),n.getVAO().releaseGraphicsResources()),n.getShaderSourceTime().modified()}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(n.getProgram());n.getVAO().bind(),e.setMapperShaderParameters(n,r,o),e.setCameraShaderParameters(n,r,o),e.setPropertyShaderParameters(n,r,o)},e.setMapperShaderParameters=(n,r,o)=>{n.getCABO().getElementCount()&&(t.VBOBuildTime>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())&&(n.getProgram().isAttributeUsed(&quot;vertexMC&quot;)&&(n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;vertexMC&quot;,n.getCABO().getVertexOffset(),n.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||Bf(&quot;Error setting vertexMC in shader VAO.&quot;)),n.getProgram().isAttributeUsed(&quot;tcoordMC&quot;)&&n.getCABO().getTCoordOffset()&&(n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;tcoordMC&quot;,n.getCABO().getTCoordOffset(),n.getCABO().getStride(),t.context.FLOAT,n.getCABO().getTCoordComponents(),t.context.FALSE)||Bf(&quot;Error setting tcoordMC in shader VAO.&quot;)),n.getAttributeUpdateTime().modified());const a=t.openGLTexture.getTextureUnit();n.getProgram().setUniformi(&quot;texture1&quot;,a);const i=t.openGLTexture.getComponents(),s=o.getProperty().getIndependentComponents();if(s)for(let e=0;e<i;e++)n.getProgram().setUniformf(`mix${e}`,o.getProperty().getComponentWeight(e));const l=t.openGLTexture.getShiftAndScale();for(let e=0;e<i;e++){let t=o.getProperty().getColorWindow(),r=o.getProperty().getColorLevel();const a=s?e:0,i=o.getProperty().getRGBTransferFunction(a);if(i&&o.getProperty().getUseLookupTableScalarRange()){const e=i.getRange();t=e[1]-e[0],r=.5*(e[1]+e[0])}const c=l.scale/t,u=(l.shift-r)/t+.5;n.getProgram().setUniformf(`cshift${e}`,u),n.getProgram().setUniformf(`cscale${e}`,c)}for(let e=0;e<i;e++){let t=1,r=0;const a=s?e:0,i=o.getProperty().getPiecewiseFunction(a);if(i){const e=i.getRange(),n=e[1]-e[0],o=.5*(e[0]+e[1]);t=l.scale/n,r=(l.shift-o)/n+.5}n.getProgram().setUniformf(`pwfshift${e}`,r),n.getProgram().setUniformf(`pwfscale${e}`,t)}if(t.haveSeenDepthRequest&&n.getProgram().setUniformi(&quot;depthRequest&quot;,t.renderDepth?1:0),n.getProgram().isUniformUsed(&quot;coffset&quot;)){const t=e.getCoincidentParameters(r,o);n.getProgram().setUniformf(&quot;coffset&quot;,t.offset),n.getProgram().isUniformUsed(&quot;cfactor&quot;)&&n.getProgram().setUniformf(&quot;cfactor&quot;,t.factor)}const c=t.colorTexture.getTextureUnit();n.getProgram().setUniformi(&quot;colorTexture1&quot;,c);const u=t.pwfTexture.getTextureUnit();if(n.getProgram().setUniformi(&quot;pwfTexture1&quot;,u),o.getProperty().getUseLabelOutline()){const e=t.labelOutlineThicknessTexture.getTextureUnit();n.getProgram().setUniformi(&quot;labelOutlineTexture1&quot;,e);const r=t.labelOutlineOpacityTexture.getTextureUnit();n.getProgram().setUniformi(&quot;labelOutlineOpacityTexture1&quot;,r)}if(t.renderable.getNumberOfClippingPlanes()){let e=t.renderable.getNumberOfClippingPlanes();e>6&&(et(&quot;OpenGL has a limit of 6 clipping planes&quot;),e=6);const r=n.getCABO().getCoordShiftAndScaleEnabled()?n.getCABO().getInverseShiftAndScaleMatrix():null,a=r?p(t.imagematinv,o.getMatrix()):o.getMatrix();r&&(h(a,a),b(a,a,r),h(a,a)),h(t.imagemat,t.currentInput.getIndexToWorld()),b(t.imagematinv,a,t.imagemat);const i=[];for(let n=0;n<e;n++){const e=[];t.renderable.getClippingPlaneInDataCoords(t.imagematinv,n,e);for(let t=0;t<4;t++)i.push(e[t])}n.getProgram().setUniformi(&quot;numClipPlanes&quot;,e),n.getProgram().setUniform4fv(&quot;clipPlanes&quot;,i)}},e.setCameraShaderParameters=(n,r,o)=>{const a=n.getProgram(),i=t.openGLImageSlice.getKeyMatrices(),s=t.currentInput,l=s.getIndexToWorld();b(t.imagemat,i.mcwc,l);const c=t.openGLCamera.getKeyMatrices(r);if(b(t.imagemat,c.wcpc,t.imagemat),n.getCABO().getCoordShiftAndScaleEnabled()){const e=n.getCABO().getInverseShiftAndScaleMatrix();b(t.imagemat,t.imagemat,e)}if(a.setUniformMatrix(&quot;MCPCMatrix&quot;,t.imagemat),!0===o.getProperty().getUseLabelOutline()){const n=s.getWorldToIndex(),o=s.getDimensions();let i=t.renderable.getClosestIJKAxis().ijkMode;i===Nf.NONE&&(i=Nf.K),a.setUniform3i(&quot;imageDimensions&quot;,o[0],o[1],o[2]),a.setUniformi(&quot;sliceAxis&quot;,i),a.setUniformMatrix(&quot;vWCtoIDX&quot;,n);const l=t.openGLCamera.getKeyMatrices(r);v(t.projectionToWorld,l.wcpc),t.openGLCamera.getKeyMatrices(r),a.setUniformMatrix(&quot;PCWCMatrix&quot;,t.projectionToWorld);const c=e.getRenderTargetSize();a.setUniformf(&quot;vpWidth&quot;,c[0]),a.setUniformf(&quot;vpHeight&quot;,c[1]);const u=e.getRenderTargetOffset();a.setUniformf(&quot;vpOffsetX&quot;,u[0]/c[0]),a.setUniformf(&quot;vpOffsetY&quot;,u[1]/c[1])}},e.setPropertyShaderParameters=(e,t,n)=>{const r=e.getProgram(),o=n.getProperty().getOpacity();r.setUniformf(&quot;opacity&quot;,o)},e.renderPieceStart=(n,r)=>{e.updateBufferObjects(n,r),t.lastBoundBO=null},e.renderPieceDraw=(n,r)=>{const o=t.context;t.openGLTexture.activate(),t.colorTexture.activate(),r.getProperty().getUseLabelOutline()&&(t.labelOutlineThicknessTexture.activate(),t.labelOutlineOpacityTexture.activate()),t.pwfTexture.activate(),t.tris.getCABO().getElementCount()&&(e.updateShaders(t.tris,n,r),o.drawArrays(o.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release()),t.openGLTexture.deactivate(),t.colorTexture.deactivate(),r.getProperty().getUseLabelOutline()&&(t.labelOutlineThicknessTexture.deactivate(),t.labelOutlineOpacityTexture.deactivate()),t.pwfTexture.deactivate()},e.renderPieceFinish=(e,t)=>{},e.renderPiece=(n,r)=>{e.invokeEvent({type:&quot;StartEvent&quot;}),t.renderable.update(),t.currentInput=t.renderable.getCurrentImage(),e.invokeEvent({type:&quot;EndEvent&quot;}),t.currentInput?(e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r)):Bf(&quot;No input!&quot;)},e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n)},e.getNeedToRebuildBufferObjects=(n,r)=>t.VBOBuildTime.getMTime()<e.getMTime()||t.VBOBuildTime.getMTime()<r.getMTime()||t.VBOBuildTime.getMTime()<t.renderable.getMTime()||t.VBOBuildTime.getMTime()<r.getProperty().getMTime()||t.VBOBuildTime.getMTime()<t.currentInput.getMTime()||!t.openGLTexture?.getHandle()||!t.colorTexture?.getHandle()||r.getProperty().getUseLabelOutline()&&(!t.labelOutlineThicknessTexture?.getHandle()||!t.labelOutlineOpacityTexture?.getHandle())||!t.pwfTexture?.getHandle(),e.buildBufferObjects=(n,r)=>{const o=t.currentInput;if(!o)return;const a=o.getPointData()&&o.getPointData().getScalars();if(!a)return;const i=a.getDataType(),s=a.getNumberOfComponents(),l=r.getProperty(),c=l.getInterpolationType(),u=l.getIndependentComponents(),d=u?s:1,p=u?2*d:1,f=[];for(let e=0;e<d;++e)f.push(l.getRGBTransferFunction(e));const g=wf(f,u,d),m=l.getRGBTransferFunction(),h=t._openGLRenderWindow.getGraphicsResourceForObject(m);if(h?.oglObject?.getHandle()&&h?.hash===g)t.colorTexture=h.oglObject;else{t.colorTexture=Pd.newInstance({resizable:!0}),t.colorTexture.setOpenGLRenderWindow(t._openGLRenderWindow);let n=t.renderable.getColorTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=new Uint8ClampedArray(n*p*3);if(c===Pf.NEAREST?(t.colorTexture.setMinificationFilter(ud.NEAREST),t.colorTexture.setMagnificationFilter(ud.NEAREST)):(t.colorTexture.setMinificationFilter(ud.LINEAR),t.colorTexture.setMagnificationFilter(ud.LINEAR)),m){const e=new Float32Array(3*n);for(let t=0;t<d;t++){const o=l.getRGBTransferFunction(t),a=o.getRange();if(o.getTable(a[0],a[1],n,e,1),u)for(let o=0;o<3*n;o++)r[t*n*6+o]=255*e[o],r[t*n*6+o+3*n]=255*e[o];else for(let o=0;o<3*n;o++)r[t*n*6+o]=255*e[o]}t.colorTexture.resetFormatAndType(),t.colorTexture.create2DFromRaw({width:n,height:p,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r})}else{for(let e=0;e<3*n;++e)r[e]=255*e/(3*(n-1)),r[e+1]=255*e/(3*(n-1)),r[e+2]=255*e/(3*(n-1));t.colorTexture.create2DFromRaw({width:n,height:1,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r})}m&&(t._openGLRenderWindow.setGraphicsResourceForObject(m,t.colorTexture,g),m!==t._colorTransferFunc&&(t._openGLRenderWindow.registerGraphicsResourceUser(m,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._colorTransferFunc,e)),t._colorTransferFunc=m)}const v=[];for(let e=0;e<d;++e)v.push(l.getPiecewiseFunction(e));const T=wf(v,u,d),y=l.getPiecewiseFunction(),b=t._openGLRenderWindow.getGraphicsResourceForObject(y);if(b?.oglObject?.getHandle()&&b?.hash===T)t.pwfTexture=b.oglObject;else{let n=t.renderable.getOpacityTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=n*p,o=new Uint8ClampedArray(r);if(t.pwfTexture=Pd.newInstance({resizable:!0}),t.pwfTexture.setOpenGLRenderWindow(t._openGLRenderWindow),c===Pf.NEAREST?(t.pwfTexture.setMinificationFilter(ud.NEAREST),t.pwfTexture.setMagnificationFilter(ud.NEAREST)):(t.pwfTexture.setMinificationFilter(ud.LINEAR),t.pwfTexture.setMagnificationFilter(ud.LINEAR)),y){const e=new Float32Array(r),o=new Float32Array(n);for(let t=0;t<d;++t){const r=l.getPiecewiseFunction(t);if(null===r)e.fill(1);else{const a=r.getRange();if(r.getTable(a[0],a[1],n,o,1),u)for(let r=0;r<n;r++)e[t*n*2+r]=o[r],e[t*n*2+r+n]=o[r];else for(let r=0;r<n;r++)e[t*n*2+r]=o[r]}}t.pwfTexture.resetFormatAndType(),t.pwfTexture.create2DFromRaw({width:n,height:p,numComps:1,dataType:cs.FLOAT,data:e})}else o.fill(255),t.pwfTexture.create2DFromRaw({width:n,height:1,numComps:1,dataType:cs.UNSIGNED_CHAR,data:o});y&&(t._openGLRenderWindow.setGraphicsResourceForObject(y,t.pwfTexture,T),y!==t._pwFunc&&(t._openGLRenderWindow.registerGraphicsResourceUser(y,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._pwFunc,e)),t._pwFunc=y)}r.getProperty().getUseLabelOutline()&&(e.updatelabelOutlineThicknessTexture(r),e.updateLabelOutlineOpacityTexture(r));const{ijkMode:x}=t.renderable.getClosestIJKAxis();let C=t.renderable.getSlice();x!==t.renderable.getSlicingMode()&&(C=t.renderable.getSliceAtPosition(C));const S=t.renderable.isA(&quot;vtkImageArrayMapper&quot;)?t.renderable.getSubSlice():Math.round(C),A=o.getExtent();let I;x===Nf.I&&(I=S-A[0]),x===Nf.J&&(I=S-A[2]),x!==Nf.K&&x!==Nf.NONE||(I=S-A[4]);const w=`${C}A${o.getMTime()}A${a.getMTime()}B${e.getMTime()}C${t.renderable.getSlicingMode()}D${r.getProperty().getInterpolationType()}`;if(t.VBOBuildString!==w){const e=o.getDimensions();t.openGLTexture||(t.openGLTexture=Pd.newInstance({resizable:!0})),t.openGLTexture.setOpenGLRenderWindow(t._openGLRenderWindow),t.openGLTexture.setOglNorm16Ext(t.context.getExtension(&quot;EXT_texture_norm16&quot;)),c===Pf.NEAREST?(new Set([1,3,4]).has(s)&&i===cs.UNSIGNED_CHAR&&!u?(t.openGLTexture.setGenerateMipmap(!0),t.openGLTexture.setMinificationFilter(ud.NEAREST)):t.openGLTexture.setMinificationFilter(ud.NEAREST),t.openGLTexture.setMagnificationFilter(ud.NEAREST)):(4!==s||i!==cs.UNSIGNED_CHAR||u?t.openGLTexture.setMinificationFilter(ud.LINEAR):(t.openGLTexture.setGenerateMipmap(!0),t.openGLTexture.setMinificationFilter(ud.LINEAR_MIPMAP_LINEAR)),t.openGLTexture.setMagnificationFilter(ud.LINEAR)),t.openGLTexture.setWrapS(cd.CLAMP_TO_EDGE),t.openGLTexture.setWrapT(cd.CLAMP_TO_EDGE);const n=e[0]*e[1]*s,r=new Float32Array(12),l=new Float32Array(8);for(let e=0;e<4;e++)l[2*e]=e%2?1:0,l[2*e+1]=e>1?1:0;const d=[Nf.X,Nf.Y,Nf.Z].includes(t.renderable.getSlicingMode())?C:S,p=o.getSpatialExtent(),f=a.getData();let g=null;if(x===Nf.I){g=new f.constructor(e[2]*e[1]*s);let t=0;for(let n=0;n<e[2];n++)for(let r=0;r<e[1];r++){let o=(I+r*e[0]+n*e[0]*e[1])*s;t=(n*e[1]+r)*s;const a=o+s;for(;o<a;)g[t++]=f[o++]}e[0]=e[1],e[1]=e[2],r[0]=d,r[1]=p[2],r[2]=p[4],r[3]=d,r[4]=p[3],r[5]=p[4],r[6]=d,r[7]=p[2],r[8]=p[5],r[9]=d,r[10]=p[3],r[11]=p[5]}else if(x===Nf.J){g=new f.constructor(e[2]*e[0]*s);let t=0;for(let n=0;n<e[2];n++)for(let r=0;r<e[0];r++){let o=(r+I*e[0]+n*e[0]*e[1])*s;t=(n*e[0]+r)*s;const a=o+s;for(;o<a;)g[t++]=f[o++]}e[1]=e[2],r[0]=p[0],r[1]=d,r[2]=p[4],r[3]=p[1],r[4]=d,r[5]=p[4],r[6]=p[0],r[7]=d,r[8]=p[5],r[9]=p[1],r[10]=d,r[11]=p[5]}else x===Nf.K||x===Nf.NONE?(g=f.subarray(I*n,(I+1)*n),r[0]=p[0],r[1]=p[2],r[2]=d,r[3]=p[1],r[4]=p[2],r[5]=d,r[6]=p[0],r[7]=p[3],r[8]=d,r[9]=p[1],r[10]=p[3],r[11]=d):Bf(&quot;Reformat slicing not yet supported.&quot;);const m=a.getRanges();t.openGLTexture.resetFormatAndType(),t.openGLTexture.create2DFilterableFromRaw({width:e[0],height:e[1],numComps:s,dataType:a.getDataType(),data:g,preferSizeOverAccuracy:!!t.renderable.getPreferSizeOverAccuracy?.(),ranges:m}),t.openGLTexture.activate(),t.openGLTexture.sendParameters(),t.openGLTexture.deactivate();const h=xs.newInstance({numberOfComponents:3,values:r});h.setName(&quot;points&quot;);const v=xs.newInstance({numberOfComponents:2,values:l});v.setName(&quot;tcoords&quot;);const T=new Uint16Array(8);T[0]=3,T[1]=0,T[2]=1,T[3]=3,T[4]=3,T[5]=0,T[6]=3,T[7]=2;const y=xs.newInstance({numberOfComponents:1,values:T});t.tris.getCABO().createVBO(y,&quot;polys&quot;,Zi.SURFACE,{points:h,tcoords:v,cellOffset:0}),t.VBOBuildTime.modified(),t.VBOBuildString=w}},e.updateLabelOutlineOpacityTexture=n=>{let r=n.getProperty().getLabelOutlineOpacity();&quot;number&quot;==typeof r&&(r=t._cachedLabelOutlineOpacityObj?.[0]===r?t._cachedLabelOutlineOpacityObj:[r],t._cachedLabelOutlineOpacityObj=r);const o=t._openGLRenderWindow.getGraphicsResourceForObject(r),a=`${r.join(&quot;-&quot;)}`;if(o?.oglObject?.getHandle()&&o?.hash===a)t.labelOutlineOpacityTexture=o.oglObject;else{let n=t.renderable.getLabelOutlineTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const o=1,i=new Float32Array(n*o);for(let e=0;e<n;++e)i[e]=r[e]??r[0];t.labelOutlineOpacityTexture=Pd.newInstance({resizable:!1}),t.labelOutlineOpacityTexture.setOpenGLRenderWindow(t._openGLRenderWindow),t.labelOutlineOpacityTexture.resetFormatAndType(),t.labelOutlineOpacityTexture.setMinificationFilter(ud.NEAREST),t.labelOutlineOpacityTexture.setMagnificationFilter(ud.NEAREST),t.labelOutlineOpacityTexture.create2DFromRaw({width:n,height:o,numComps:1,dataType:cs.FLOAT,data:i}),r&&(t._openGLRenderWindow.setGraphicsResourceForObject(r,t.labelOutlineOpacityTexture,a),r!==t._labelOutlineOpacity&&(t._openGLRenderWindow.registerGraphicsResourceUser(r,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._labelOutlineOpacity,e)),t._labelOutlineOpacity=r)}},e.updatelabelOutlineThicknessTexture=n=>{const r=n.getProperty().getLabelOutlineThicknessByReference(),o=t._openGLRenderWindow.getGraphicsResourceForObject(r),a=`${r.join(&quot;-&quot;)}`;if(o?.oglObject?.getHandle()&&o?.hash===a)t.labelOutlineThicknessTexture=o.oglObject;else{let n=t.renderable.getLabelOutlineTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const o=1,i=new Uint8Array(n*o);for(let e=0;e<n;++e){const t=void 0!==r[e]?r[e]:r[0];i[e]=t}t.labelOutlineThicknessTexture=Pd.newInstance({resizable:!1}),t.labelOutlineThicknessTexture.setOpenGLRenderWindow(t._openGLRenderWindow),t.labelOutlineThicknessTexture.resetFormatAndType(),t.labelOutlineThicknessTexture.setMinificationFilter(ud.NEAREST),t.labelOutlineThicknessTexture.setMagnificationFilter(ud.NEAREST),t.labelOutlineThicknessTexture.create2DFromRaw({width:n,height:o,numComps:1,dataType:cs.UNSIGNED_CHAR,data:i}),r&&(t._openGLRenderWindow.setGraphicsResourceForObject(r,t.labelOutlineThicknessTexture,a),r!==t._labelOutlineThicknessArray&&(t._openGLRenderWindow.registerGraphicsResourceUser(r,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._labelOutlineThicknessArray,e)),t._labelOutlineThicknessArray=r)}},e.getRenderTargetSize=()=>{if(t._useSmallViewport)return[t._smallViewportWidth,t._smallViewportHeight];const{usize:e,vsize:n}=t._openGLRenderer.getTiledSizeAndOrigin();return[e,n]},e.getRenderTargetOffset=()=>{const{lowerLeftU:e,lowerLeftV:n}=t._openGLRenderer.getTiledSizeAndOrigin();return[e,n]},e.delete=Et((()=>{t._openGLRenderWindow&&n(t._openGLRenderWindow)}),e.delete)}(e,t)}),&quot;vtkOpenGLImageMapper&quot;);Jt(&quot;vtkAbstractImageMapper&quot;,kf);const Gf=0,Uf=1,zf=2,{vtkErrorMacro:Wf}=Wt,Hf={currentRenderPass:null,volumeTexture:null,colorTexture:null,pwfTexture:null,tris:null,lastHaveSeenDepthRequest:!1,haveSeenDepthRequest:!1,lastTextureComponents:0,lastIndependentComponents:0,imagemat:null,imagematinv:null};const jf=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Hf,n),qt.extend(e,t,n),Ed(e,t,n),Wt.algo(e,t,2,0),t.tris=ld.newInstance(),t.volumeTexture=null,t.colorTexture=null,t.pwfTexture=null,t.imagemat=m(new Float64Array(16)),t.imagematinv=m(new Float64Array(16)),t.VBOBuildTime={},Wt.obj(t.VBOBuildTime,{mtime:0}),function(e,t){function n(n){[t._scalars,t._colorTransferFunc,t._pwFunc].forEach((t=>n.unregisterGraphicsResourceUser(t,e)))}t.classHierarchy.push(&quot;vtkOpenGLImageCPRMapper&quot;),e.buildPass=r=>{if(r){t.currentRenderPass=null,t.openGLImageSlice=e.getFirstAncestorOfType(&quot;vtkOpenGLImageSlice&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;);const r=t._openGLRenderWindow;t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),r&&!r.isDeleted()&&r!==t._openGLRenderWindow&&n(r),t.context=t._openGLRenderWindow.getContext(),t.openGLCamera=t._openGLRenderer.getViewNodeFor(t._openGLRenderer.getRenderable().getActiveCamera()),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow)}},e.opaquePass=(n,r)=>{n&&(t.currentRenderPass=r,e.render())},e.opaqueZBufferPass=n=>{n&&(t.haveSeenDepthRequest=!0,t.renderDepth=!0,e.render(),t.renderDepth=!1)},e.getCoincidentParameters=(e,n)=>t.renderable.getResolveCoincidentTopology()===gl.PolygonOffset?t.renderable.getCoincidentTopologyPolygonOffsetParameters():null,e.render=()=>{const n=t.openGLImageSlice.getRenderable(),r=t._openGLRenderer.getRenderable();e.renderPiece(r,n)},e.renderPiece=(n,r)=>{e.invokeEvent({type:&quot;StartEvent&quot;}),t.renderable.update(),e.invokeEvent({type:&quot;EndEvent&quot;}),t.renderable.preRenderCheck()&&(t.currentImageDataInput=t.renderable.getInputData(0),t.currentCenterlineInput=t.renderable.getOrientedCenterline(),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r))},e.renderPieceStart=(t,n)=>{e.updateBufferObjects(t,n)},e.renderPieceDraw=(n,r)=>{const o=t.context;t.volumeTexture.activate(),t.colorTexture.activate(),t.pwfTexture.activate(),t.tris.getCABO().getElementCount()&&(e.updateShaders(t.tris,n,r),o.drawArrays(o.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release()),t.volumeTexture.deactivate(),t.colorTexture.deactivate(),t.pwfTexture.deactivate()},e.renderPieceFinish=(e,t)=>{},e.updateBufferObjects=(n,r)=>{e.getNeedToRebuildBufferObjects(n,r)&&e.buildBufferObjects(n,r),r.getProperty().getInterpolationType()===Pf.NEAREST?(t.volumeTexture.setMinificationFilter(ud.NEAREST),t.volumeTexture.setMagnificationFilter(ud.NEAREST),t.colorTexture.setMinificationFilter(ud.NEAREST),t.colorTexture.setMagnificationFilter(ud.NEAREST),t.pwfTexture.setMinificationFilter(ud.NEAREST),t.pwfTexture.setMagnificationFilter(ud.NEAREST)):(t.volumeTexture.setMinificationFilter(ud.LINEAR),t.volumeTexture.setMagnificationFilter(ud.LINEAR),t.colorTexture.setMinificationFilter(ud.LINEAR),t.colorTexture.setMagnificationFilter(ud.LINEAR),t.pwfTexture.setMinificationFilter(ud.LINEAR),t.pwfTexture.setMagnificationFilter(ud.LINEAR))},e.getNeedToRebuildBufferObjects=(n,r)=>{const o=t.VBOBuildTime.getMTime();return o<e.getMTime()||o<t.renderable.getMTime()||o<r.getMTime()||o<t.currentImageDataInput.getMTime()||o<t.currentCenterlineInput.getMTime()||!t.volumeTexture?.getHandle()},e.buildBufferObjects=(n,r)=>{const o=t.currentImageDataInput,a=t.currentCenterlineInput,i=r.getProperty(),s=o?.getPointData()?.getScalars();if(!s)return;const l=t._openGLRenderWindow.getGraphicsResourceForObject(s),c=Of(0,s),u=!l?.oglObject?.getHandle()||l?.hash!==c,d=i.getUpdatedExtents(),p=!!d.length;if(u){t.volumeTexture=Pd.newInstance(),t.volumeTexture.setOpenGLRenderWindow(t._openGLRenderWindow);const n=o.getDimensions();t.volumeTexture.setOglNorm16Ext(t.context.getExtension(&quot;EXT_texture_norm16&quot;)),t.volumeTexture.resetFormatAndType(),t.volumeTexture.create3DFilterableFromDataArray({width:n[0],height:n[1],depth:n[2],dataArray:s,preferSizeOverAccuracy:t.renderable.getPreferSizeOverAccuracy()}),t._openGLRenderWindow.setGraphicsResourceForObject(s,t.volumeTexture,c),s!==t._scalars&&(t._openGLRenderWindow.registerGraphicsResourceUser(s,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._scalars,e)),t._scalars=s}else t.volumeTexture=l.oglObject;if(p){i.setUpdatedExtents([]);const e=o.getDimensions();t.volumeTexture.create3DFilterableFromDataArray({width:e[0],height:e[1],depth:e[2],dataArray:s,updatedExtents:d})}const f=s.getNumberOfComponents(),g=r.getProperty(),m=g.getIndependentComponents(),h=m?f:1,v=m?2*h:1,T=[];for(let e=0;e<h;++e)T.push(g.getRGBTransferFunction(e));const y=wf(T,m,h),b=g.getRGBTransferFunction(),x=t._openGLRenderWindow.getGraphicsResourceForObject(b);if(x?.oglObject?.getHandle()&&x?.hash===y)t.colorTexture=x.oglObject;else{let n=t.renderable.getColorTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=new Uint8ClampedArray(n*v*3);if(t.colorTexture=Pd.newInstance(),t.colorTexture.setOpenGLRenderWindow(t._openGLRenderWindow),b){const e=new Float32Array(3*n);for(let t=0;t<h;t++){const o=g.getRGBTransferFunction(t),a=o.getRange();if(o.getTable(a[0],a[1],n,e,1),m)for(let o=0;o<3*n;o++)r[t*n*6+o]=255*e[o],r[t*n*6+o+3*n]=255*e[o];else for(let o=0;o<3*n;o++)r[t*n*6+o]=255*e[o]}t.colorTexture.resetFormatAndType(),t.colorTexture.create2DFromRaw({width:n,height:v,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r})}else{for(let e=0;e<3*n;++e)r[e]=255*e/(3*(n-1)),r[e+1]=255*e/(3*(n-1)),r[e+2]=255*e/(3*(n-1));t.colorTexture.resetFormatAndType(),t.colorTexture.create2DFromRaw({width:n,height:1,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r})}b&&(t._openGLRenderWindow.setGraphicsResourceForObject(b,t.colorTexture,y),b!==t._colorTransferFunc&&(t._openGLRenderWindow.registerGraphicsResourceUser(b,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._colorTransferFunc,e)),t._colorTransferFunc=b)}const C=[];for(let e=0;e<h;++e)C.push(g.getPiecewiseFunction(e));const S=wf(C,m,h),A=g.getPiecewiseFunction(),I=t._openGLRenderWindow.getGraphicsResourceForObject(A);if(I?.oglObject?.getHandle()&&I?.hash===S)t.pwfTexture=I.oglObject;else{let n=t.renderable.getOpacityTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=n*v,o=new Uint8ClampedArray(r);if(t.pwfTexture=Pd.newInstance(),t.pwfTexture.setOpenGLRenderWindow(t._openGLRenderWindow),A){const e=new Float32Array(r),o=new Float32Array(n);for(let t=0;t<h;++t){const r=g.getPiecewiseFunction(t);if(null===r)e.fill(1);else{const a=r.getRange();if(r.getTable(a[0],a[1],n,o,1),m)for(let r=0;r<n;r++)e[t*n*2+r]=o[r],e[t*n*2+r+n]=o[r];else for(let r=0;r<n;r++)e[t*n*2+r]=o[r]}}t.pwfTexture.resetFormatAndType(),t.pwfTexture.create2DFromRaw({width:n,height:v,numComps:1,dataType:cs.FLOAT,data:e})}else o.fill(255),t.pwfTexture.resetFormatAndType(),t.pwfTexture.create2DFromRaw({width:n,height:1,numComps:1,dataType:cs.UNSIGNED_CHAR,data:o});A&&(t._openGLRenderWindow.setGraphicsResourceForObject(A,t.pwfTexture,S),A!==t._pwFunc&&(t._openGLRenderWindow.registerGraphicsResourceUser(A,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._pwFunc,e)),t._pwFunc=A)}if(t.VBOBuildTime.getMTime()<t.renderable.getMTime()||t.VBOBuildTime.getMTime()<a.getMTime()){const e=a.getNumberOfPoints(),n=e<=1?0:e-1,r=a.getDistancesToFirstPoint(),o=t.renderable.getHeight(),i=4*n,s=new Float32Array(3*i),l=t.renderable.getWidth();for(let e=0,t=0;e<n;++e)s.set([0,o-r[e],0],t),t+=3,s.set([l,o-r[e],0],t),t+=3,s.set([l,o-r[e+1],0],t),t+=3,s.set([0,o-r[e+1],0],t),t+=3;const c=xs.newInstance({numberOfComponents:3,values:s});c.setName(&quot;points&quot;);const u=new Uint16Array(5*n);for(let e=0,t=0,r=0;e<n;++e)u.set([4,r+3,r+2,r+1,r],t),t+=5,r+=4;const d=xs.newInstance({numberOfComponents:1,values:u}),p=a.getPoints(),f=new Float32Array(3*i),g=new Array(3),m=new Array(3);for(let e=0,t=0;e<n;++e)p.getPoint(e,g),p.getPoint(e+1,m),f.set(g,t),t+=3,f.set(g,t),t+=3,f.set(m,t),t+=3,f.set(m,t),t+=3;const h=xs.newInstance({numberOfComponents:3,values:f,name:&quot;centerlinePosition&quot;}),v=new Float32Array(i);for(let e=0,t=0;e<n;++e)v.set([0,1,3,2],t),t+=4;const T=[h,xs.newInstance({numberOfComponents:1,values:v,name:&quot;quadIndex&quot;})];if(!t.renderable.getUseUniformOrientation()){const e=t.renderable.getOrientedCenterline().getOrientations()??[],r=new Float32Array(4*i),o=new Float32Array(4*i);for(let t=0;t<n;++t){const n=e[t],a=e[t+1];for(let e=0;e<4;++e){const i=4*(e+4*t);r.set(n,i),o.set(a,i)}}const a=xs.newInstance({numberOfComponents:4,values:r,name:&quot;centerlineTopOrientation&quot;}),s=xs.newInstance({numberOfComponents:4,values:o,name:&quot;centerlineBotOrientation&quot;});T.push(a,s)}t.tris.getCABO().createVBO(d,&quot;polys&quot;,Zi.SURFACE,{points:c,customAttributes:T}),t.VBOBuildTime.modified()}},e.getNeedToRebuildShaders=(e,n,r)=>{const o=t.volumeTexture.getComponents(),a=r.getProperty().getIndependentComponents(),i=!!t.renderable.getCenterPoint(),s=t.renderable.getUseUniformOrientation(),l=t.renderable.isProjectionEnabled()&&t.renderable.getProjectionMode();return(0===e.getProgram()||t.lastUseCenterPoint!==i||t.lastUseUniformOrientation!==s||t.lastProjectionMode!==l||t.lastHaveSeenDepthRequest!==t.haveSeenDepthRequest||t.lastTextureComponents!==o||t.lastIndependentComponents!==a)&&(t.lastUseCenterPoint=i,t.lastUseUniformOrientation=s,t.lastProjectionMode=l,t.lastHaveSeenDepthRequest=t.haveSeenDepthRequest,t.lastTextureComponents=o,t.lastIndependentComponents=a,!0)},e.buildShaders=(t,n,r)=>{e.getShaderTemplate(t,n,r),e.replaceShaderValues(t,n,r)},e.replaceShaderValues=(n,r,o)=>{let a=n.Vertex,i=n.Fragment;const s=[&quot;vec3 applyQuaternionToVec(vec4 q, vec3 v) {&quot;,&quot;  float uvx = q.y * v.z - q.z * v.y;&quot;,&quot;  float uvy = q.z * v.x - q.x * v.z;&quot;,&quot;  float uvz = q.x * v.y - q.y * v.x;&quot;,&quot;  float uuvx = q.y * uvz - q.z * uvy;&quot;,&quot;  float uuvy = q.z * uvx - q.x * uvz;&quot;,&quot;  float uuvz = q.x * uvy - q.y * uvx;&quot;,&quot;  float w2 = q.w * 2.0;&quot;,&quot;  uvx *= w2;&quot;,&quot;  uvy *= w2;&quot;,&quot;  uvz *= w2;&quot;,&quot;  uuvx *= 2.0;&quot;,&quot;  uuvy *= 2.0;&quot;,&quot;  uuvz *= 2.0;&quot;,&quot;  return vec3(v.x + uvx + uuvx, v.y + uvy + uuvy, v.z + uvz + uuvz);&quot;,&quot;}&quot;];a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;  gl_Position = MCPCMatrix * vertexMC;&quot;]).result;const l=[&quot;attribute vec3 centerlinePosition;&quot;,&quot;attribute float quadIndex;&quot;,&quot;uniform float width;&quot;,&quot;out vec2 quadOffsetVSOutput;&quot;,&quot;out vec3 centerlinePosVSOutput;&quot;],c=t.renderable.isProjectionEnabled(),u=t.renderable.getUseUniformOrientation();u?(l.push(&quot;out vec3 samplingDirVSOutput;&quot;,&quot;uniform vec4 centerlineOrientation;&quot;,&quot;uniform vec3 tangentDirection;&quot;,...s),c&&l.push(&quot;out vec3 projectionDirVSOutput;&quot;,&quot;uniform vec3 bitangentDirection;&quot;)):l.push(&quot;out vec4 centerlineTopOrientationVSOutput;&quot;,&quot;out vec4 centerlineBotOrientationVSOutput;&quot;,&quot;attribute vec4 centerlineTopOrientation;&quot;,&quot;attribute vec4 centerlineBotOrientation;&quot;),a=td.substitute(a,&quot;//VTK::Color::Dec&quot;,l).result;const d=[&quot;quadOffsetVSOutput = vec2(width * (mod(quadIndex, 2.0) == 0.0 ? -0.5 : 0.5), quadIndex > 1.0 ? 0.0 : 1.0);&quot;,&quot;centerlinePosVSOutput = centerlinePosition;&quot;];u?(d.push(&quot;samplingDirVSOutput = applyQuaternionToVec(centerlineOrientation, tangentDirection);&quot;),c&&d.push(&quot;projectionDirVSOutput = applyQuaternionToVec(centerlineOrientation, bitangentDirection);&quot;)):d.push(&quot;centerlineTopOrientationVSOutput = centerlineTopOrientation;&quot;,&quot;centerlineBotOrientationVSOutput = centerlineBotOrientation;&quot;),a=td.substitute(a,&quot;//VTK::Color::Impl&quot;,d).result;const p=t.volumeTexture.getComponents(),f=o.getProperty().getIndependentComponents();let g=[&quot;uniform mat4 MCTCMatrix; // Model coordinates to texture coordinates&quot;,&quot;in vec2 quadOffsetVSOutput;&quot;,&quot;in vec3 centerlinePosVSOutput;&quot;,&quot;uniform highp sampler3D volumeTexture;&quot;,&quot;uniform sampler2D colorTexture1;&quot;,&quot;uniform sampler2D pwfTexture1;&quot;,&quot;uniform float opacity;&quot;,&quot;uniform vec4 backgroundColor;&quot;,&quot;uniform float cshift0;&quot;,&quot;uniform float cscale0;&quot;,&quot;uniform float pwfshift0;&quot;,&quot;uniform float pwfscale0;&quot;];c&&g.push(&quot;uniform vec3 volumeSizeMC;&quot;,&quot;uniform int projectionSlabNumberOfSamples;&quot;,&quot;uniform float projectionConstantOffset;&quot;,&quot;uniform float projectionStepLength;&quot;),u?(g.push(&quot;in vec3 samplingDirVSOutput;&quot;),c&&g.push(&quot;in vec3 projectionDirVSOutput;&quot;)):(g.push(&quot;uniform vec3 tangentDirection;&quot;,&quot;in vec4 centerlineTopOrientationVSOutput;&quot;,&quot;in vec4 centerlineBotOrientationVSOutput;&quot;,...s),c&&g.push(&quot;uniform vec3 bitangentDirection;&quot;));const m=t.renderable.getCenterPoint();if(m&&g.push(&quot;uniform vec3 globalCenterPoint;&quot;),f){for(let e=1;e<p;e++)g=g.concat([`uniform float cshift${e};`,`uniform float cscale${e};`,`uniform float pwfshift${e};`,`uniform float pwfscale${e};`]);switch(p){case 1:g=g.concat([&quot;uniform float mix0;&quot;,&quot;#define height0 0.5&quot;]);break;case 2:g=g.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;#define height0 0.25&quot;,&quot;#define height1 0.75&quot;]);break;case 3:g=g.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;#define height0 0.17&quot;,&quot;#define height1 0.5&quot;,&quot;#define height2 0.83&quot;]);break;case 4:g=g.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;uniform float mix3;&quot;,&quot;#define height0 0.125&quot;,&quot;#define height1 0.375&quot;,&quot;#define height2 0.625&quot;,&quot;#define height3 0.875&quot;]);break;default:Wf(&quot;Unsupported number of independent coordinates.&quot;)}}i=td.substitute(i,&quot;//VTK::TCoord::Dec&quot;,g).result;let h=[];if(u?(h.push(&quot;vec3 samplingDirection = samplingDirVSOutput;&quot;),c&&h.push(&quot;vec3 projectionDirection = projectionDirVSOutput;&quot;)):(h.push(&quot;vec4 q0 = centerlineBotOrientationVSOutput;&quot;,&quot;vec4 q1 = centerlineTopOrientationVSOutput;&quot;,&quot;float qCosAngle = dot(q0, q1);&quot;,&quot;vec4 interpolatedOrientation;&quot;,&quot;if (qCosAngle > 0.999 || qCosAngle < -0.999) {&quot;,&quot;  // Use LERP instead of SLERP when the two quaternions are close or opposite&quot;,&quot;  interpolatedOrientation = normalize(mix(q0, q1, quadOffsetVSOutput.y));&quot;,&quot;} else {&quot;,&quot;  float omega = acos(qCosAngle);&quot;,&quot;  interpolatedOrientation = normalize(sin((1.0 - quadOffsetVSOutput.y) * omega) * q0 + sin(quadOffsetVSOutput.y * omega) * q1);&quot;,&quot;}&quot;,&quot;vec3 samplingDirection = applyQuaternionToVec(interpolatedOrientation, tangentDirection);&quot;),c&&h.push(&quot;vec3 projectionDirection = applyQuaternionToVec(interpolatedOrientation, bitangentDirection);&quot;)),m?h.push(&quot;float baseOffset = dot(samplingDirection, globalCenterPoint - centerlinePosVSOutput);&quot;,&quot;float horizontalOffset = quadOffsetVSOutput.x + baseOffset;&quot;):h.push(&quot;float horizontalOffset = quadOffsetVSOutput.x;&quot;),h.push(&quot;vec3 volumePosMC = centerlinePosVSOutput + horizontalOffset * samplingDirection;&quot;,&quot;vec3 volumePosTC = (MCTCMatrix * vec4(volumePosMC, 1.0)).xyz;&quot;,&quot;if (any(lessThan(volumePosTC, vec3(0.0))) || any(greaterThan(volumePosTC, vec3(1.0))))&quot;,&quot;{&quot;,&quot;  // set the background color and exit&quot;,&quot;  gl_FragData[0] = backgroundColor;&quot;,&quot;  return;&quot;,&quot;}&quot;),c){const e=t.renderable.getProjectionMode();switch(e===Uf?h.push(&quot;const vec4 initialProjectionTextureValue = vec4(1.0);&quot;):h.push(&quot;const vec4 initialProjectionTextureValue = vec4(0.0);&quot;),h.push(&quot;vec3 projectionScaledDirection = projectionDirection / volumeSizeMC;&quot;,&quot;vec3 projectionStep = projectionStepLength * projectionScaledDirection;&quot;,&quot;vec3 projectionStartPosition = volumePosTC + projectionConstantOffset * projectionScaledDirection;&quot;,&quot;vec4 tvalue = initialProjectionTextureValue;&quot;,&quot;for (int projectionSampleIdx = 0; projectionSampleIdx < projectionSlabNumberOfSamples; ++projectionSampleIdx) {&quot;,&quot;  vec3 projectionSamplePosition = projectionStartPosition + float(projectionSampleIdx) * projectionStep;&quot;,&quot;  vec4 sampledTextureValue = texture(volumeTexture, projectionSamplePosition);&quot;),e){case Gf:h.push(&quot;  tvalue = max(tvalue, sampledTextureValue);&quot;);break;case Uf:h.push(&quot;  tvalue = min(tvalue, sampledTextureValue);&quot;);break;default:h.push(&quot;  tvalue = tvalue + sampledTextureValue;&quot;)}h.push(&quot;}&quot;),e===zf&&h.push(&quot;tvalue = tvalue / float(projectionSlabNumberOfSamples);&quot;)}else h.push(&quot;vec4 tvalue = texture(volumeTexture, volumePosTC);&quot;);if(f){const e=[&quot;r&quot;,&quot;g&quot;,&quot;b&quot;,&quot;a&quot;];for(let t=0;t<p;++t)h=h.concat([`vec3 tcolor${t} = mix${t} * texture2D(colorTexture1, vec2(tvalue.${e[t]} * cscale${t} + cshift${t}, height${t})).rgb;`,`float compWeight${t} = mix${t} * texture2D(pwfTexture1, vec2(tvalue.${e[t]} * pwfscale${t} + pwfshift${t}, height${t})).r;`]);switch(p){case 1:h=h.concat([&quot;gl_FragData[0] = vec4(tcolor0.rgb, compWeight0 * opacity);&quot;]);break;case 2:h=h.concat([&quot;float weightSum = compWeight0 + compWeight1;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum))), opacity);&quot;]);break;case 3:h=h.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum))), opacity);&quot;]);break;case 4:h=h.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2 + compWeight3;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum)) + (tcolor3.rgb * (compWeight3 / weightSum))), opacity);&quot;]);break;default:Wf(&quot;Unsupported number of independent coordinates.&quot;)}}else switch(p){case 1:h=h.concat([&quot;// Dependent components&quot;,&quot;float intensity = tvalue.r;&quot;,&quot;vec3 tcolor = texture2D(colorTexture1, vec2(intensity * cscale0 + cshift0, 0.5)).rgb;&quot;,&quot;float scalarOpacity = texture2D(pwfTexture1, vec2(intensity * pwfscale0 + pwfshift0, 0.5)).r;&quot;,&quot;gl_FragData[0] = vec4(tcolor, scalarOpacity * opacity);&quot;]);break;case 2:h=h.concat([&quot;float intensity = tvalue.r*cscale0 + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(intensity, 0.5)).rgb, pwfscale0*tvalue.g + pwfshift0);&quot;]);break;case 3:h=h.concat([&quot;vec4 tcolor = cscale0*tvalue + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, opacity);&quot;]);break;default:h=h.concat([&quot;vec4 tcolor = cscale0*tvalue + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, tcolor.a);&quot;])}i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,h).result,t.haveSeenDepthRequest&&(i=td.substitute(i,&quot;//VTK::ZBuffer::Dec&quot;,&quot;uniform int depthRequest;&quot;).result,i=td.substitute(i,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float iz = floor(gl_FragCoord.z*65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result),n.Vertex=a,n.Fragment=i,e.replaceShaderClip(n,r,o),e.replaceShaderCoincidentOffset(n,r,o)},e.replaceShaderClip=(e,n,r)=>{let o=e.Vertex,a=e.Fragment;if(t.renderable.getNumberOfClippingPlanes()){let e=t.renderable.getNumberOfClippingPlanes();e>6&&(Wt.vtkErrorMacro(&quot;OpenGL has a limit of 6 clipping planes&quot;),e=6),o=td.substitute(o,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,&quot;uniform vec4 clipPlanes[6];&quot;,&quot;varying float clipDistancesVSOutput[6];&quot;]).result,o=td.substitute(o,&quot;//VTK::Clip::Impl&quot;,[&quot;for (int planeNum = 0; planeNum < 6; planeNum++)&quot;,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], vertexMC);&quot;,&quot;    }&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,&quot;varying float clipDistancesVSOutput[6];&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Impl&quot;,[&quot;for (int planeNum = 0; planeNum < 6; planeNum++)&quot;,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    if (clipDistancesVSOutput[planeNum] < 0.0) discard;&quot;,&quot;    }&quot;]).result}e.Vertex=o,e.Fragment=a},e.getShaderTemplate=(e,t,n)=>{e.Vertex=Rd,e.Fragment=Md,e.Geometry=&quot;&quot;},e.setMapperShaderParameters=(n,r,o)=>{const a=n.getProgram(),i=n.getCABO();i.getElementCount()&&(t.VBOBuildTime.getMTime()>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())&&(a.isAttributeUsed(&quot;vertexMC&quot;)&&(n.getVAO().addAttributeArray(a,i,&quot;vertexMC&quot;,i.getVertexOffset(),i.getStride(),t.context.FLOAT,3,t.context.FALSE)||Wf(&quot;Error setting vertexMC in shader VAO.&quot;)),n.getCABO().getCustomData().forEach((e=>{e&&a.isAttributeUsed(e.name)&&!n.getVAO().addAttributeArray(a,i,e.name,e.offset,i.getStride(),t.context.FLOAT,e.components,t.context.FALSE)&&Wf(`Error setting ${e.name} in shader VAO.`)})),n.getAttributeUpdateTime().modified());const s=t.volumeTexture.getTextureUnit();if(a.setUniformi(&quot;volumeTexture&quot;,s),a.setUniformf(&quot;width&quot;,t.renderable.getWidth()),n.getProgram().setUniform4fv(&quot;backgroundColor&quot;,t.renderable.getBackgroundColor()),a.isUniformUsed(&quot;tangentDirection&quot;)){const e=t.renderable.getTangentDirection();n.getProgram().setUniform3fArray(&quot;tangentDirection&quot;,e)}if(a.isUniformUsed(&quot;bitangentDirection&quot;)){const e=t.renderable.getBitangentDirection();n.getProgram().setUniform3fArray(&quot;bitangentDirection&quot;,e)}if(a.isUniformUsed(&quot;centerlineOrientation&quot;)){const e=t.renderable.getUniformOrientation();n.getProgram().setUniform4fv(&quot;centerlineOrientation&quot;,e)}if(a.isUniformUsed(&quot;globalCenterPoint&quot;)){const e=t.renderable.getCenterPoint();a.setUniform3fArray(&quot;globalCenterPoint&quot;,e)}if(t.renderable.isProjectionEnabled()){const e=t.currentImageDataInput,n=e.getSpacing(),r=e.getDimensions(),o=t.renderable.getProjectionSlabThickness(),i=t.renderable.getProjectionSlabNumberOfSamples(),s=Mn([],n,r);a.setUniform3fArray(&quot;volumeSizeMC&quot;,s),a.setUniformi(&quot;projectionSlabNumberOfSamples&quot;,i);const l=-.5*o;a.setUniformf(&quot;projectionConstantOffset&quot;,l);const c=o/(i-1);a.setUniformf(&quot;projectionStepLength&quot;,c)}const l=t.currentImageDataInput,c=l.getWorldToIndex(),u=P(new Float32Array(16),xn([],l.getDimensions())),d=ae(u,u,c);if(a.setUniformMatrix(&quot;MCTCMatrix&quot;,d),t.haveSeenDepthRequest&&n.getProgram().setUniformi(&quot;depthRequest&quot;,t.renderDepth?1:0),t.renderable.getNumberOfClippingPlanes()){let e=t.renderable.getNumberOfClippingPlanes();e>6&&(Wt.vtkErrorMacro(&quot;OpenGL has a limit of 6 clipping planes&quot;),e=6);const n=i.getCoordShiftAndScaleEnabled()?i.getInverseShiftAndScaleMatrix():null,r=n?p(t.imagematinv,o.getMatrix()):o.getMatrix();n&&(h(r,r),b(r,r,n),h(r,r)),h(t.imagemat,t.currentImageDataInput.getIndexToWorld()),b(t.imagematinv,r,t.imagemat);const s=[];for(let n=0;n<e;n++){const e=[];t.renderable.getClippingPlaneInDataCoords(t.imagematinv,n,e);for(let t=0;t<4;t++)s.push(e[t])}a.setUniformi(&quot;numClipPlanes&quot;,e),a.setUniform4fv(&quot;clipPlanes&quot;,s)}if(a.isUniformUsed(&quot;coffset&quot;)){const t=e.getCoincidentParameters(r,o);a.setUniformf(&quot;coffset&quot;,t.offset),a.isUniformUsed(&quot;cfactor&quot;)&&a.setUniformf(&quot;cfactor&quot;,t.factor)}},e.setCameraShaderParameters=(e,n,r)=>{const o=t.openGLImageSlice.getKeyMatrices().mcwc,a=t.openGLCamera.getKeyMatrices(n).wcpc;if(b(t.imagemat,a,o),e.getCABO().getCoordShiftAndScaleEnabled()){const n=e.getCABO().getInverseShiftAndScaleMatrix();b(t.imagemat,t.imagemat,n)}e.getProgram().setUniformMatrix(&quot;MCPCMatrix&quot;,t.imagemat)},e.setPropertyShaderParameters=(e,n,r)=>{const o=e.getProgram(),a=r.getProperty(),i=a.getOpacity();o.setUniformf(&quot;opacity&quot;,i);const s=t.volumeTexture.getComponents(),l=a.getIndependentComponents();if(l)for(let e=0;e<s;++e)o.setUniformf(`mix${e}`,a.getComponentWeight(e));const c=t.volumeTexture.getVolumeInfo();for(let e=0;e<s;e++){let t=a.getColorWindow(),n=a.getColorLevel();const r=l?e:0,i=a.getRGBTransferFunction(r);if(i&&a.getUseLookupTableScalarRange()){const e=i.getRange();t=e[1]-e[0],n=.5*(e[1]+e[0])}const s=c.scale[e]/t,u=(c.offset[e]-n)/t+.5;o.setUniformf(`cshift${e}`,u),o.setUniformf(`cscale${e}`,s)}const u=t.colorTexture.getTextureUnit();o.setUniformi(&quot;colorTexture1&quot;,u);for(let e=0;e<s;e++){let t=1,n=0;const r=l?e:0,i=a.getPiecewiseFunction(r);if(i){const r=i.getRange(),o=r[1]-r[0],a=.5*(r[0]+r[1]);t=c.scale[e]/o,n=(c.offset[e]-a)/o+.5}o.setUniformf(`pwfshift${e}`,n),o.setUniformf(`pwfscale${e}`,t)}const d=t.pwfTexture.getTextureUnit();o.setUniformi(&quot;pwfTexture1&quot;,d)},e.updateShaders=(n,r,o)=>{if(e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};e.buildShaders(a,r,o);const i=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==n.getProgram()&&(n.setProgram(i),n.getVAO().releaseGraphicsResources()),n.getShaderSourceTime().modified()}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(n.getProgram());n.getVAO().bind(),e.setMapperShaderParameters(n,r,o),e.setCameraShaderParameters(n,r,o),e.setPropertyShaderParameters(n,r,o)},e.delete=Wt.chain((()=>{t._openGLRenderWindow&&n(t._openGLRenderWindow)}),e.delete)}(e,t)}),&quot;vtkOpenGLImageCPRMapper&quot;);Jt(&quot;vtkImageCPRMapper&quot;,jf);const Kf={context:null,keyMatrixTime:null,keyMatrices:null};const $f=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Kf,n),qt.extend(e,t,n),t.keyMatrixTime={},ht(t.keyMatrixTime,{mtime:0}),t.keyMatrices={mcwc:m(new Float64Array(16))},Ct(e,t,[&quot;context&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLImageSlice&quot;),e.buildPass=n=>{if(t.renderable&&t.renderable.getVisibility()&&n){if(!t.renderable)return;t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t.context=t._openGLRenderWindow.getContext(),e.prepareNodes(),e.addMissingNode(t.renderable.getMapper()),e.removeUnusedNodes()}},e.traverseZBufferPass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.children.forEach((e=>{e.traverse(n)})),e.apply(n,!1))},e.traverseOpaqueZBufferPass=t=>e.traverseOpaquePass(t),e.traverseOpaquePass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&t.renderable.getIsOpaque()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.children.forEach((e=>{e.traverse(n)})),e.apply(n,!1))},e.traverseTranslucentPass=n=>{!t.renderable||!t.renderable.getNestedVisibility()||t.renderable.getIsOpaque()||t._openGLRenderer.getSelector()&&!t.renderable.getNestedPickable()||(e.apply(n,!0),t.children.forEach((e=>{e.traverse(n)})),e.apply(n,!1))},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;t.renderable.getIsOpaque()?n.incrementOpaqueActorCount():n.incrementTranslucentActorCount()}},e.zBufferPass=(t,n)=>e.opaquePass(t,n),e.opaqueZBufferPass=(t,n)=>e.opaquePass(t,n),e.opaquePass=(e,n)=>{e&&t.context.depthMask(!0)},e.translucentPass=(e,n)=>{t.context.depthMask(!e)},e.getKeyMatrices=()=>(t.renderable.getMTime()>t.keyMatrixTime.getMTime()&&(p(t.keyMatrices.mcwc,t.renderable.getMatrix()),h(t.keyMatrices.mcwc,t.keyMatrices.mcwc),t.keyMatrixTime.modified()),t.keyMatrices)}(e,t)}),&quot;vtkOpenGLImageSlice&quot;);Jt(&quot;vtkImageSlice&quot;,$f);const qf={};const Xf=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,qf,n),qt.extend(e,t,n),t.keyMatrixTime={},ht(t.keyMatrixTime,{mtime:0}),t.normalMatrix=new Float64Array(9),t.MCWCMatrix=new Float64Array(16),Ct(e,t,[&quot;context&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLVolume&quot;),e.buildPass=n=>{t.renderable&&t.renderable.getVisibility()&&n&&(t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t.context=t._openGLRenderWindow.getContext(),e.prepareNodes(),e.addMissingNode(t.renderable.getMapper()),e.removeUnusedNodes())},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;n.incrementVolumeCount()}},e.traverseVolumePass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.children[0].traverse(n),e.apply(n,!1))},e.volumePass=e=>{t.renderable&&t.renderable.getVisibility()&&t.context.depthMask(!e)},e.getKeyMatrices=()=>(t.renderable.getMTime()>t.keyMatrixTime.getMTime()&&(t.renderable.computeMatrix(),p(t.MCWCMatrix,t.renderable.getMatrix()),h(t.MCWCMatrix,t.MCWCMatrix),t.renderable.getIsIdentity()?fe(t.normalMatrix):(le(t.normalMatrix,t.MCWCMatrix),me(t.normalMatrix,t.normalMatrix),ge(t.normalMatrix,t.normalMatrix)),t.keyMatrixTime.modified()),{mcwc:t.MCWCMatrix,normalMatrix:t.normalMatrix})}(e,t)}),&quot;vtkOpenGLVolume&quot;);Jt(&quot;vtkVolume&quot;,Xf);const Yf={NEAREST:0,LINEAR:1,FAST_LINEAR:2},Zf={FRACTIONAL:0,PROPORTIONAL:1},Qf={DEFAULT:0,ADDITIVE:1,COLORIZE:2,CUSTOM:3};var Jf={InterpolationType:Yf,OpacityMode:Zf,ColorMixPreset:Qf,FilterMode:{OFF:0,NORMALIZED:1,RAW:2}};const eg={COMPOSITE_BLEND:0,MAXIMUM_INTENSITY_BLEND:1,MINIMUM_INTENSITY_BLEND:2,AVERAGE_INTENSITY_BLEND:3,ADDITIVE_INTENSITY_BLEND:4,RADON_TRANSFORM_BLEND:5,LABELMAP_EDGE_PROJECTION_BLEND:6};var tg={BlendMode:eg};const{vtkWarningMacro:ng,vtkErrorMacro:rg}=Ht,og={idxToView:m(new Float64Array(16)),vecISToVCMatrix:fe(new Float64Array(9)),modelToView:m(new Float64Array(16)),projectionToView:m(new Float64Array(16)),projectionToWorld:m(new Float64Array(16))};const ag={context:null,VBOBuildTime:null,scalarTextures:[],_scalarTexturesCore:[],opacityTexture:null,_opacityTextureCore:null,colorTexture:null,_colorTextureCore:null,labelOutlineThicknessTexture:null,_labelOutlineThicknessTextureCore:null,jitterTexture:null,tris:null,framebuffer:null,copyShader:null,copyVAO:null,lastXYF:1,targetXYF:1,zBufferTexture:null,lastZBufferTexture:null,fullViewportTime:1,idxToView:null,vecISToVCMatrix:null,modelToView:null,projectionToView:null,avgWindowArea:0,avgFrameTime:0};const ig=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ag,n),qt.extend(e,t,n),Vd(e,t,n),t.VBOBuildTime={},ht(t.VBOBuildTime,{mtime:0}),t.tris=ld.newInstance(),t.jitterTexture=Pd.newInstance(),t.jitterTexture.setWrapS(cd.REPEAT),t.jitterTexture.setWrapT(cd.REPEAT),t.framebuffer=Sp.newInstance(),Ct(e,t,[&quot;context&quot;]),function(e,t){function n(e){return e.getUseLabelOutline()||t.renderable.getBlendMode()===eg.LABELMAP_EDGE_PROJECTION_BLEND}t.classHierarchy.push(&quot;vtkOpenGLVolumeMapper&quot;);const r=new Map;function o(t,n,o){n!==o&&(function(t,n){if(!n)return;const o=(r.get(n)??0)-1;o<=0?(t.unregisterGraphicsResourceUser(n,e),r.delete(n)):r.set(n,o)}(t,n),function(t,n){if(!n)return;const o=r.get(n)??0,a=o+1;r.set(n,a),o<=0&&t.registerGraphicsResourceUser(n,e)}(t,o))}function a(t){[...r.keys()].forEach((n=>t.unregisterGraphicsResourceUser(n,e)))}e.buildPass=()=>{t.zBufferTexture=null},e.zBufferPass=(e,n)=>{if(e){const e=n.getZBufferTexture();e!==t.zBufferTexture&&(t.zBufferTexture=e)}},e.opaqueZBufferPass=(t,n)=>e.zBufferPass(t,n),e.volumePass=(n,r)=>{if(n){const n=t._openGLRenderWindow;t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),n&&!n.isDeleted()&&n!==t._openGLRenderWindow&&a(n),t.context=t._openGLRenderWindow.getContext(),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow),t.jitterTexture.setOpenGLRenderWindow(t._openGLRenderWindow),t.framebuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.openGLVolume=e.getFirstAncestorOfType(&quot;vtkOpenGLVolume&quot;);const r=t.openGLVolume.getRenderable();t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;);const o=t._openGLRenderer.getRenderable();t.openGLCamera=t._openGLRenderer.getViewNodeFor(o.getActiveCamera()),e.renderPiece(o,r)}},e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkVolumeVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\nattribute vec4 vertexDC;\\n\\nvarying vec3 vertexVCVSOutput;\\nuniform mat4 PCVCMatrix;\\n\\nuniform float dcxmin;\\nuniform float dcxmax;\\nuniform float dcymin;\\nuniform float dcymax;\\n\\nvoid main()\\n{\\n  // dcsmall is the device coords reduced to the\\n  // x y area covered by the volume\\n  vec4 dcsmall = vec4(\\n    dcxmin + 0.5 * (vertexDC.x + 1.0) * (dcxmax - dcxmin),\\n    dcymin + 0.5 * (vertexDC.y + 1.0) * (dcymax - dcymin),\\n    vertexDC.z,\\n    vertexDC.w);\\n  vec4 vcpos = PCVCMatrix * dcsmall;\\n  vertexVCVSOutput = vcpos.xyz/vcpos.w;\\n  gl_Position = dcsmall;\\n}\\n&quot;,e.Fragment=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkVolumeFS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// Template for the volume mappers fragment shader\\n\\nconst float infinity = 3.402823466e38;\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nin vec3 vertexVCVSOutput;\\n\\n// From Sources\\\\Rendering\\\\Core\\\\VolumeProperty\\\\Constants.js\\n#define COMPOSITE_BLEND 0\\n#define MAXIMUM_INTENSITY_BLEND 1\\n#define MINIMUM_INTENSITY_BLEND 2\\n#define AVERAGE_INTENSITY_BLEND 3\\n#define ADDITIVE_INTENSITY_BLEND 4\\n#define RADON_TRANSFORM_BLEND 5\\n#define LABELMAP_EDGE_PROJECTION_BLEND 6\\n\\n#define vtkNumberOfLights //VTK::NumberOfLights\\n#define vtkMaxLaoKernelSize //VTK::MaxLaoKernelSize\\n#define vtkNumberOfComponents //VTK::NumberOfComponents\\n#define vtkBlendMode //VTK::BlendMode\\n#define vtkMaximumNumberOfSamples //VTK::MaximumNumberOfSamples\\n\\n//VTK::EnabledColorFunctions\\n\\n//VTK::EnabledLightings\\n\\n//VTK::EnabledMultiTexturePerVolume\\n\\n//VTK::EnabledGradientOpacity\\n\\n//VTK::EnabledIndependentComponents\\n\\n//VTK::vtkProportionalComponents\\n\\n//VTK::vtkForceNearestComponents\\n\\nuniform int twoSidedLighting;\\n\\n#if vtkMaxLaoKernelSize > 0\\n  vec2 kernelSample[vtkMaxLaoKernelSize];\\n#endif\\n\\n// Textures\\n#ifdef EnabledMultiTexturePerVolume\\n  #define vtkNumberOfVolumeTextures vtkNumberOfComponents\\n#else\\n  #define vtkNumberOfVolumeTextures 1\\n#endif\\nuniform highp sampler3D volumeTexture[vtkNumberOfVolumeTextures];\\nuniform sampler2D colorTexture;\\nuniform sampler2D opacityTexture;\\nuniform sampler2D jtexture;\\nuniform sampler2D labelOutlineThicknessTexture;\\n\\nstruct Volume {\\n  // ---- Volume geometry settings ----\\n\\n  vec3 originVC;          // in VC\\n  vec3 spacing;           // in VC per IC\\n  vec3 inverseSpacing;    // 1/spacing\\n  ivec3 dimensions;       // in IC\\n  vec3 inverseDimensions; // 1/vec3(dimensions)\\n  mat3 vecISToVCMatrix;   // convert from IS to VC without translation\\n  mat3 vecVCToISMatrix;   // convert from VC to IS without translation\\n  mat4 PCWCMatrix;\\n  mat4 worldToIndex;\\n  float diagonalLength; // in VC, this is: length(size)\\n\\n  // ---- Texture settings ----\\n\\n  // Texture shift and scale\\n  vec4 colorTextureScale;\\n  vec4 colorTextureShift;\\n  vec4 opacityTextureScale;\\n  vec4 opacityTextureShift;\\n\\n  // The heights defined below are the locations for the up to four components\\n  // of the transfer functions. The transfer functions have a height of (2 *\\n  // numberOfComponents) pixels so the values are computed to hit the middle of\\n  // the two rows for that component\\n  vec4 transferFunctionsSampleHeight;\\n\\n  // ---- Mode specific settings ----\\n\\n  // Independent component default preset settings per component\\n  vec4 independentComponentMix;\\n\\n  // Additive / average blending mode settings\\n  vec4 ipScalarRangeMin;\\n  vec4 ipScalarRangeMax;\\n\\n  // ---- Rendering settings ----\\n\\n  // Lighting\\n  float ambient;\\n  float diffuse;\\n  float specular;\\n  float specularPower;\\n  int computeNormalFromOpacity;\\n\\n  // Gradient opacity\\n  vec4 gradientOpacityScale;\\n  vec4 gradientOpacityShift;\\n  vec4 gradientOpacityMin;\\n  vec4 gradientOpacityMax;\\n\\n  // Volume shadow\\n  float volumetricScatteringBlending;\\n  float globalIlluminationReach;\\n  float anisotropy;\\n  float anisotropySquared;\\n\\n  // LAO\\n  int kernelSize;\\n  int kernelRadius;\\n\\n  // Label outline\\n  float outlineOpacity;\\n};\\nuniform Volume volume;\\n\\nstruct Light {\\n  vec3 color;\\n  vec3 positionVC;\\n  vec3 directionVC; // normalized\\n  vec3 halfAngleVC;\\n  vec3 attenuation;\\n  float exponent;\\n  float coneAngle;\\n  int isPositional;\\n};\\n#if vtkNumberOfLights > 0\\n  uniform Light lights[vtkNumberOfLights];\\n#endif\\n\\nuniform float vpWidth;\\nuniform float vpHeight;\\nuniform float vpOffsetX;\\nuniform float vpOffsetY;\\n\\n// Bitmasks for label outline\\nconst int MAX_SEGMENT_INDEX = 256; // Define as per expected maximum\\n#define MAX_SEGMENTS 256\\n#define UINT_SIZE 32\\n// We add UINT_SIZE - 1, as we want the ceil of the division instead of the\\n// floor\\n#define BITMASK_SIZE ((MAX_SEGMENTS + UINT_SIZE - 1) / UINT_SIZE)\\nuint labelOutlineBitmasks[BITMASK_SIZE];\\n\\n// Set the corresponding bit in the bitmask\\nvoid setLabelOutlineBit(int segmentIndex) {\\n  int arrayIndex = segmentIndex / UINT_SIZE;\\n  int bitIndex = segmentIndex % UINT_SIZE;\\n  labelOutlineBitmasks[arrayIndex] |= 1u << bitIndex;\\n}\\n\\n// Check if a bit is set in the bitmask\\nbool isLabelOutlineBitSet(int segmentIndex) {\\n  int arrayIndex = segmentIndex / UINT_SIZE;\\n  int bitIndex = segmentIndex % UINT_SIZE;\\n  return ((labelOutlineBitmasks[arrayIndex] & (1u << bitIndex)) != 0u);\\n}\\n\\n// if you want to see the raw tiled\\n// data in webgl1 uncomment the following line\\n// #define debugtile\\n\\n// camera values\\nuniform float camThick;\\nuniform float camNear;\\nuniform float camFar;\\nuniform int cameraParallel;\\n\\n//VTK::ClipPlane::Dec\\n\\n// A random number between 0 and 1 that only depends on the fragment\\n// It uses the jtexture, so this random seed repeats by blocks of 32 fragments\\n// in screen space\\nfloat fragmentSeed;\\n\\n// sample texture is global\\nuniform float sampleDistance;\\nuniform float volumeShadowSampleDistance;\\n\\n// declaration for intermixed geometry\\n//VTK::ZBuffer::Dec\\n\\n//=======================================================================\\n// global and custom variables (a temporary section before photorealistics\\n// rendering module is complete)\\nvec3 rayDirVC;\\n\\n#define INV4PI 0.0796\\n#define EPSILON 0.001\\n#define PI 3.1415\\n#define PI2 9.8696\\n\\nvec4 rawSampleTexture(vec3 pos) {\\n  #ifdef EnabledMultiTexturePerVolume\\n    vec4 rawSample;\\n    rawSample[0] = texture(volumeTexture[0], pos)[0];\\n  #if vtkNumberOfComponents > 1\\n    rawSample[1] = texture(volumeTexture[1], pos)[0];\\n  #endif\\n  #if vtkNumberOfComponents > 2\\n    rawSample[2] = texture(volumeTexture[2], pos)[0];\\n  #endif\\n  #if vtkNumberOfComponents > 3\\n    rawSample[3] = texture(volumeTexture[3], pos)[0];\\n  #endif\\n    return rawSample;\\n  #else\\n    return texture(volumeTexture[0], pos);\\n  #endif\\n}\\n\\nvec4 rawFetchTexture(ivec3 pos) {\\n  #ifdef EnabledMultiTexturePerVolume\\n    vec4 rawSample;\\n    #if vtkNumberOfComponents > 0\\n      rawSample[0] = texelFetch(volumeTexture[0], pos, 0)[0];\\n    #endif\\n    #if vtkNumberOfComponents > 1\\n      rawSample[1] = texelFetch(volumeTexture[1], pos, 0)[0];\\n    #endif\\n    #if vtkNumberOfComponents > 2\\n      rawSample[2] = texelFetch(volumeTexture[2], pos, 0)[0];\\n    #endif\\n    #if vtkNumberOfComponents > 3\\n      rawSample[3] = texelFetch(volumeTexture[3], pos, 0)[0];\\n    #endif\\n    return rawSample;\\n  #else\\n    return texelFetch(volumeTexture[0], pos, 0);\\n  #endif\\n}\\n\\nvec4 getTextureValue(vec3 pos) {\\n  vec4 tmp = rawSampleTexture(pos);\\n\\n  // Force nearest\\n  #if defined(vtkComponent0ForceNearest) || \\\\\\n      defined(vtkComponent1ForceNearest) || \\\\\\n      defined(vtkComponent2ForceNearest) || \\\\\\n      defined(vtkComponent3ForceNearest)\\n    vec3 nearestPos = (floor(pos * vec3(volume.dimensions)) + 0.5) *\\n                      volume.inverseDimensions;\\n    vec4 nearestValue = rawSampleTexture(nearestPos);\\n    #ifdef vtkComponent0ForceNearest\\n      tmp[0] = nearestValue[0];\\n    #endif\\n    #ifdef vtkComponent1ForceNearest\\n      tmp[1] = nearestValue[1];\\n    #endif\\n    #ifdef vtkComponent2ForceNearest\\n      tmp[2] = nearestValue[2];\\n    #endif\\n    #ifdef vtkComponent3ForceNearest\\n      tmp[3] = nearestValue[3];\\n    #endif\\n  #endif\\n\\n  // Set alpha when using dependent components\\n  #ifndef EnabledIndependentComponents\\n    #if vtkNumberOfComponents == 1\\n      tmp.a = tmp.r;\\n    #endif\\n    #if vtkNumberOfComponents == 2\\n      tmp.a = tmp.g;\\n    #endif\\n    #if vtkNumberOfComponents == 3\\n      tmp.a = length(tmp.rgb);\\n    #endif\\n  #endif\\n\\n  return tmp;\\n}\\n\\n// `height` is usually `volume.transferFunctionsSampleHeight[component]`\\n// when using independent component and `0.5` otherwise. Don't move the if\\n// statement in these function, as the callers usually already knows if it is\\n// using independent component or not\\nfloat getOpacityFromTexture(float scalar, int component, float height) {\\n  float scaledScalar = scalar * volume.opacityTextureScale[component] +\\n                       volume.opacityTextureShift[component];\\n  return texture2D(opacityTexture, vec2(scaledScalar, height)).r;\\n}\\nvec3 getColorFromTexture(float scalar, int component, float height) {\\n  float scaledScalar = scalar * volume.colorTextureScale[component] +\\n                       volume.colorTextureShift[component];\\n  return texture2D(colorTexture, vec2(scaledScalar, height)).rgb;\\n}\\n\\n//=======================================================================\\n// transformation between VC and IS space\\n\\n// convert vector position from idx to vc\\nvec3 posIStoVC(vec3 posIS) {\\n  return volume.vecISToVCMatrix * posIS + volume.originVC;\\n}\\n\\n// convert vector position from vc to idx\\nvec3 posVCtoIS(vec3 posVC) {\\n  return volume.vecVCToISMatrix * (posVC - volume.originVC);\\n}\\n\\n// Rotate vector to view coordinate\\nvec3 vecISToVC(vec3 dirIS) {\\n  return volume.vecISToVCMatrix * dirIS;\\n}\\n\\n// Rotate vector to idx coordinate\\nvec3 vecVCToIS(vec3 dirVC) {\\n  return volume.vecVCToISMatrix * dirVC;\\n}\\n\\n//=======================================================================\\n// Given a normal compute the gradient opacity factors\\nfloat computeGradientOpacityFactor(float normalMag, int component) {\\n  float goscale = volume.gradientOpacityScale[component];\\n  float goshift = volume.gradientOpacityShift[component];\\n  float gomin = volume.gradientOpacityMin[component];\\n  float gomax = volume.gradientOpacityMax[component];\\n  return clamp(normalMag * goscale + goshift, gomin, gomax);\\n}\\n\\n#ifdef vtkClippingPlanesOn\\n  bool isPointClipped(vec3 posVC) {\\n    for (int i = 0; i < clip_numPlanes; ++i) {\\n      if (dot(vec3(vClipPlaneOrigins[i] - posVC), vClipPlaneNormals[i]) > 0.0) {\\n        return true;\\n      }\\n    }\\n    return false;\\n  }\\n#endif\\n\\n//=======================================================================\\n// compute the normal and gradient magnitude for a position, uses forward\\n// difference\\n\\n// The output normal is in VC\\nvec4 computeDensityNormal(vec3 opacityUCoords[2], float opacityTextureHeight,\\n                          float gradientOpacity, int component) {\\n  // Pass the scalars through the opacity functions\\n  vec4 opacityG;\\n  opacityG.x += getOpacityFromTexture(opacityUCoords[0].x, component,\\n                                      opacityTextureHeight);\\n  opacityG.y += getOpacityFromTexture(opacityUCoords[0].y, component,\\n                                      opacityTextureHeight);\\n  opacityG.z += getOpacityFromTexture(opacityUCoords[0].z, component,\\n                                      opacityTextureHeight);\\n  opacityG.x -= getOpacityFromTexture(opacityUCoords[1].x, component,\\n                                      opacityTextureHeight);\\n  opacityG.y -= getOpacityFromTexture(opacityUCoords[1].y, component,\\n                                      opacityTextureHeight);\\n  opacityG.z -= getOpacityFromTexture(opacityUCoords[1].z, component,\\n                                      opacityTextureHeight);\\n\\n  // Divide by spacing and convert to VC\\n  opacityG.xyz *= gradientOpacity * volume.inverseSpacing;\\n  opacityG.w = length(opacityG.xyz);\\n  if (opacityG.w == 0.0) {\\n    return vec4(0.0);\\n  }\\n\\n  // Normalize\\n  opacityG.xyz = normalize(vecISToVC(opacityG.xyz));\\n\\n  return opacityG;\\n}\\n\\n// The output normal is in VC\\nvec4 computeNormalForDensity(vec3 posIS, out vec3 scalarInterp[2],\\n                             const int opacityComponent) {\\n  vec3 offsetedPosIS;\\n  for (int axis = 0; axis < 3; ++axis) {\\n    // Positive direction\\n    offsetedPosIS = posIS;\\n    offsetedPosIS[axis] += volume.inverseDimensions[axis];\\n    scalarInterp[0][axis] =\\n        getTextureValue(offsetedPosIS)[opacityComponent];\\n    #ifdef vtkClippingPlanesOn\\n      if (isPointClipped(posIStoVC(offsetedPosIS))) {\\n        scalarInterp[0][axis] = 0.0;\\n      }\\n    #endif\\n\\n    // Negative direction\\n    offsetedPosIS = posIS;\\n    offsetedPosIS[axis] -= volume.inverseDimensions[axis];\\n    scalarInterp[1][axis] =\\n        getTextureValue(offsetedPosIS)[opacityComponent];\\n    #ifdef vtkClippingPlanesOn\\n      if (isPointClipped(posIStoVC(offsetedPosIS))) {\\n        scalarInterp[1][axis] = 0.0;\\n      }\\n    #endif\\n  }\\n\\n  vec4 result;\\n  result.xyz = (scalarInterp[0] - scalarInterp[1]) * volume.inverseSpacing;\\n  result.w = length(result.xyz);\\n  if (result.w == 0.0) {\\n    return vec4(0.0);\\n  }\\n  result.xyz = normalize(vecISToVC(result.xyz));\\n  return result;\\n}\\n\\nvec4 fragCoordToPCPos(vec4 fragCoord) {\\n  return vec4((fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,\\n              (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,\\n              (fragCoord.z - 0.5) * 2.0, 1.0);\\n}\\n\\nvec4 pcPosToWorldCoord(vec4 pcPos) {\\n  return volume.PCWCMatrix * pcPos;\\n}\\n\\nvec3 fragCoordToIndexSpace(vec4 fragCoord) {\\n  vec4 pcPos = fragCoordToPCPos(fragCoord);\\n  vec4 worldCoord = pcPosToWorldCoord(pcPos);\\n  vec4 vertex = (worldCoord / worldCoord.w);\\n\\n  vec3 index = (volume.worldToIndex * vertex).xyz;\\n\\n  // half voxel fix for labelmapOutline\\n  return (index + vec3(0.5)) * volume.inverseDimensions;\\n}\\n\\nvec3 fragCoordToWorld(vec4 fragCoord) {\\n  vec4 pcPos = fragCoordToPCPos(fragCoord);\\n  vec4 worldCoord = pcPosToWorldCoord(pcPos);\\n  return worldCoord.xyz;\\n}\\n\\n//=======================================================================\\n// Compute the normals and gradient magnitudes for a position for independent\\n// components The output normals are in VC\\nmat4 computeMat4Normal(vec3 posIS, vec4 tValue) {\\n  vec3 xvec = vec3(volume.inverseDimensions.x, 0.0, 0.0);\\n  vec3 yvec = vec3(0.0, volume.inverseDimensions.y, 0.0);\\n  vec3 zvec = vec3(0.0, 0.0, volume.inverseDimensions.z);\\n\\n  vec4 distX = getTextureValue(posIS + xvec) - getTextureValue(posIS - xvec);\\n  vec4 distY = getTextureValue(posIS + yvec) - getTextureValue(posIS - yvec);\\n  vec4 distZ = getTextureValue(posIS + zvec) - getTextureValue(posIS - zvec);\\n\\n  // divide by spacing\\n  distX *= 0.5 * volume.inverseSpacing.x;\\n  distY *= 0.5 * volume.inverseSpacing.y;\\n  distZ *= 0.5 * volume.inverseSpacing.z;\\n\\n  mat4 result;\\n\\n  // optionally compute the 1st component\\n  #if vtkNumberOfComponents > 0 && !defined(vtkComponent0Proportional)\\n    {\\n      const int component = 0;\\n      vec3 normal = vec3(distX[component], distY[component], distZ[component]);\\n      float normalLength = length(normal);\\n      if (normalLength > 0.0) {\\n        normal = normalize(vecISToVC(normal));\\n      }\\n      result[component] = vec4(normal, normalLength);\\n    }\\n  #endif\\n\\n  // optionally compute the 2nd component\\n  #if vtkNumberOfComponents > 1 && !defined(vtkComponent1Proportional)\\n    {\\n      const int component = 1;\\n      vec3 normal = vec3(distX[component], distY[component], distZ[component]);\\n      float normalLength = length(normal);\\n      if (normalLength > 0.0) {\\n        normal = normalize(vecISToVC(normal));\\n      }\\n      result[component] = vec4(normal, normalLength);\\n    }\\n  #endif\\n\\n  // optionally compute the 3rd component\\n  #if vtkNumberOfComponents > 2 && !defined(vtkComponent2Proportional)\\n    {\\n      const int component = 2;\\n      vec3 normal = vec3(distX[component], distY[component], distZ[component]);\\n      float normalLength = length(normal);\\n      if (normalLength > 0.0) {\\n        normal = normalize(vecISToVC(normal));\\n      }\\n      result[component] = vec4(normal, normalLength);\\n    }\\n  #endif\\n\\n  // optionally compute the 4th component\\n  #if vtkNumberOfComponents > 3 && !defined(vtkComponent3Proportional)\\n    {\\n      const int component = 3;\\n      vec3 normal = vec3(distX[component], distY[component], distZ[component]);\\n      float normalLength = length(normal);\\n      if (normalLength > 0.0) {\\n        normal = normalize(vecISToVC(normal));\\n      }\\n      result[component] = vec4(normal, normalLength);\\n    }\\n  #endif\\n\\n  return result;\\n}\\n\\n//=======================================================================\\n// global shadow - secondary ray\\n\\n// henyey greenstein phase function\\nfloat phaseFunction(float cos_angle) {\\n  // divide by 2.0 instead of 4pi to increase intensity\\n  float anisotropy = volume.anisotropy;\\n  if (abs(anisotropy) <= EPSILON) {\\n    // isotropic scatter returns 0.5 instead of 1/4pi to increase intensity\\n    return 0.5;\\n  }\\n  float anisotropy2 = volume.anisotropySquared;\\n  return ((1.0 - anisotropy2) /\\n          pow(1.0 + anisotropy2 - 2.0 * anisotropy * cos_angle, 1.5)) /\\n         2.0;\\n}\\n\\n// Compute the two intersection distances of the ray with the volume in VC\\n// The entry point is `rayOriginVC + distanceMin * rayDirVC` and the exit point\\n// is `rayOriginVC + distanceMax * rayDirVC` If distanceMin < distanceMax, the\\n// volume is not intersected The ray origin is inside the box when distanceMin <\\n// 0.0 < distanceMax\\nvec2 rayIntersectVolumeDistances(vec3 rayOriginVC, vec3 rayDirVC) {\\n  // Compute origin and direction in IS\\n  vec3 rayOriginIS = posVCtoIS(rayOriginVC);\\n  vec3 rayDirIS = vecVCToIS(rayDirVC);\\n  // Don't check for infinity as the min/max combination afterward will always\\n  // find an intersection before infinity\\n  vec3 invDir = 1.0 / rayDirIS;\\n\\n  // We have: bound = origin + t * dir\\n  // So: t = (1/dir) * (bound - origin)\\n  vec3 distancesTo0 = invDir * (vec3(0.0) - rayOriginIS);\\n  vec3 distancesTo1 = invDir * (vec3(1.0) - rayOriginIS);\\n  // Min and max distances to plane intersection per plane\\n  vec3 dMinPerAxis = min(distancesTo0, distancesTo1);\\n  vec3 dMaxPerAxis = max(distancesTo0, distancesTo1);\\n  // Overall first and last intersection\\n  float distanceMin = max(dMinPerAxis.x, max(dMinPerAxis.y, dMinPerAxis.z));\\n  float distanceMax = min(dMaxPerAxis.x, min(dMaxPerAxis.y, dMaxPerAxis.z));\\n  return vec2(distanceMin, distanceMax);\\n}\\n\\n//=======================================================================\\n// local ambient occlusion\\n#if vtkMaxLaoKernelSize > 0\\n\\n  // Return a random point on the unit sphere\\n  vec3 sampleDirectionUniform(int rayIndex) {\\n    // Each ray of each fragment should be different, two sources of randomness\\n    // are used. Only depends on ray index\\n    vec2 rayRandomness = kernelSample[rayIndex];\\n    // Only depends on fragment\\n    float fragmentRandomness = fragmentSeed;\\n    // Merge both source of randomness in a single uniform random variable using\\n    // the formula (x+y < 1 ? x+y : x+y-1). The simpler formula (x+y)/2 doesn't\\n    // result in a uniform distribution\\n    vec2 mergedRandom = rayRandomness + vec2(fragmentRandomness);\\n    mergedRandom -= vec2(greaterThanEqual(mergedRandom, vec2(1.0)));\\n\\n    // Insipred by:\\n    // https://karthikkaranth.me/blog/generating-random-points-in-a-sphere/#better-choice-of-spherical-coordinates\\n    float u = mergedRandom[0];\\n    float v = mergedRandom[1];\\n    float theta = u * 2.0 * PI;\\n    float phi = acos(2.0 * v - 1.0);\\n    float sinTheta = sin(theta);\\n    float cosTheta = cos(theta);\\n    float sinPhi = sin(phi);\\n    float cosPhi = cos(phi);\\n    return vec3(sinPhi * cosTheta, sinPhi * sinTheta, cosPhi);\\n  }\\n\\n  float computeLAO(vec3 posVC, vec4 normalVC, float originalOpacity) {\\n    // apply LAO only at selected locations, otherwise return full brightness\\n    if (normalVC.w <= 0.0 || originalOpacity <= 0.05) {\\n      return 1.0;\\n    }\\n\\n    #ifdef EnabledGradientOpacity\\n      float gradientOpacityFactor = computeGradientOpacityFactor(normalVC.w, 0);\\n    #endif\\n\\n    float visibilitySum = 0.0;\\n    float weightSum = 0.0;\\n    for (int i = 0; i < volume.kernelSize; i++) {\\n      // Only sample on an hemisphere around the normalVC.xyz axis, so\\n      // normalDotRay should be negative\\n      vec3 rayDirectionVC = sampleDirectionUniform(i);\\n      float normalDotRay = dot(normalVC.xyz, rayDirectionVC);\\n      if (normalDotRay > 0.0) {\\n        // Flip rayDirectionVC when it is in the wrong hemisphere\\n        rayDirectionVC = -rayDirectionVC;\\n        normalDotRay = -normalDotRay;\\n      }\\n\\n      vec3 currPosIS = posVCtoIS(posVC);\\n      float visibility = 1.0;\\n      vec3 randomDirStepIS = vecVCToIS(rayDirectionVC * sampleDistance);\\n      for (int j = 0; j < volume.kernelRadius; j++) {\\n        currPosIS += randomDirStepIS;\\n        // If out of the volume, we are done\\n        if (any(lessThan(currPosIS, vec3(0.0))) ||\\n            any(greaterThan(currPosIS, vec3(1.0)))) {\\n          break;\\n        }\\n        float opacity = getOpacityFromTexture(getTextureValue(currPosIS).r, 0, 0.5);\\n        #ifdef EnabledGradientOpacity\\n          opacity *= gradientOpacityFactor;\\n        #endif\\n        visibility *= 1.0 - opacity;\\n        // If visibility is less than EPSILON, consider it to be 0\\n        if (visibility < EPSILON) {\\n          visibility = 0.0;\\n          break;\\n        }\\n      }\\n      float rayWeight = -normalDotRay;\\n      visibilitySum += visibility * rayWeight;\\n      weightSum += rayWeight;\\n    }\\n\\n    // If no sample, LAO factor is one\\n    if (weightSum == 0.0) {\\n      return 1.0;\\n    }\\n\\n    // LAO factor is the average visibility:\\n    // - visibility low => ambient low\\n    // - visibility high => ambient high\\n    float lao = visibilitySum / weightSum;\\n\\n    // Reduce variance by clamping\\n    return clamp(lao, 0.3, 1.0);\\n  }\\n#endif\\n\\n//=======================================================================\\n// Volume shadows\\n#if vtkNumberOfLights > 0\\n\\n  // Non-memoised version\\n  float computeVolumeShadowWithoutCache(vec3 posVC, vec3 lightDirNormVC) {\\n    // modify sample distance with a random number between 1.5 and 3.0\\n    float rayStepLength =\\n        volumeShadowSampleDistance * mix(1.5, 3.0, fragmentSeed);\\n\\n    // in case the first sample near surface has a very tiled light ray, we need\\n    // to offset start position\\n    vec3 initialPosVC = posVC + rayStepLength * lightDirNormVC;\\n\\n    #ifdef vtkClippingPlanesOn\\n      float clippingPlanesMaxDistance = infinity;\\n      for (int i = 0; i < clip_numPlanes; ++i) {\\n        // Find distance of intersection with the plane\\n        // Points are clipped when:\\n        // dot(planeOrigin - (rayOrigin + distance * rayDirection), planeNormal) > 0\\n        // This is equivalent to:\\n        // dot(planeOrigin - rayOrigin, planeNormal) - distance * dot(rayDirection,\\n        // planeNormal) > 0.0\\n        // We precompute the dot products, so we clip ray points when:\\n        // dotOrigin - distance * dotDirection > 0.0\\n        float dotOrigin =\\n            dot(vClipPlaneOrigins[i] - initialPosVC, vClipPlaneNormals[i]);\\n        if (dotOrigin > 0.0) {\\n          // The initialPosVC is clipped by this plane\\n          return 1.0;\\n        }\\n        float dotDirection = dot(lightDirNormVC, vClipPlaneNormals[i]);\\n        if (dotDirection < 0.0) {\\n          // We only hit the plane if dotDirection is negative, as (distance is\\n          // positive)\\n          float intersectionDistance =\\n              dotOrigin / dotDirection; // negative divided by negative => positive\\n          clippingPlanesMaxDistance =\\n              min(clippingPlanesMaxDistance, intersectionDistance);\\n        }\\n      }\\n    #endif\\n\\n    vec2 intersectionDistances =\\n        rayIntersectVolumeDistances(initialPosVC, lightDirNormVC);\\n\\n    if (intersectionDistances[1] <= intersectionDistances[0] ||\\n        intersectionDistances[1] <= 0.0) {\\n      // Volume not hit or behind the ray\\n      return 1.0;\\n    }\\n\\n    // When globalIlluminationReach is 0, no sample at all\\n    // When globalIlluminationReach is 1, the ray will go through the whole\\n    // volume\\n    float maxTravelDistance = mix(0.0, volume.diagonalLength,\\n                                  volume.globalIlluminationReach);\\n    float startDistance = max(intersectionDistances[0], 0.0);\\n    float endDistance = min(intersectionDistances[1], startDistance + maxTravelDistance);\\n    #ifdef vtkClippingPlanesOn\\n      endDistance = min(endDistance, clippingPlanesMaxDistance);\\n    #endif\\n    if (endDistance - startDistance < 0.0) {\\n      return 1.0;\\n    }\\n\\n    // These two variables are used to compute posIS, without having to call\\n    // VCtoIS at each step\\n    vec3 initialPosIS = posVCtoIS(initialPosVC);\\n    // The light dir is scaled and rotated, but not translated, as it is a\\n    // vector (w = 0)\\n    vec3 scaledLightDirIS = vecVCToIS(lightDirNormVC);\\n\\n    float shadow = 1.0;\\n    for (float currentDistance = startDistance; currentDistance <= endDistance;\\n          currentDistance += rayStepLength) {\\n      vec3 posIS = initialPosIS + currentDistance * scaledLightDirIS;\\n      vec4 scalar = getTextureValue(posIS);\\n      float opacity = getOpacityFromTexture(scalar.r, 0, 0.5);\\n      #if defined(EnabledGradientOpacity) && !defined(EnabledIndependentComponents)\\n        vec3 scalarInterp[2];\\n        vec4 normal = computeNormalForDensity(posIS, scalarInterp, 3);\\n        float opacityFactor = computeGradientOpacityFactor(normal.w, 0);\\n        opacity *= opacityFactor;\\n      #endif\\n      shadow *= 1.0 - opacity;\\n\\n      // Early termination if shadow coeff is near 0.0\\n      if (shadow < EPSILON) {\\n        return 0.0;\\n      }\\n    }\\n    return shadow;\\n  }\\n\\n  // Some cache for volume shadows\\n  struct {\\n    vec3 posVC;\\n    float shadow;\\n  } cachedShadows[vtkNumberOfLights];\\n\\n  // Memoised version\\n  float computeVolumeShadow(vec3 posVC, vec3 lightDirNormVC, int lightIdx) {\\n    if (posVC == cachedShadows[lightIdx].posVC) {\\n      return cachedShadows[lightIdx].shadow;\\n    }\\n    float shadow = computeVolumeShadowWithoutCache(posVC, lightDirNormVC);\\n    cachedShadows[lightIdx].posVC = posVC;\\n    cachedShadows[lightIdx].shadow = shadow;\\n    return shadow;\\n  }\\n\\n#endif\\n\\n//=======================================================================\\n// surface light contribution\\n#if vtkNumberOfLights > 0\\n  vec3 applyLighting(vec3 tColor, vec4 normalVC) {\\n    vec3 diffuse = vec3(0.0, 0.0, 0.0);\\n    vec3 specular = vec3(0.0, 0.0, 0.0);\\n    for (int lightIdx = 0; lightIdx < vtkNumberOfLights; lightIdx++) {\\n      float df = dot(normalVC.xyz, lights[lightIdx].directionVC);\\n      if (df > 0.0) {\\n        diffuse += df * lights[lightIdx].color;\\n        float sf = dot(normalVC.xyz, -lights[lightIdx].halfAngleVC);\\n        if (sf > 0.0) {\\n          specular += pow(sf, volume.specularPower) * lights[lightIdx].color;\\n        }\\n      }\\n    }\\n    return tColor * (diffuse * volume.diffuse + volume.ambient) +\\n          specular * volume.specular;\\n  }\\n\\n  vec3 applySurfaceShadowLighting(vec3 tColor, float alpha, vec3 posVC,\\n                                  vec4 normalVC) {\\n    // everything in VC\\n    vec3 diffuse = vec3(0.0);\\n    vec3 specular = vec3(0.0);\\n    for (int ligthIdx = 0; ligthIdx < vtkNumberOfLights; ligthIdx++) {\\n      vec3 vertLightDirection;\\n      float attenuation;\\n      if (lights[ligthIdx].isPositional == 1) {\\n        vertLightDirection = posVC - lights[ligthIdx].positionVC;\\n        float lightDistance = length(vertLightDirection);\\n        // Normalize with precomputed length\\n        vertLightDirection = vertLightDirection / lightDistance;\\n        // Base attenuation\\n        vec3 attenuationPolynom = lights[ligthIdx].attenuation;\\n        attenuation =\\n            1.0 / (attenuationPolynom[0] +\\n                  lightDistance * (attenuationPolynom[1] +\\n                                    lightDistance * attenuationPolynom[2]));\\n        // Cone attenuation\\n        float coneDot = dot(vertLightDirection, lights[ligthIdx].directionVC);\\n        // Per OpenGL standard cone angle is 90 or less for a spot light\\n        if (lights[ligthIdx].coneAngle <= 90.0) {\\n          if (coneDot >= cos(radians(lights[ligthIdx].coneAngle))) {\\n            // Inside the cone\\n            attenuation *= pow(coneDot, lights[ligthIdx].exponent);\\n          } else {\\n            // Outside the cone\\n            attenuation = 0.0;\\n          }\\n        }\\n      } else {\\n        vertLightDirection = lights[ligthIdx].directionVC;\\n        attenuation = 1.0;\\n      }\\n\\n      float ndotL = dot(normalVC.xyz, vertLightDirection);\\n      if (ndotL < 0.0 && twoSidedLighting == 1) {\\n        ndotL = -ndotL;\\n      }\\n      if (ndotL > 0.0) {\\n        // Diffuse\\n        diffuse += ndotL * attenuation * lights[ligthIdx].color;\\n        // Specular\\n        float vdotR =\\n            dot(-rayDirVC, normalize(vertLightDirection - 2.0 * ndotL * normalVC.xyz));\\n        if (vdotR > 0.0) {\\n          specular += pow(vdotR, volume.specularPower) * attenuation *\\n                      lights[ligthIdx].color;\\n        }\\n      }\\n    }\\n    #if vtkMaxLaoKernelSize > 0\\n      float laoFactor = computeLAO(posVC, normalVC, alpha);\\n    #else\\n      const float laoFactor = 1.0;\\n    #endif\\n    return tColor * (diffuse * volume.diffuse +\\n                    volume.ambient * laoFactor) +\\n          specular * volume.specular;\\n  }\\n\\n  vec3 applyVolumeShadowLighting(vec3 tColor, vec3 posVC) {\\n    // Here we have no effect of cones and no attenuation\\n    vec3 diffuse = vec3(0.0);\\n    for (int lightIdx = 0; lightIdx < vtkNumberOfLights; lightIdx++) {\\n      vec3 lightDirVC = lights[lightIdx].isPositional == 1\\n                            ? normalize(lights[lightIdx].positionVC - posVC)\\n                            : -lights[lightIdx].directionVC;\\n      float shadowCoeff = computeVolumeShadow(posVC, lightDirVC, lightIdx);\\n      float phaseAttenuation = phaseFunction(dot(rayDirVC, lightDirVC));\\n      diffuse += phaseAttenuation * shadowCoeff * lights[lightIdx].color;\\n    }\\n    return tColor * (diffuse * volume.diffuse + volume.ambient);\\n  }\\n#endif\\n\\n// LAO of surface shadows and volume shadows only work with dependent components\\nvec3 applyAllLightning(vec3 tColor, float alpha, vec3 posVC,\\n                       vec4 surfaceNormalVC) {\\n  #if vtkNumberOfLights > 0\\n    // 0 <= volCoeff < EPSILON => only surface shadows\\n    // EPSILON <= volCoeff < 1 - EPSILON => mix of surface and volume shadows\\n    // 1 - EPSILON <= volCoeff => only volume shadows\\n    float volCoeff = volume.volumetricScatteringBlending *\\n                    (1.0 - alpha / 2.0) *\\n                    (1.0 - atan(surfaceNormalVC.w) * INV4PI);\\n\\n    // Compute surface lighting if needed\\n    vec3 surfaceShadedColor = tColor;\\n    #ifdef EnableSurfaceLighting\\n      if (volCoeff < 1.0 - EPSILON) {\\n        surfaceShadedColor =\\n            applySurfaceShadowLighting(tColor, alpha, posVC, surfaceNormalVC);\\n      }\\n    #endif\\n\\n    // Compute volume lighting if needed\\n    vec3 volumeShadedColor = tColor;\\n    #ifdef EnableVolumeLighting\\n      if (volCoeff >= EPSILON) {\\n        volumeShadedColor = applyVolumeShadowLighting(tColor, posVC);\\n      }\\n    #endif\\n\\n    // Return the right mix\\n    if (volCoeff < EPSILON) {\\n      // Surface shadows\\n      return surfaceShadedColor;\\n    }\\n    if (volCoeff >= 1.0 - EPSILON) {\\n      // Volume shadows\\n      return volumeShadedColor;\\n    }\\n    // Mix of surface and volume shadows\\n    return mix(surfaceShadedColor, volumeShadedColor, volCoeff);\\n  #endif\\n  return tColor;\\n}\\n\\nvec4 getColorForLabelOutline() {\\n  vec3 centerPosIS =\\n      fragCoordToIndexSpace(gl_FragCoord); // pos in texture space\\n  vec4 centerValue = getTextureValue(centerPosIS);\\n  bool pixelOnBorder = false;\\n  vec4 tColor = vec4(getColorFromTexture(centerValue.r, 0, 0.5),\\n                     getOpacityFromTexture(centerValue.r, 0, 0.5));\\n\\n  int segmentIndex = int(centerValue.r * 255.0);\\n\\n  // Use texture sampling for outlineThickness\\n  float textureCoordinate = float(segmentIndex - 1) / 1024.0;\\n  float textureValue =\\n      texture2D(labelOutlineThicknessTexture, vec2(textureCoordinate, 0.5)).r;\\n  int actualThickness = int(textureValue * 255.0);\\n\\n  // If it is the background (segment index 0), we should quickly bail out.\\n  // Previously, this was determined by tColor.a, which was incorrect as it\\n  // prevented the outline from appearing when the fill is 0.\\n  if (segmentIndex == 0) {\\n    return vec4(0, 0, 0, 0);\\n  }\\n\\n  // Only perform outline check on fragments rendering voxels that aren't\\n  // invisible. Saves a bunch of needless checks on the background.\\n  // TODO define epsilon when building shader?\\n  for (int i = -actualThickness; i <= actualThickness; i++) {\\n    for (int j = -actualThickness; j <= actualThickness; j++) {\\n      if (i == 0 || j == 0) {\\n        continue;\\n      }\\n\\n      vec4 neighborPixelCoord =\\n          vec4(gl_FragCoord.x + float(i), gl_FragCoord.y + float(j),\\n               gl_FragCoord.z, gl_FragCoord.w);\\n\\n      vec3 neighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);\\n      vec4 value = getTextureValue(neighborPosIS);\\n\\n      // If any of my neighbours are not the same value as I\\n      // am, this means I am on the border of the segment.\\n      // We can break the loops\\n      if (any(notEqual(value, centerValue))) {\\n        pixelOnBorder = true;\\n        break;\\n      }\\n    }\\n\\n    if (pixelOnBorder == true) {\\n      break;\\n    }\\n  }\\n\\n  // If I am on the border, I am displayed at full opacity\\n  if (pixelOnBorder == true) {\\n    tColor.a = volume.outlineOpacity;\\n  }\\n\\n  return tColor;\\n}\\n\\nvec4 getColorForAdditivePreset(vec4 tValue, vec3 posVC, vec3 posIS) {\\n  // compute normals\\n  mat4 normalMat = computeMat4Normal(posIS, tValue);\\n  vec4 normalLights[2];\\n  normalLights[0] = normalMat[0];\\n  normalLights[1] = normalMat[1];\\n  #if vtkNumberOfLights > 0\\n    if (volume.computeNormalFromOpacity == 1) {\\n      for (int component = 0; component < 2; ++component) {\\n        vec3 scalarInterp[2];\\n        float height = volume.transferFunctionsSampleHeight[component];\\n        computeNormalForDensity(posIS, scalarInterp, component);\\n        normalLights[component] =\\n            computeDensityNormal(scalarInterp, height, 1.0, component);\\n      }\\n    }\\n  #endif\\n\\n  // compute opacities\\n  float opacities[2];\\n  opacities[0] = getOpacityFromTexture(\\n      tValue[0], 0, volume.transferFunctionsSampleHeight[0]);\\n  opacities[1] = getOpacityFromTexture(\\n      tValue[1], 1, volume.transferFunctionsSampleHeight[1]);\\n  #ifdef EnabledGradientOpacity\\n    for (int component = 0; component < 2; ++component) {\\n      opacities[component] *=\\n          computeGradientOpacityFactor(normalMat[component].a, component);\\n    }\\n  #endif\\n  float opacitySum = opacities[0] + opacities[1];\\n  if (opacitySum <= 0.0) {\\n    return vec4(0.0);\\n  }\\n\\n  // mix the colors and opacities\\n  vec3 colors[2];\\n  for (int component = 0; component < 2; ++component) {\\n    float sampleHeight = volume.transferFunctionsSampleHeight[component];\\n    vec3 color = getColorFromTexture(tValue[component], component, sampleHeight);\\n    color = applyAllLightning(color, opacities[component], posVC,\\n                              normalLights[component]);\\n    colors[component] = color;\\n  }\\n  vec3 mixedColor =\\n      (opacities[0] * colors[0] + opacities[1] * colors[1]) / opacitySum;\\n  return vec4(mixedColor, min(1.0, opacitySum));\\n}\\n\\nvec4 getColorForColorizePreset(vec4 tValue, vec3 posVC, vec3 posIS) {\\n  // compute normals\\n  mat4 normalMat = computeMat4Normal(posIS, tValue);\\n  vec4 normalLight = normalMat[0];\\n  #if vtkNumberOfLights > 0\\n    if (volume.computeNormalFromOpacity == 1) {\\n      vec3 scalarInterp[2];\\n      float height = volume.transferFunctionsSampleHeight[0];\\n      computeNormalForDensity(posIS, scalarInterp, 0);\\n      normalLight = computeDensityNormal(scalarInterp, height, 1.0, 0);\\n    }\\n  #endif\\n\\n  // compute opacities\\n  float opacity = getOpacityFromTexture(\\n      tValue[0], 0, volume.transferFunctionsSampleHeight[0]);\\n  #ifdef EnabledGradientOpacity\\n    opacity *= computeGradientOpacityFactor(normalMat[0].a, 0);\\n  #endif\\n\\n  // colorizing component\\n  vec3 colorizingColor = getColorFromTexture(\\n      tValue[0], 1, volume.transferFunctionsSampleHeight[1]);\\n  float colorizingOpacity = getOpacityFromTexture(\\n      tValue[1], 1, volume.transferFunctionsSampleHeight[1]);\\n\\n  // mix the colors and opacities\\n  vec3 color =\\n      getColorFromTexture(tValue[0], 0,\\n                          volume.transferFunctionsSampleHeight[0]) *\\n      mix(vec3(1.0), colorizingColor, colorizingOpacity);\\n  color = applyAllLightning(color, opacity, posVC, normalLight);\\n  return vec4(color, opacity);\\n}\\n\\nvec4 getColorForDefaultIndependentPreset(vec4 tValue, vec3 posIS) {\\n\\n  // compute the normal vectors as needed\\n  #if defined(EnabledGradientOpacity) || vtkNumberOfLights > 0\\n    mat4 normalMat = computeMat4Normal(posIS, tValue);\\n  #endif\\n\\n  // process color and opacity for each component\\n  // initial value of alpha is determined by wether the first component is\\n  // proportional or not\\n  #if defined(vtkComponent0Proportional)\\n    // when it is proportional, it starts at 1 (neutral for multiplications)\\n    float alpha = 1.0;\\n  #else\\n    // when it is not proportional, it starts at 0 (neutral for additions)\\n    float alpha = 0.0;\\n  #endif\\n\\n  vec3 mixedColor = vec3(0.0);\\n  #if vtkNumberOfComponents > 0\\n    {\\n      const int component = 0;\\n      vec3 color = getColorFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      float opacity = getOpacityFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      #if !defined(vtkComponent0Proportional)\\n        float alphaContribution = volume.independentComponentMix[component] * opacity;\\n        #ifdef EnabledGradientOpacity\\n          alphaContribution *= computeGradientOpacityFactor(normalMat[component].a, component);\\n        #endif\\n        alpha += alphaContribution;\\n        #if vtkNumberOfLights > 0\\n          color = applyLighting(color, normalMat[component]);\\n        #endif\\n      #else\\n        color *= opacity;\\n        alpha *= mix(opacity, 1.0,\\n                    (1.0 - volume.independentComponentMix[component]));\\n      #endif\\n      mixedColor += volume.independentComponentMix[component] * color;\\n    }\\n  #endif\\n  #if vtkNumberOfComponents > 1\\n    {\\n      const int component = 1;\\n      vec3 color = getColorFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      float opacity = getOpacityFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      #if !defined(vtkComponent1Proportional)\\n        float alphaContribution = volume.independentComponentMix[component] * opacity;\\n        #ifdef EnabledGradientOpacity\\n          alphaContribution *= computeGradientOpacityFactor(normalMat[component].a, component);\\n        #endif\\n        alpha += alphaContribution;\\n        #if vtkNumberOfLights > 0\\n          color = applyLighting(color, normalMat[component]);\\n        #endif\\n      #else\\n        color *= opacity;\\n        alpha *= mix(opacity, 1.0,\\n                    (1.0 - volume.independentComponentMix[component]));\\n      #endif\\n      mixedColor += volume.independentComponentMix[component] * color;\\n    }\\n  #endif\\n  #if vtkNumberOfComponents > 2\\n    {\\n      const int component = 2;\\n      vec3 color = getColorFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      float opacity = getOpacityFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      #if !defined(vtkComponent2Proportional)\\n        float alphaContribution = volume.independentComponentMix[component] * opacity;\\n        #ifdef EnabledGradientOpacity\\n          alphaContribution *= computeGradientOpacityFactor(normalMat[component].a, component);\\n        #endif\\n        alpha += alphaContribution;\\n        #if vtkNumberOfLights > 0\\n          color = applyLighting(color, normalMat[component]);\\n        #endif\\n      #else\\n        color *= opacity;\\n        alpha *= mix(opacity, 1.0,\\n                    (1.0 - volume.independentComponentMix[component]));\\n      #endif\\n      mixedColor += volume.independentComponentMix[component] * color;\\n    }\\n  #endif\\n  #if vtkNumberOfComponents > 3\\n    {\\n      const int component = 3;\\n      vec3 color = getColorFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      float opacity = getOpacityFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      #if !defined(vtkComponent3Proportional)\\n        float alphaContribution = volume.independentComponentMix[component] * opacity;\\n        #ifdef EnabledGradientOpacity\\n          alphaContribution *= computeGradientOpacityFactor(normalMat[component].a, component);\\n        #endif\\n        alpha += alphaContribution;\\n        #if vtkNumberOfLights > 0\\n          color = applyLighting(color, normalMat[component]);\\n        #endif\\n      #else\\n        color *= opacity;\\n        alpha *= mix(opacity, 1.0,\\n                    (1.0 - volume.independentComponentMix[component]));\\n      #endif\\n      mixedColor += volume.independentComponentMix[component] * color;\\n    }\\n  #endif\\n\\n  return vec4(mixedColor, alpha);\\n}\\n\\nvec4 getColorForDependentComponents(vec4 tValue, vec3 posVC, vec3 posIS) {\\n  #if defined(EnabledGradientOpacity) || vtkNumberOfLights > 0\\n    // use component 3 of the opacity texture as getTextureValue() sets alpha to\\n    // the opacity value\\n    vec3 scalarInterp[2];\\n    vec4 normal0 = computeNormalForDensity(posIS, scalarInterp, 3);\\n    float gradientOpacity = computeGradientOpacityFactor(normal0.a, 0);\\n  #endif\\n\\n  // get color and opacity\\n  #if vtkNumberOfComponents == 1\\n    vec3 tColor = getColorFromTexture(tValue.r, 0, 0.5);\\n    float alpha = getOpacityFromTexture(tValue.r, 0, 0.5);\\n  #endif\\n  #if vtkNumberOfComponents == 2\\n    vec3 tColor = vec3(tValue.r * volume.colorTextureScale[0] +\\n                  volume.colorTextureShift[0]);\\n    float alpha = getOpacityFromTexture(tValue.a, 1, 0.5);\\n  #endif\\n  #if vtkNumberOfComponents == 3\\n      vec3 tColor = tValue.rgb * volume.colorTextureScale.rgb +\\n              volume.colorTextureShift.rgb;\\n      float alpha = getOpacityFromTexture(tValue.a, 0, 0.5);\\n  #endif\\n  #if vtkNumberOfComponents == 4\\n      vec3 tColor = tValue.rgb * volume.colorTextureScale.rgb +\\n              volume.colorTextureShift.rgb;\\n      float alpha = getOpacityFromTexture(tValue.a, 3, 0.5);\\n  #endif\\n\\n  // Apply gradient opacity\\n  #if defined(EnabledGradientOpacity)\\n    alpha *= gradientOpacity;\\n  #endif\\n\\n  #if vtkNumberOfComponents == 1\\n    if (alpha < EPSILON) {\\n      return vec4(0.0);\\n    }\\n  #endif\\n\\n  // lighting\\n  #if vtkNumberOfLights > 0\\n    vec4 normalLight;\\n    if (volume.computeNormalFromOpacity == 1) {\\n      if (normal0[3] != 0.0) {\\n        normalLight =\\n            computeDensityNormal(scalarInterp, 0.5, gradientOpacity, 0);\\n        if (normalLight[3] == 0.0) {\\n          normalLight = normal0;\\n        }\\n      }\\n    } else {\\n      normalLight = normal0;\\n    }\\n    tColor = applyAllLightning(tColor, alpha, posVC, normalLight);\\n  #endif\\n\\n  return vec4(tColor, alpha);\\n}\\n\\nvec4 getColorForValue(vec4 tValue, vec3 posVC, vec3 posIS) {\\n  #ifdef EnableColorForValueFunctionId0\\n    return getColorForDependentComponents(tValue, posVC, posIS);\\n  #endif\\n\\n  #ifdef EnableColorForValueFunctionId1\\n    return getColorForAdditivePreset(tValue, posVC, posIS);\\n  #endif\\n\\n  #ifdef EnableColorForValueFunctionId2\\n    return getColorForColorizePreset(tValue, posVC, posIS);\\n  #endif\\n\\n  #ifdef EnableColorForValueFunctionId3\\n    /*\\n      * Mix the color information from all the independent components to get a\\n      * single rgba output. See other shader functions like\\n      * `getColorForAdditivePreset` to learn how to create a custom color mix.\\n      * The custom color mix should return a value, but if it doesn't, it will\\n      * fallback on the default shading\\n      */\\n    //VTK::CustomColorMix\\n  #endif\\n\\n  #if defined(EnableColorForValueFunctionId4) || defined(EnableColorForValueFunctionId3)\\n    return getColorForDefaultIndependentPreset(tValue, posIS);\\n  #endif\\n\\n  #ifdef EnableColorForValueFunctionId5\\n    return getColorForLabelOutline();\\n  #endif\\n}\\n\\nbool valueWithinScalarRange(vec4 val) {\\n  #if vtkNumberOfComponents > 1 && !defined(EnabledIndependentComponents)\\n    return false;\\n  #endif\\n  vec4 rangeMin = volume.ipScalarRangeMin;\\n  vec4 rangeMax = volume.ipScalarRangeMax;\\n  for (int component = 0; component < vtkNumberOfComponents; ++component) {\\n    if (val[component] < rangeMin[component] ||\\n        rangeMax[component] < val[component]) {\\n      return false;\\n    }\\n  }\\n  return true;\\n}\\n\\n#if vtkBlendMode == LABELMAP_EDGE_PROJECTION_BLEND\\n  bool checkOnEdgeForNeighbor(int xFragmentOffset, int yFragmentOffset,\\n                              int segmentIndex, vec3 stepIS) {\\n    vec3 volumeDimensions = vec3(volume.dimensions);\\n    vec4 neighborPixelCoord = vec4(gl_FragCoord.x + float(xFragmentOffset),\\n                                  gl_FragCoord.y + float(yFragmentOffset),\\n                                  gl_FragCoord.z, gl_FragCoord.w);\\n    vec3 originalNeighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);\\n\\n    vec3 neighborPosIS = originalNeighborPosIS;\\n    for (int k = 0; k < vtkMaximumNumberOfSamples / 2; ++k) {\\n      ivec3 texCoord = ivec3(neighborPosIS * volumeDimensions);\\n      vec4 texValue = rawFetchTexture(texCoord);\\n      if (int(texValue.g) == segmentIndex) {\\n        // not on edge\\n        return false;\\n      }\\n      neighborPosIS += stepIS;\\n    }\\n\\n    neighborPosIS = originalNeighborPosIS;\\n    for (int k = 0; k < vtkMaximumNumberOfSamples / 2; ++k) {\\n      ivec3 texCoord = ivec3(neighborPosIS * volumeDimensions);\\n      vec4 texValue = rawFetchTexture(texCoord);\\n      if (int(texValue.g) == segmentIndex) {\\n        // not on edge\\n        return false;\\n      }\\n      neighborPosIS -= stepIS;\\n    }\\n\\n    // onedge\\n    float sampleHeight = volume.transferFunctionsSampleHeight[1];\\n    vec3 tColorSegment =\\n        getColorFromTexture(float(segmentIndex), 1, sampleHeight);\\n    float pwfValueSegment =\\n        getOpacityFromTexture(float(segmentIndex), 1, sampleHeight);\\n    gl_FragData[0] = vec4(tColorSegment, pwfValueSegment);\\n    return true;\\n  }\\n#endif\\n\\nvec4 getColorAtPos(vec3 posVC) {\\n  vec3 posIS = posVCtoIS(posVC);\\n  vec4 texValue = getTextureValue(posIS);\\n  return getColorForValue(texValue, posVC, posIS);\\n}\\n\\n//=======================================================================\\n// Apply the specified blend mode operation along the ray's path.\\n//\\nvoid applyBlend(vec3 rayOriginVC, vec3 rayDirVC, float minDistance,\\n                float maxDistance) {\\n  // start slightly inside and apply some jitter\\n  vec3 stepVC = rayDirVC * sampleDistance;\\n  float raySteps = (maxDistance - minDistance) / sampleDistance;\\n\\n  // Avoid 0.0 jitter\\n  float jitter = 0.01 + 0.99 * fragmentSeed;\\n\\n  #if vtkBlendMode == COMPOSITE_BLEND\\n    // now map through opacity and color\\n    vec3 firstPosVC = rayOriginVC + minDistance * rayDirVC;\\n    vec4 firstColor = getColorAtPos(firstPosVC);\\n\\n    // handle very thin volumes\\n    if (raySteps <= 1.0) {\\n      firstColor.a = 1.0 - pow(1.0 - firstColor.a, raySteps);\\n      gl_FragData[0] = firstColor;\\n      return;\\n    }\\n\\n    // first color only counts for `jitter` factor of the step\\n    firstColor.a = 1.0 - pow(1.0 - firstColor.a, jitter);\\n    vec4 color = vec4(firstColor.rgb * firstColor.a, firstColor.a);\\n    vec3 posVC = firstPosVC + jitter * stepVC;\\n    float stepsTraveled = jitter;\\n\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      // If we have reached the last step, break\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n      vec4 tColor = getColorAtPos(posVC);\\n\\n      color = color + vec4(tColor.rgb * tColor.a, tColor.a) * (1.0 - color.a);\\n      stepsTraveled++;\\n      posVC += stepVC;\\n      if (color.a > 0.99) {\\n        color.a = 1.0;\\n        break;\\n      }\\n    }\\n\\n    if (color.a < 0.99 && (raySteps - stepsTraveled) > 0.0) {\\n      vec3 endPosVC = rayOriginVC + maxDistance * rayDirVC;\\n      vec4 tColor = getColorAtPos(endPosVC);\\n      tColor.a = 1.0 - pow(1.0 - tColor.a, raySteps - stepsTraveled);\\n\\n      float mix = (1.0 - color.a);\\n      color = color + vec4(tColor.rgb * tColor.a, tColor.a) * mix;\\n    }\\n\\n    gl_FragData[0] = vec4(color.rgb / color.a, color.a);\\n  #endif\\n\\n  #if vtkBlendMode == MAXIMUM_INTENSITY_BLEND ||                                 \\\\\\n      vtkBlendMode == MINIMUM_INTENSITY_BLEND\\n    // Find maximum/minimum intensity along the ray.\\n\\n    // Define the operation we will use (min or max)\\n    #if vtkBlendMode == MAXIMUM_INTENSITY_BLEND\\n      #define OP max\\n    #else\\n      #define OP min\\n    #endif\\n\\n    vec3 posVC = rayOriginVC + minDistance * rayDirVC;\\n    float stepsTraveled = 0.0;\\n\\n    // Find a value to initialize the selected variables\\n    vec4 selectedValue;\\n    vec3 selectedPosVC;\\n    vec3 selectedPosIS;\\n    {\\n      vec3 posIS = posVCtoIS(posVC);\\n      selectedValue = getTextureValue(posIS);\\n      selectedPosVC = posVC;\\n      selectedPosIS = posIS;\\n    }\\n\\n    // If the clipping range is shorter than the sample distance\\n    // we can skip the sampling loop along the ray.\\n    if (raySteps <= 1.0) {\\n      gl_FragData[0] = getColorForValue(selectedValue, selectedPosVC, selectedPosIS);\\n      return;\\n    }\\n\\n    posVC += jitter * stepVC;\\n    stepsTraveled += jitter;\\n\\n    // Sample along the ray until vtkMaximumNumberOfSamples,\\n    // ending slightly inside the total distance\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      // If we have reached the last step, break\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n\\n      // Get selected values\\n      vec3 posIS = posVCtoIS(posVC);\\n      vec4 previousSelectedValue = selectedValue;\\n      vec4 currentValue = getTextureValue(posIS);\\n      selectedValue = OP(selectedValue, currentValue);\\n      if (previousSelectedValue != selectedValue) {\\n        selectedPosVC = posVC;\\n        selectedPosIS = posIS;\\n      }\\n\\n      // Otherwise, continue along the ray\\n      stepsTraveled++;\\n      posVC += stepVC;\\n    }\\n\\n    // Perform the last step along the ray using the\\n    // residual distance\\n    posVC = rayOriginVC + maxDistance * rayDirVC;\\n    {\\n      vec3 posIS = posVCtoIS(posVC);\\n      vec4 previousSelectedValue = selectedValue;\\n      vec4 currentValue = getTextureValue(posIS);\\n      selectedValue = OP(selectedValue, currentValue);\\n      if (previousSelectedValue != selectedValue) {\\n        selectedPosVC = posVC;\\n        selectedPosIS = posIS;\\n      }\\n    }\\n\\n    gl_FragData[0] = getColorForValue(selectedValue, selectedPosVC, selectedPosIS);\\n  #endif\\n\\n  #if vtkBlendMode == ADDITIVE_INTENSITY_BLEND ||                                \\\\\\n      vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n    vec4 sum = vec4(0.);\\n    #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n      float totalWeight = 0.0;\\n    #endif\\n    vec3 posVC = rayOriginVC + minDistance * rayDirVC;\\n    float stepsTraveled = 0.0;\\n\\n    vec3 posIS = posVCtoIS(posVC);\\n    vec4 value = getTextureValue(posIS);\\n\\n    if (raySteps <= 1.0) {\\n      gl_FragData[0] = getColorForValue(value * raySteps, posVC, posIS);\\n      return;\\n    }\\n\\n    if (valueWithinScalarRange(value)) {\\n      sum += value * jitter;\\n      #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n        totalWeight += jitter;\\n      #endif\\n    }\\n    posVC += jitter * stepVC;\\n    stepsTraveled += jitter;\\n\\n    // Sample along the ray until vtkMaximumNumberOfSamples,\\n    // ending slightly inside the total distance\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      // If we have reached the last step, break\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n\\n      posIS = posVCtoIS(posVC);\\n      value = getTextureValue(posIS);\\n      // One can control the scalar range by setting the AverageIPScalarRange to\\n      // disregard scalar values, not in the range of interest, from the average\\n      // computation. Notes:\\n      // - We are comparing all values in the texture to see if any of them\\n      //   are outside of the scalar range. In the future we might want to allow\\n      //   scalar ranges for each component.\\n      if (valueWithinScalarRange(value)) {\\n        sum += value;\\n        #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n          totalWeight++;\\n        #endif\\n      }\\n\\n      stepsTraveled++;\\n      posVC += stepVC;\\n    }\\n\\n    // Perform the last step along the ray using the\\n    // residual distance\\n    posVC = rayOriginVC + maxDistance * rayDirVC;\\n    posIS = posVCtoIS(posVC);\\n    value = getTextureValue(posIS);\\n    if (valueWithinScalarRange(value)) {\\n      sum += value;\\n      #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n        totalWeight += raySteps - stepsTraveled;\\n      #endif\\n    }\\n\\n    #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n      sum /= vec4(totalWeight, totalWeight, totalWeight, 1.0);\\n    #endif\\n\\n    gl_FragData[0] = getColorForValue(sum, posVC, posIS);\\n  #endif\\n\\n  #if vtkBlendMode == RADON_TRANSFORM_BLEND\\n    float normalizedRayIntensity = 1.0;\\n    vec3 posVC = rayOriginVC + minDistance * rayDirVC;\\n    float stepsTraveled = 0.0;\\n\\n    // handle very thin volumes\\n    if (raySteps <= 1.0) {\\n      vec3 posIS = posVCtoIS(posVC);\\n      vec4 tValue = getTextureValue(posIS);\\n      normalizedRayIntensity -= raySteps * sampleDistance *\\n                                getOpacityFromTexture(tValue.r, 0, 0.5);\\n      gl_FragData[0] =\\n          vec4(getColorFromTexture(normalizedRayIntensity, 0, 0.5), 1.0);\\n      return;\\n    }\\n\\n    posVC += jitter * stepVC;\\n    stepsTraveled += jitter;\\n\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n\\n      vec3 posIS = posVCtoIS(posVC);\\n      vec4 value = getTextureValue(posIS);\\n      // Convert scalar value to normalizedRayIntensity coefficient and\\n      // accumulate normalizedRayIntensity\\n      normalizedRayIntensity -=\\n          sampleDistance * getOpacityFromTexture(value.r, 0, 0.5);\\n\\n      posVC += stepVC;\\n      stepsTraveled++;\\n    }\\n\\n    // map normalizedRayIntensity to color\\n    gl_FragData[0] =\\n        vec4(getColorFromTexture(normalizedRayIntensity, 0, 0.5), 1.0);\\n  #endif\\n\\n  #if vtkBlendMode == LABELMAP_EDGE_PROJECTION_BLEND\\n    // Only works with a single volume\\n    vec3 posVC = rayOriginVC + minDistance * rayDirVC;\\n    float stepsTraveled = 0.0;\\n    vec3 posIS = posVCtoIS(posVC);\\n    vec4 tValue = getTextureValue(posIS);\\n    if (raySteps <= 1.0) {\\n      gl_FragData[0] = getColorForValue(tValue, posVC, posIS);\\n      return;\\n    }\\n\\n    vec3 stepIS = vecVCToIS(stepVC);\\n    vec4 value = tValue;\\n    posIS += jitter * stepIS;\\n    stepsTraveled += jitter;\\n    vec3 maxPosIS = posIS; // Store the position of the max value\\n    int segmentIndex = int(value.g);\\n    bool originalPosHasSeenNonZero = false;\\n\\n    if (segmentIndex != 0) {\\n      // Tried using the segment index in an boolean array but reading\\n      // from the array by dynamic indexing was horrondously slow\\n      // so use bit masking instead and assign 1 to the bit corresponding to the\\n      // segment index and later check if the bit is set via bit operations\\n      setLabelOutlineBit(segmentIndex);\\n    }\\n\\n    // Sample along the ray until vtkMaximumNumberOfSamples,\\n    // ending slightly inside the total distance\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      // If we have reached the last step, break\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n\\n      // compute the scalar\\n      tValue = getTextureValue(posIS);\\n      segmentIndex = int(tValue.g);\\n\\n      if (segmentIndex != 0) {\\n        originalPosHasSeenNonZero = true;\\n        setLabelOutlineBit(segmentIndex);\\n      }\\n\\n      if (tValue.r > value.r) {\\n        value = tValue;   // Update the max value\\n        maxPosIS = posIS; // Update the position where max occurred\\n      }\\n\\n      // Otherwise, continue along the ray\\n      stepsTraveled++;\\n      posIS += stepIS;\\n    }\\n\\n    // Perform the last step along the ray using the\\n    // residual distance\\n    posIS = posVCtoIS(rayOriginVC + maxDistance * rayDirVC);\\n    tValue = getTextureValue(posIS);\\n\\n    if (tValue.r > value.r) {\\n      value = tValue;   // Update the max value\\n      maxPosIS = posIS; // Update the position where max occurred\\n    }\\n\\n    // If we have not seen any non-zero segments, we can return early\\n    // and grab color from the actual center value first component (image)\\n    if (!originalPosHasSeenNonZero) {\\n      vec3 maxPosVC = posIStoVC(maxPosIS);\\n      gl_FragData[0] = getColorForValue(value, maxPosVC, maxPosIS);\\n      return;\\n    }\\n\\n    vec3 neighborRayStepsIS = stepIS;\\n    float neighborRaySteps = raySteps;\\n    bool shouldLookInAllNeighbors = false;\\n\\n    vec3 volumeSpacings = volume.spacing;\\n    float minVoxelSpacing =\\n        min(volumeSpacings[0], min(volumeSpacings[1], volumeSpacings[2]));\\n    vec4 base =\\n        vec4(gl_FragCoord.x, gl_FragCoord.y, gl_FragCoord.z, gl_FragCoord.w);\\n\\n    vec4 baseXPlus = vec4(gl_FragCoord.x + 1.0, gl_FragCoord.y, gl_FragCoord.z,\\n                          gl_FragCoord.w);\\n    vec4 baseYPlus = vec4(gl_FragCoord.x, gl_FragCoord.y + 1.0, gl_FragCoord.z,\\n                          gl_FragCoord.w);\\n\\n    vec3 baseWorld = fragCoordToWorld(base);\\n    vec3 baseXPlusWorld = fragCoordToWorld(baseXPlus);\\n    vec3 baseYPlusWorld = fragCoordToWorld(baseYPlus);\\n\\n    float XPlusDiff = length(baseXPlusWorld - baseWorld);\\n    float YPlusDiff = length(baseYPlusWorld - baseWorld);\\n\\n    float minFragSpacingWorld = min(XPlusDiff, YPlusDiff);\\n\\n    for (int s = 1; s < MAX_SEGMENT_INDEX; s++) {\\n      // bail out quickly if the segment index has not\\n      // been seen by the center segment\\n      if (!isLabelOutlineBitSet(s)) {\\n        continue;\\n      }\\n\\n      // Use texture sampling for outlineThickness so that we can have\\n      // per segment thickness\\n      float textureCoordinate = float(s - 1) / 1024.0;\\n      float textureValue =\\n          texture2D(labelOutlineThicknessTexture, vec2(textureCoordinate, 0.5)).r;\\n\\n      int actualThickness = int(textureValue * 255.0);\\n\\n      // check the extreme points in the neighborhood since there is a better\\n      // chance of finding the edge there, so that we can bail out\\n      // faster if we find the edge\\n      bool onEdge = checkOnEdgeForNeighbor(-actualThickness, -actualThickness, s,\\n                                          stepIS) ||\\n                    checkOnEdgeForNeighbor(actualThickness, actualThickness, s,\\n                                          stepIS) ||\\n                    checkOnEdgeForNeighbor(actualThickness, -actualThickness, s,\\n                                          stepIS) ||\\n                    checkOnEdgeForNeighbor(-actualThickness, +actualThickness, s,\\n                                          stepIS);\\n\\n      if (onEdge) {\\n        return;\\n      }\\n\\n      // since the next step is computationally expensive, we need to perform\\n      // some optimizations to avoid it if possible. One of the optimizations\\n      // is to check the whether the minimum of the voxel spacing is greater than\\n      // the 2 * the thickness of the outline segment. If that is the case\\n      // then we can safely skip the next step since we can be sure that the\\n      // the previous 4 checks on the extreme points would caught the entirety\\n      // of the all the fragments inside. i.e., this happens when we zoom out,\\n      if (minVoxelSpacing >\\n          (2.0 * float(actualThickness) - 1.0) * minFragSpacingWorld) {\\n        continue;\\n      }\\n\\n      // Loop through the rest, skipping the processed extremes and the center\\n      for (int i = -actualThickness; i <= actualThickness; i++) {\\n        for (int j = -actualThickness; j <= actualThickness; j++) {\\n          if (i == 0 && j == 0)\\n            continue; // Skip the center\\n          if (abs(i) == actualThickness && abs(j) == actualThickness)\\n            continue; // Skip corners\\n          if (checkOnEdgeForNeighbor(i, j, s, stepIS)) {\\n            return;\\n          }\\n        }\\n      }\\n    }\\n\\n    float sampleHeight = volume.transferFunctionsSampleHeight[0];\\n    vec3 tColor0 = getColorFromTexture(value.r, 0, sampleHeight);\\n    float pwfValue0 = getOpacityFromTexture(value.r, 0, sampleHeight);\\n    gl_FragData[0] = vec4(tColor0, pwfValue0);\\n  #endif\\n}\\n\\n//=======================================================================\\n// given a\\n// - ray direction (rayDir)\\n// - starting point (vertexVCVSOutput)\\n// - bounding planes of the volume\\n// - optionally depth buffer values\\n// - far clipping plane\\n// compute the start/end distances of the ray we need to cast\\nvec2 computeRayDistances(vec3 rayOriginVC, vec3 rayDirVC) {\\n  vec2 dists = rayIntersectVolumeDistances(rayOriginVC, rayDirVC);\\n\\n  //VTK::ClipPlane::Impl\\n\\n  // do not go behind front clipping plane\\n  dists.x = max(0.0, dists.x);\\n\\n  // do not go PAST far clipping plane\\n  float farDist = -camThick / rayDirVC.z;\\n  dists.y = min(farDist, dists.y);\\n\\n  // Do not go past the zbuffer value if set\\n  // This is used for intermixing opaque geometry\\n  //VTK::ZBuffer::Impl\\n\\n  return dists;\\n}\\n\\nfloat getFragmentSeed() {\\n  // This first noise has a diagonal pattern\\n  float firstNoise =\\n      fract(sin(dot(gl_FragCoord.xy, vec2(12.9898, 78.233))) * 43758.5453);\\n  // This second noise is made out of blocks of CPU generated noise\\n  float secondNoise = texture2D(jtexture, gl_FragCoord.xy / 32.0).r;\\n  // Combine the two sources of noise in a way that the distribution is uniform\\n  // in [0,1[\\n  float noiseSum = firstNoise + secondNoise;\\n  return noiseSum < 1.0 ? noiseSum : noiseSum - 1.0;\\n}\\n\\nvoid main() {\\n  fragmentSeed = getFragmentSeed();\\n\\n  if (cameraParallel == 1) {\\n    // Camera is parallel, so the rayDir is just the direction of the camera.\\n    rayDirVC = vec3(0.0, 0.0, -1.0);\\n  } else {\\n    // camera is at 0,0,0 so rayDir for perspective is just the vc coord\\n    rayDirVC = normalize(vertexVCVSOutput);\\n  }\\n\\n  vec3 rayOriginVC = vertexVCVSOutput;\\n  vec2 rayStartEndDistancesVC = computeRayDistances(rayOriginVC, rayDirVC);\\n  if (rayStartEndDistancesVC[1] <= rayStartEndDistancesVC[0] ||\\n      rayStartEndDistancesVC[1] <= 0.0) {\\n    // Volume not hit or behind the ray\\n    discard;\\n  }\\n\\n  // Perform the blending operation along the ray\\n  applyBlend(rayOriginVC, rayDirVC, rayStartEndDistancesVC[0], rayStartEndDistancesVC[1]);\\n}\\n&quot;,e.Geometry=&quot;&quot;},e.replaceShaderValues=(e,n,r)=>{let o=e.Fragment;o=td.substitute(o,&quot;//VTK::EnabledColorFunctions&quot;,`#define EnableColorForValueFunctionId${t.previousState.colorForValueFunctionId}`).result;const a=[];t.previousState.surfaceLightingEnabled&&a.push(&quot;Surface&quot;),t.previousState.volumeLightingEnabled&&a.push(&quot;Volume&quot;),o=td.substitute(o,&quot;//VTK::EnabledLightings&quot;,a.map((e=>`#define Enable${e}Lighting`))).result,t.previousState.multiTexturePerVolumeEnabled&&(o=td.substitute(o,&quot;//VTK::EnabledMultiTexturePerVolume&quot;,&quot;#define EnabledMultiTexturePerVolume&quot;).result),t.previousState.useIndependentComponents&&(o=td.substitute(o,&quot;//VTK::EnabledIndependentComponents&quot;,&quot;#define EnabledIndependentComponents&quot;).result),t.previousState.gradientOpacityEnabled&&(o=td.substitute(o,&quot;//VTK::EnabledGradientOpacity&quot;,&quot;#define EnabledGradientOpacity&quot;).result),o=td.substitute(o,&quot;//VTK::vtkProportionalComponents&quot;,t.previousState.proportionalComponents.map((e=>`#define vtkComponent${e}Proportional`)).join(&quot;\\n&quot;)).result,o=td.substitute(o,&quot;//VTK::vtkForceNearestComponents&quot;,t.previousState.forceNearestComponents.map((e=>`#define vtkComponent${e}ForceNearest`)).join(&quot;\\n&quot;)).result,t.previousState.hasZBufferTexture&&(o=td.substitute(o,&quot;//VTK::ZBuffer::Dec&quot;,[&quot;uniform sampler2D zBufferTexture;&quot;,&quot;uniform float vpZWidth;&quot;,&quot;uniform float vpZHeight;&quot;]).result,o=td.substitute(o,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;vec4 depthVec = texture2D(zBufferTexture, vec2(gl_FragCoord.x / vpZWidth, gl_FragCoord.y/vpZHeight));&quot;,&quot;float zdepth = (depthVec.r*256.0 + depthVec.g)/257.0;&quot;,&quot;zdepth = zdepth * 2.0 - 1.0;&quot;,&quot;if (cameraParallel == 0) {&quot;,&quot;zdepth = -2.0 * camFar * camNear / (zdepth*(camFar-camNear)-(camFar+camNear)) - camNear;}&quot;,&quot;else {&quot;,&quot;zdepth = (zdepth + 1.0) * 0.5 * (camFar - camNear);}\\n&quot;,&quot;zdepth = -zdepth/rayDirVC.z;&quot;,&quot;dists.y = min(zdepth,dists.y);&quot;]).result),o=td.substitute(o,&quot;//VTK::BlendMode&quot;,`${t.previousState.blendMode}`).result,o=td.substitute(o,&quot;//VTK::NumberOfLights&quot;,`${t.previousState.numberOfLights}`).result,o=td.substitute(o,&quot;//VTK::MaxLaoKernelSize&quot;,`${t.previousState.maxLaoKernelSize}`).result,o=td.substitute(o,&quot;//VTK::NumberOfComponents&quot;,`${t.previousState.numberOfComponents}`).result,o=td.substitute(o,&quot;//VTK::MaximumNumberOfSamples&quot;,`${t.previousState.maximumNumberOfSamples}`).result,e.Fragment=o;const i=t.previousState.numberOfClippingPlanes;i>0&&(o=td.substitute(o,&quot;//VTK::ClipPlane::Dec&quot;,[&quot;uniform vec3 vClipPlaneNormals[6];&quot;,&quot;uniform float vClipPlaneDistances[6];&quot;,&quot;uniform vec3 vClipPlaneOrigins[6];&quot;,&quot;uniform int clip_numPlanes;&quot;,&quot;//VTK::ClipPlane::Dec&quot;,&quot;#define vtkClippingPlanesOn&quot;],!1).result,o=td.substitute(o,&quot;//VTK::ClipPlane::Impl&quot;,[`for(int i = 0; i < ${i}; i++) {`,&quot;  float rayDirRatio = dot(rayDirVC, vClipPlaneNormals[i]);&quot;,&quot;  float equationResult = dot(vertexVCVSOutput, vClipPlaneNormals[i]) + vClipPlaneDistances[i];&quot;,&quot;  if (rayDirRatio == 0.0)&quot;,&quot;  {&quot;,&quot;    if (equationResult < 0.0) dists.x = dists.y;&quot;,&quot;    continue;&quot;,&quot;  }&quot;,&quot;  float result = -1.0 * equationResult / rayDirRatio;&quot;,&quot;  if (rayDirRatio < 0.0) dists.y = min(dists.y, result);&quot;,&quot;  else dists.x = max(dists.x, result);&quot;,&quot;}&quot;,&quot;//VTK::ClipPlane::Impl&quot;],!1).result),e.Fragment=o},e.getNeedToRebuildShaders=(r,o,a)=>{const i=!!t.zBufferTexture,s=t.currentValidInputs.length,l=t.numberOfLights,c=t.numberOfComponents,u=t.useIndependentComponents,d=a.getProperties(),p=t.currentValidInputs[0],f=d[p.inputIndex],g=s>1,m=p.imageData.getBounds(),h=Gi.getDiagonalLength(m),v=Math.ceil(h/e.getCurrentSampleDistance(o));v>t.renderable.getMaximumSamplesPerRay()&&ng(`The number of steps required ${v} is larger than the specified maximum number of steps ${t.renderable.getMaximumSamplesPerRay()}.\\nPlease either change the volumeMapper sampleDistance or its maximum number of samples.`);const T=u?c:1;let y=!1;for(let e=0;e<T;++e)if(f.getUseGradientOpacity(e)){y=!0;break}let b=0;const x=f.getLAOKernelSize();x>b&&f.getLocalAmbientOcclusion()&&f.getAmbient()>0&&(b=x);const C=t.renderable.getClippingPlanes().length,S=t.renderable.getViewSpecificProperties().OpenGL?.ShaderReplacements,A=t.currentRenderPass?.getShaderReplacement(),I=t.renderable.getBlendMode(),w=(()=>{if(I!==eg.LABELMAP_EDGE_PROJECTION_BLEND&&n(f))return 5;if(u)switch(f.getColorMixPreset()){case Qf.ADDITIVE:return 1;case Qf.COLORIZE:return 2;case Qf.CUSTOM:return 3;default:return 4}return 0})(),O=f.getVolumetricScatteringBlending()<1,P=f.getVolumetricScatteringBlending()>0;let R=!1;for(let e=0;e<c;++e)if(f.getForceNearestInterpolation(e)){R=!0;break}const M=[],E=[];for(let e=0;e<c;e++)f.getOpacityMode(e)===Zf.PROPORTIONAL&&M.push(e),f.getForceNearestInterpolation(e)&&E.push(e);const V={numberOfComponents:c,useIndependentComponents:u,proportionalComponents:M,forceNearestComponents:E,blendMode:I,numberOfLights:l,numberOfValidInputs:s,maximumNumberOfSamples:v,hasZBufferTexture:i,maxLaoKernelSize:b,numberOfClippingPlanes:C,mapperShaderReplacements:S,renderPassShaderReplacements:A,colorForValueFunctionId:w,surfaceLightingEnabled:O,volumeLightingEnabled:P,forceNearestInterpolationEnabled:R,multiTexturePerVolumeEnabled:g,gradientOpacityEnabled:y};return!(0!==r.getProgram()?.getHandle()&&t.previousState&&ke(t.previousState,V)||(t.previousState=V,0))},e.updateShaders=(n,r,o)=>{if(e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};e.buildShaders(a,r,o);const i=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==n.getProgram()&&(n.setProgram(i),n.getVAO().releaseGraphicsResources()),n.getShaderSourceTime().modified()}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(n.getProgram());n.getVAO().bind(),e.setMapperShaderParameters(n,r,o),e.setCameraShaderParameters(n,r,o),e.setPropertyShaderParameters(n,r,o),e.getClippingPlaneShaderParameters(n,r,o)},e.setMapperShaderParameters=(n,r,o)=>{const a=n.getProgram();n.getCABO().getElementCount()&&(t.VBOBuildTime.getMTime()>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())&&(a.isAttributeUsed(&quot;vertexDC&quot;)&&(n.getVAO().addAttributeArray(a,n.getCABO(),&quot;vertexDC&quot;,n.getCABO().getVertexOffset(),n.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||rg(&quot;Error setting vertexDC in shader VAO.&quot;)),n.getAttributeUpdateTime().modified());const i=e.getCurrentSampleDistance(r);a.setUniformf(&quot;sampleDistance&quot;,i);const s=i*t.renderable.getVolumeShadowSamplingDistFactor();a.setUniformf(&quot;volumeShadowSampleDistance&quot;,s),t.scalarTextures.forEach(((e,t)=>{a.setUniformi(`volumeTexture[${t}]`,e.getTextureUnit())}));const l=o.getProperties()[t.currentValidInputs[0].inputIndex].getIpScalarRange(),c=new Float32Array(4),u=new Float32Array(4),d=(e,t,n)=>{t?.dataComputedScale?.length&&(c[e]=l[0]*t.dataComputedScale[n]+t.dataComputedOffset[n],u[e]=l[1]*t.dataComputedScale[n]+t.dataComputedOffset[n],c[e]=(c[e]-t.offset[n])/t.scale[n],u[e]=(u[e]-t.offset[n])/t.scale[n])};if(t.previousState.multiTexturePerVolumeEnabled)t.scalarTextures.forEach(((e,t)=>{const n=e.getVolumeInfo();d(t,n,0)}));else{const e=t.scalarTextures[0].getVolumeInfo();for(let t=0;t<4;++t)d(t,e,t)}const p=&quot;volume&quot;;if(a.setUniform4f(`${p}.ipScalarRangeMin`,c[0],c[1],c[2],c[3]),a.setUniform4f(`${p}.ipScalarRangeMax`,u[0],u[1],u[2],u[3]),null!==t.zBufferTexture){a.setUniformi(&quot;zBufferTexture&quot;,t.zBufferTexture.getTextureUnit());const e=t._useSmallViewport?[t._smallViewportWidth,t._smallViewportHeight]:t._openGLRenderWindow.getFramebufferSize();a.setUniformf(&quot;vpZWidth&quot;,e[0]),a.setUniformf(&quot;vpZHeight&quot;,e[1])}},e.setCameraShaderParameters=(r,o,a)=>{const{idxToView:i,vecISToVCMatrix:s,modelToView:l,projectionToView:c,projectionToWorld:u}=og,d=t.openGLCamera.getKeyMatrices(o),p=t.openGLVolume.getKeyMatrices();b(l,d.wcvc,p.mcwc);const f=r.getProgram(),g=t.openGLCamera.getRenderable(),m=g.getParallelProjection(),h=g.getClippingRange();f.setUniformf(&quot;camThick&quot;,h[1]-h[0]),f.setUniformf(&quot;camNear&quot;,h[0]),f.setUniformf(&quot;camFar&quot;,h[1]),f.setUniformi(&quot;cameraParallel&quot;,m);const T=t.currentValidInputs[0],y=T.imageData.getBounds(),x=Gi.getCorners(y,[]).map((e=>(In(e,e,l),m||bn(e,e,-h[0]/(e[2]*gn(e))),In(e,e,d.vcpc),e))),C=Gi.addPoints([...Gi.INIT_BOUNDS],x);f.setUniformf(&quot;dcxmin&quot;,C[0]),f.setUniformf(&quot;dcxmax&quot;,C[1]),f.setUniformf(&quot;dcymin&quot;,C[2]),f.setUniformf(&quot;dcymax&quot;,C[3]);const S=e.getRenderTargetSize();f.setUniformf(&quot;vpWidth&quot;,S[0]),f.setUniformf(&quot;vpHeight&quot;,S[1]);const A=e.getRenderTargetOffset();f.setUniformf(&quot;vpOffsetX&quot;,A[0]/S[0]),f.setUniformf(&quot;vpOffsetY&quot;,A[1]/S[1]),v(c,d.vcpc),f.setUniformMatrix(&quot;PCVCMatrix&quot;,c),f.setUniformi(&quot;twoSidedLighting&quot;,o.getTwoSidedLighting());const I=new Array(2*t.previousState.maxLaoKernelSize);for(let e=0;e<t.previousState.maxLaoKernelSize;e++)I[2*e]=Math.random(),I[2*e+1]=Math.random();if(f.setUniform2fv(&quot;kernelSample&quot;,I),t.numberOfLights>0){let e=0;o.getLights().forEach((t=>{if(t.getSwitch()>0){const n=`lights[${e}]`,r=bn([],t.getColor(),t.getIntensity());f.setUniform3fv(`${n}.color`,r);const o=t.getTransformedPosition();In(o,o,l),f.setUniform3fv(`${n}.positionVC`,o);const a=[...t.getDirection()];wn(a,a,d.normalMatrix),Cn(a,a),f.setUniform3fv(`${n}.directionVC`,a);const i=[-.5*a[0],-.5*a[1],-.5*(a[2]-1)];f.setUniform3fv(`${n}.halfAngleVC`,i);const s=t.getAttenuationValues();f.setUniform3fv(`${n}.attenuation`,s);const c=t.getExponent();f.setUniformf(`${n}.exponent`,c);const u=t.getConeAngle();f.setUniformf(`${n}.coneAngle`,u);const p=t.getPositional();f.setUniformi(`${n}.isPositional`,p),e++}}))}const w=&quot;volume&quot;,O=a.getProperties()[T.inputIndex],P=T.imageData,R=P.getSpatialExtent(),M=P.getSpacing(),E=P.getDimensions(),V=P.getIndexToWorld(),D=P.getWorldToIndex(),L=P.getDirectionByReference();b(i,l,V),f.setUniform3fv(`${w}.spacing`,M);const B=xn([],M);f.setUniform3fv(`${w}.inverseSpacing`,B),f.setUniform3iv(`${w}.dimensions`,E),f.setUniform3fv(`${w}.inverseDimensions`,xn([],E)),f.setUniformMatrix(`${w}.worldToIndex`,D),s.fill(0);const N=yn(new Float64Array(3),E,M);s[0]=N[0],s[4]=N[1],s[8]=N[2],Te(s,L,s),Te(s,p.normalMatrix,s),Te(s,d.normalMatrix,s),f.setUniformMatrix3x3(`${w}.vecISToVCMatrix`,s),f.setUniformMatrix3x3(`${w}.vecVCToISMatrix`,me(new Float32Array(9),s));const F=mn(R[0],R[2],R[4]),_=In(new Float64Array(3),F,i);f.setUniform3fv(`${w}.originVC`,_);const k=gn(N);if(f.setUniformf(`${w}.diagonalLength`,k),n(O)){const e=g.getDistance();g.setClippingRange(e,e+.1),v(u,t.openGLCamera.getKeyMatrices(o).wcpc),g.setClippingRange(h[0],h[1]),t.openGLCamera.getKeyMatrices(o),f.setUniformMatrix(`${w}.PCWCMatrix`,u)}if(O.getVolumetricScatteringBlending()>0&&(f.setUniformf(`${w}.globalIlluminationReach`,O.getGlobalIlluminationReach()),f.setUniformf(`${w}.volumetricScatteringBlending`,O.getVolumetricScatteringBlending()),f.setUniformf(`${w}.anisotropy`,O.getAnisotropy()),f.setUniformf(`${w}.anisotropySquared`,O.getAnisotropy()**2)),O.getLocalAmbientOcclusion()&&O.getAmbient()>0){const e=O.getLAOKernelSize();f.setUniformi(`${w}.kernelSize`,e);const t=O.getLAOKernelRadius();f.setUniformi(`${w}.kernelRadius`,t)}else f.setUniformi(`${w}.kernelSize`,0)},e.setPropertyShaderParameters=(e,n,r)=>{const o=e.getProgram();o.setUniformi(&quot;jtexture&quot;,t.jitterTexture.getTextureUnit());const a=r.getProperties();o.setUniformi(&quot;labelOutlineThicknessTexture&quot;,t.labelOutlineThicknessTexture.getTextureUnit()),o.setUniformi(&quot;opacityTexture&quot;,t.opacityTexture.getTextureUnit()),o.setUniformi(&quot;colorTexture&quot;,t.colorTexture.getTextureUnit());const i=&quot;volume&quot;,s=a[t.currentValidInputs[0].inputIndex],l=t.previousState.numberOfComponents,c=t.previousState.useIndependentComponents;if(c){const e=new Float32Array(4);for(let t=0;t<l;t++)e[t]=s.getComponentWeight(t);o.setUniform4fv(`${i}.independentComponentMix`,e);const t=new Float32Array(4),n=1/l;for(let e=0;e<l;++e)t[e]=(e+.5)*n;o.setUniform4fv(`${i}.transferFunctionsSampleHeight`,t)}const u=t.colorForValueFunctionId;o.setUniformi(`${i}.colorForValueFunctionId`,u);const d=s.getComputeNormalFromOpacity();o.setUniformi(`${i}.computeNormalFromOpacity`,d);const p=new Float32Array(4),f=new Float32Array(4),g=new Float32Array(4),m=new Float32Array(4);for(let e=0;e<l;e++){const n=t.previousState.multiTexturePerVolumeEnabled,r=n?e:0,o=n?0:e,a=t.scalarTextures[r].getVolumeInfo(),i=c?e:0,l=a.scale[o],u=s.getRGBTransferFunction(i).getRange();p[e]=l/(u[1]-u[0]),f[e]=(a.offset[o]-u[0])/(u[1]-u[0]);const d=s.getScalarOpacity(i).getRange();g[e]=l/(d[1]-d[0]),m[e]=(a.offset[o]-d[0])/(d[1]-d[0])}if(o.setUniform4fv(`${i}.colorTextureScale`,p),o.setUniform4fv(`${i}.colorTextureShift`,f),o.setUniform4fv(`${i}.opacityTextureScale`,g),o.setUniform4fv(`${i}.opacityTextureShift`,m),t.previousState.gradientOpacityEnabled){const e=new Array(4),n=new Array(4),r=new Array(4),a=new Array(4);if(c)for(let o=0;o<l;++o){const i=t.previousState.multiTexturePerVolumeEnabled,l=i?o:0,c=i?0:o,u=t.scalarTextures[l].getVolumeInfo().scale[c];if(s.getUseGradientOpacity(o)){const t=[s.getGradientOpacityMinimumOpacity(o),s.getGradientOpacityMaximumOpacity(o)],i=[s.getGradientOpacityMinimumValue(o),s.getGradientOpacityMaximumValue(o)];r[o]=t[0],a[o]=t[1],e[o]=u*(t[1]-t[0])/(i[1]-i[0]),n[o]=-i[0]*(t[1]-t[0])/(i[1]-i[0])+t[0]}else r[o]=1,a[o]=1,e[o]=0,n[o]=1}else{const o=l-1,i=t.previousState.multiTexturePerVolumeEnabled,c=i?o:0,u=i?0:o,d=t.scalarTextures[c].getVolumeInfo().scale[u],p=[s.getGradientOpacityMinimumOpacity(0),s.getGradientOpacityMaximumOpacity(0)],f=[s.getGradientOpacityMinimumValue(0),s.getGradientOpacityMaximumValue(0)];r[0]=p[0],a[0]=p[1],e[0]=d*(p[1]-p[0])/(f[1]-f[0]),n[0]=-f[0]*(p[1]-p[0])/(f[1]-f[0])+p[0]}o.setUniform4f(`${i}.gradientOpacityScale`,e),o.setUniform4f(`${i}.gradientOpacityShift`,n),o.setUniform4f(`${i}.gradientOpacityMin`,r),o.setUniform4f(`${i}.gradientOpacityMax`,a)}const h=s.getLabelOutlineOpacity();if(o.setUniformf(`${i}.outlineOpacity`,h),t.numberOfLights>0){o.setUniformf(`${i}.ambient`,s.getAmbient()),o.setUniformf(`${i}.diffuse`,s.getDiffuse()),o.setUniformf(`${i}.specular`,s.getSpecular());const e=s.getSpecularPower();o.setUniformf(`${i}.specularPower`,0===e?1:e)}},e.getClippingPlaneShaderParameters=(e,n,r)=>{if(t.renderable.getClippingPlanes().length>0){const r=t.openGLCamera.getKeyMatrices(n),o=[],a=[],i=[],s=t.renderable.getClippingPlanes(),l=s.length;for(let e=0;e<l;++e){const t=s[e].getNormal(),n=s[e].getOrigin();wn(t,t,r.normalMatrix),In(n,n,r.wcvc);const l=-1*Sn(n,t);o.push(t[0]),o.push(t[1]),o.push(t[2]),a.push(l),i.push(n[0]),i.push(n[1]),i.push(n[2])}const c=e.getProgram();c.setUniform3fv(&quot;vClipPlaneNormals&quot;,o),c.setUniformfv(&quot;vClipPlaneDistances&quot;,a),c.setUniform3fv(&quot;vClipPlaneOrigins&quot;,i),c.setUniformi(&quot;clip_numPlanes&quot;,l)}},e.delete=Et((()=>{t._animationRateSubscription&&(t._animationRateSubscription.unsubscribe(),t._animationRateSubscription=null)}),(()=>{t._openGLRenderWindow&&a(t._openGLRenderWindow)}),e.delete),e.getRenderTargetSize=()=>{if(t._useSmallViewport)return[t._smallViewportWidth,t._smallViewportHeight];const{usize:e,vsize:n}=t._openGLRenderer.getTiledSizeAndOrigin();return[e,n]},e.getRenderTargetOffset=()=>{const{lowerLeftU:e,lowerLeftV:n}=t._openGLRenderer.getTiledSizeAndOrigin();return[e,n]},e.getCurrentSampleDistance=e=>{const n=e.getVTKWindow().getInteractor(),r=t.renderable.getSampleDistance();return n.isAnimating()?r*t.renderable.getInteractionSampleDistanceFactor():r},e.renderPieceStart=(n,r)=>{const o=n.getVTKWindow().getInteractor();if(t._lastScale||(t._lastScale=t.renderable.getInitialInteractionScale()),t._useSmallViewport=!1,o.isAnimating()&&t._lastScale>1.5&&(t._useSmallViewport=!0),t._animationRateSubscription||(t._animationRateSubscription=o.onAnimationFrameRateUpdate((()=>{if(t.renderable.getAutoAdjustSampleDistances()){const e=o.getRecentAnimationFrameRate(),n=o.getDesiredUpdateRate()/e;(n>1.15||n<.85)&&(t._lastScale*=n),t._lastScale>400&&(t._lastScale=400),t._lastScale<1.5&&(t._lastScale=1.5)}else t._lastScale=t.renderable.getImageSampleDistance()*t.renderable.getImageSampleDistance()}))),t._useSmallViewport){const e=t._openGLRenderWindow.getFramebufferSize(),n=1/Math.sqrt(t._lastScale);if(t._smallViewportWidth=Math.ceil(n*e[0]),t._smallViewportHeight=Math.ceil(n*e[1]),t._smallViewportHeight>e[1]&&(t._smallViewportHeight=e[1]),t._smallViewportWidth>e[0]&&(t._smallViewportWidth=e[0]),t.framebuffer.saveCurrentBindingsAndBuffers(),null===t.framebuffer.getGLFramebuffer())t.framebuffer.create(e[0],e[1]),t.framebuffer.populateFramebuffer();else{const n=t.framebuffer.getSize();n&&n[0]===e[0]&&n[1]===e[1]||(t.framebuffer.create(e[0],e[1]),t.framebuffer.populateFramebuffer())}t.framebuffer.bind();const r=t.context;r.clearColor(0,0,0,0),r.colorMask(!0,!0,!0,!0),r.clear(r.COLOR_BUFFER_BIT),r.viewport(0,0,t._smallViewportWidth,t._smallViewportHeight),t.fvp=[t._smallViewportWidth/e[0],t._smallViewportHeight/e[1]]}t.context.disable(t.context.DEPTH_TEST),e.updateBufferObjects(n,r);const a=r.getProperties();t.currentValidInputs.forEach((e=>{let{inputIndex:n}=e;const r=a[n].getInterpolationType(),o=t.scalarTextures[n];r===Yf.NEAREST?(o.setMinificationFilter(ud.NEAREST),o.setMagnificationFilter(ud.NEAREST)):(o.setMinificationFilter(ud.LINEAR),o.setMagnificationFilter(ud.LINEAR))})),null!==t.zBufferTexture&&t.zBufferTexture.activate()},e.renderPieceDraw=(n,r)=>{const o=t.context,a=[...t.scalarTextures,t.colorTexture,t.opacityTexture,t.labelOutlineThicknessTexture,t.jitterTexture];a.forEach((e=>e.activate())),e.updateShaders(t.tris,n,r),o.drawArrays(o.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release(),a.forEach((e=>e.deactivate()))},e.renderPieceFinish=(e,n)=>{if(null!==t.zBufferTexture&&t.zBufferTexture.deactivate(),t._useSmallViewport){if(t.framebuffer.restorePreviousBindingsAndBuffers(),null===t.copyShader){t.copyShader=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray([&quot;//VTK::System::Dec&quot;,&quot;attribute vec4 vertexDC;&quot;,&quot;uniform vec2 tfactor;&quot;,&quot;varying vec2 tcoord;&quot;,&quot;void main() { tcoord = vec2(vertexDC.x*0.5 + 0.5, vertexDC.y*0.5 + 0.5) * tfactor; gl_Position = vertexDC; }&quot;].join(&quot;\\n&quot;),[&quot;//VTK::System::Dec&quot;,&quot;//VTK::Output::Dec&quot;,&quot;uniform sampler2D texture1;&quot;,&quot;varying vec2 tcoord;&quot;,&quot;void main() { gl_FragData[0] = texture2D(texture1,tcoord); }&quot;].join(&quot;\\n&quot;),&quot;&quot;);const e=t.copyShader;t.copyVAO=od.newInstance(),t.copyVAO.setOpenGLRenderWindow(t._openGLRenderWindow),t.tris.getCABO().bind(),t.copyVAO.addAttributeArray(e,t.tris.getCABO(),&quot;vertexDC&quot;,t.tris.getCABO().getVertexOffset(),t.tris.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||rg(&quot;Error setting vertexDC in copy shader VAO.&quot;)}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(t.copyShader);const e=t._openGLRenderWindow.getFramebufferSize();t.context.viewport(0,0,e[0],e[1]);const n=t.framebuffer.getColorTexture();n.activate(),t.copyShader.setUniformi(&quot;texture&quot;,n.getTextureUnit()),t.copyShader.setUniform2f(&quot;tfactor&quot;,t.fvp[0],t.fvp[1]);const r=t.context;r.blendFuncSeparate(r.ONE,r.ONE_MINUS_SRC_ALPHA,r.ONE,r.ONE_MINUS_SRC_ALPHA),t.context.drawArrays(t.context.TRIANGLES,0,t.tris.getCABO().getElementCount()),n.deactivate(),r.blendFuncSeparate(r.SRC_ALPHA,r.ONE_MINUS_SRC_ALPHA,r.ONE,r.ONE_MINUS_SRC_ALPHA)}},e.renderPiece=(n,r)=>{e.invokeEvent({type:&quot;StartEvent&quot;}),t.renderable.update();const o=t.renderable.getNumberOfInputPorts();t.currentValidInputs=[];for(let e=0;e<o;++e){const n=t.renderable.getInputData(e);n&&!n.isDeleted()&&t.currentValidInputs.push({imageData:n,inputIndex:e})}let a=0;if(t.currentValidInputs.length>0){const e=r.getProperties(),o=t.currentValidInputs[0],i=o.imageData.getPointData().getScalars(),s=e[o.inputIndex];s.getShade()&&t.renderable.getBlendMode()===eg.COMPOSITE_BLEND&&n.getLights().forEach((e=>{e.getSwitch()>0&&a++}));const l=t.currentValidInputs.length,c=l>1;t.numberOfComponents=c?l:i.getNumberOfComponents(),t.useIndependentComponents=function(e,t){const n=e.getIndependentComponents(),r=e.getColorMixPreset();return n&&t>=2||!!r}(s,t.numberOfComponents)}a!==t.numberOfLights&&(t.numberOfLights=a,e.modified()),e.invokeEvent({type:&quot;EndEvent&quot;}),0!==t.currentValidInputs.length&&(e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r))},e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n)},e.getNeedToRebuildBufferObjects=(n,r)=>t.VBOBuildTime.getMTime()<e.getMTime()||t.VBOBuildTime.getMTime()<r.getMTime()||t.VBOBuildTime.getMTime()<r.getProperty(t.currentValidInputs[0].inputIndex)?.getMTime()||t.VBOBuildTime.getMTime()<t.renderable.getMTime()||t.currentValidInputs.some((e=>{let{imageData:n}=e;return t.VBOBuildTime.getMTime()<n.getMTime()}))||t.scalarTextures.length!==t.currentValidInputs.length||!t.scalarTextures.every((e=>!!e?.getHandle()))||!t.colorTexture?.getHandle()||!t.opacityTexture?.getHandle()||!t.labelOutlineThicknessTexture?.getHandle()||!t.jitterTexture?.getHandle(),e.buildBufferObjects=(n,r)=>{if(!t.jitterTexture.getHandle()){const e=new Float32Array(1024);for(let t=0;t<1024;++t)e[t]=Math.random();t.jitterTexture.setMinificationFilter(ud.NEAREST),t.jitterTexture.setMagnificationFilter(ud.NEAREST),t.jitterTexture.create2DFromRaw({width:32,height:32,numComps:1,dataType:cs.FLOAT,data:e})}const a=r.getProperties(),i=t.currentValidInputs[0],s=a[i.inputIndex],l=t.numberOfComponents,c=t.useIndependentComponents,u=c?l:1,d=[];for(let e=0;e<u;++e)d.push(s.getScalarOpacity(e));const p=wf(d,c,u),f=s.getScalarOpacity(),g=t._openGLRenderWindow.getGraphicsResourceForObject(f);if(g?.oglObject?.getHandle()&&g.hash===p)t.opacityTexture=g.oglObject;else{const r=Pd.newInstance();r.setOpenGLRenderWindow(t._openGLRenderWindow);let o=t.renderable.getOpacityTextureWidth();o<=0&&(o=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const a=2*o*u,i=new Float32Array(a),l=new Float32Array(o);for(let t=0;t<u;++t){const r=s.getScalarOpacity(t),a=e.getCurrentSampleDistance(n)/s.getScalarOpacityUnitDistance(t),c=r.getRange();r.getTable(c[0],c[1],o,l,1);for(let e=0;e<o;++e)i[t*o*2+e]=1-(1-l[e])**a,i[t*o*2+e+o]=i[t*o*2+e]}if(r.resetFormatAndType(),r.setMinificationFilter(ud.LINEAR),r.setMagnificationFilter(ud.LINEAR),t._openGLRenderWindow.getWebgl2()||t.context.getExtension(&quot;OES_texture_float&quot;)&&t.context.getExtension(&quot;OES_texture_float_linear&quot;))r.create2DFromRaw({width:o,height:2*u,numComps:1,dataType:cs.FLOAT,data:i});else{const e=new Uint8ClampedArray(a);for(let t=0;t<a;++t)e[t]=255*i[t];r.create2DFromRaw({width:o,height:2*u,numComps:1,dataType:cs.UNSIGNED_CHAR,data:e})}f&&t._openGLRenderWindow.setGraphicsResourceForObject(f,r,p),t.opacityTexture=r}o(t._openGLRenderWindow,t._opacityTextureCore,f),t._opacityTextureCore=f;const m=[];for(let e=0;e<u;++e)m.push(s.getRGBTransferFunction(e));const h=wf(m,c,u),v=s.getRGBTransferFunction(),T=t._openGLRenderWindow.getGraphicsResourceForObject(v);if(T?.oglObject?.getHandle()&&T?.hash===h)t.colorTexture=T.oglObject;else{const e=Pd.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow);let n=t.renderable.getColorTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=new Uint8ClampedArray(2*n*u*3),o=new Float32Array(3*n);for(let e=0;e<u;++e){const t=s.getRGBTransferFunction(e),a=t.getRange();t.getTable(a[0],a[1],n,o,1);for(let t=0;t<3*n;++t)r[e*n*6+t]=255*o[t],r[e*n*6+t+3*n]=255*o[t]}e.resetFormatAndType(),e.setMinificationFilter(ud.LINEAR),e.setMagnificationFilter(ud.LINEAR),e.create2DFromRaw({width:n,height:2*u,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r}),t._openGLRenderWindow.setGraphicsResourceForObject(v,e,h),t.colorTexture=e}o(t._openGLRenderWindow,t._colorTextureCore,v),t._colorTextureCore=v,t.currentValidInputs.forEach(((e,n)=>{let{imageData:r,inputIndex:i}=e;const s=a[i],l=r.getPointData().getScalars(),c=t._openGLRenderWindow.getGraphicsResourceForObject(l),u=Of(0,l),d=!c?.oglObject?.getHandle()||c?.hash!==u,p=s.getUpdatedExtents(),f=!!p.length;if(d&&!f){const e=Pd.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow);const o=r.getDimensions();e.setOglNorm16Ext(t.context.getExtension(&quot;EXT_texture_norm16&quot;)),e.resetFormatAndType(),e.create3DFilterableFromDataArray({width:o[0],height:o[1],depth:o[2],dataArray:l,preferSizeOverAccuracy:s.getPreferSizeOverAccuracy()}),t._openGLRenderWindow.setGraphicsResourceForObject(l,e,u),t.scalarTextures[n]=e}else t.scalarTextures[n]=c.oglObject;if(f){s.setUpdatedExtents([]);const e=r.getDimensions();t.scalarTextures[n].create3DFilterableFromDataArray({width:e[0],height:e[1],depth:e[2],dataArray:l,updatedExtents:p})}o(t._openGLRenderWindow,t._scalarTexturesCore[n],l),t._scalarTexturesCore[n]=l}));const y=s.getLabelOutlineThickness(),b=t._openGLRenderWindow.getGraphicsResourceForObject(y),x=y.join(&quot;-&quot;);if(b?.oglObject?.getHandle()&&b?.hash===x)t.labelOutlineThicknessTexture=b.oglObject;else{const e=Pd.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow);let n=t.renderable.getLabelOutlineTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=1,o=new Uint8Array(n*r);for(let e=0;e<n;++e){const t=void 0!==y[e]?y[e]:y[0];o[e]=t}e.resetFormatAndType(),e.setMinificationFilter(ud.NEAREST),e.setMagnificationFilter(ud.NEAREST),e.create2DFromRaw({width:n,height:r,numComps:1,dataType:cs.UNSIGNED_CHAR,data:o}),y&&t._openGLRenderWindow.setGraphicsResourceForObject(y,e,x),t.labelOutlineThicknessTexture=e}if(o(t._openGLRenderWindow,t._labelOutlineThicknessTextureCore,y),t._labelOutlineThicknessTextureCore=y,!t.tris.getCABO().getElementCount()){const e=new Float32Array(12);for(let t=0;t<4;t++)e[3*t]=t%2*2-1,e[3*t+1]=t>1?1:-1,e[3*t+2]=-1;const n=new Uint16Array(8);n[0]=3,n[1]=0,n[2]=1,n[3]=3,n[4]=3,n[5]=0,n[6]=3,n[7]=2;const r=xs.newInstance({numberOfComponents:3,values:e});r.setName(&quot;points&quot;);const o=xs.newInstance({numberOfComponents:1,values:n});t.tris.getCABO().createVBO(o,&quot;polys&quot;,Zi.SURFACE,{points:r,cellOffset:0})}t.VBOBuildTime.modified()}}(e,t)}),&quot;vtkOpenGLVolumeMapper&quot;);Jt(&quot;vtkVolumeMapper&quot;,ig);const{vtkDebugMacro:sg}=Ht,lg={};const cg=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,lg,n),qt.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLPixelSpaceCallbackMapper&quot;),e.opaquePass=(n,r)=>{t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;);const o=t._openGLRenderer.getAspectRatio(),a=t._openGLRenderer?t._openGLRenderer.getRenderable().getActiveCamera():null,i=t._openGLRenderer.getTiledSizeAndOrigin();let s=null;if(t.renderable.getUseZValues()){const e=r.getZBufferTexture(),n=Math.floor(e.getWidth()),o=Math.floor(e.getHeight()),a=t._openGLRenderWindow.getContext();e.bind();const i=r.getFramebuffer();i?i.saveCurrentBindingsAndBuffers():sg(&quot;No framebuffer to save/restore&quot;);const l=a.createFramebuffer();a.bindFramebuffer(a.FRAMEBUFFER,l),a.framebufferTexture2D(a.FRAMEBUFFER,a.COLOR_ATTACHMENT0,a.TEXTURE_2D,e.getHandle(),0),a.checkFramebufferStatus(a.FRAMEBUFFER)===a.FRAMEBUFFER_COMPLETE&&(s=new Uint8Array(n*o*4),a.viewport(0,0,n,o),a.readPixels(0,0,n,o,a.RGBA,a.UNSIGNED_BYTE,s)),i&&i.restorePreviousBindingsAndBuffers(),a.deleteFramebuffer(l)}t.renderable.invokeCallback(t.renderable.getInputData(),a,o,i,s)},e.queryPass=(e,n)=>{e&&t.renderable.getUseZValues()&&n.requestDepth()}}(e,t)}),&quot;vtkOpenGLPixelSpaceCallbackMapper&quot;);Jt(&quot;vtkPixelSpaceCallbackMapper&quot;,cg);var ug=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtktextureObjectVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\nattribute vec4 vertexDC;\\nattribute vec2 tcoordDC;\\nvarying vec2 tcoordVC;\\n\\nvoid main()\\n{\\n  tcoordVC = tcoordDC;\\n  gl_Position = vertexDC;\\n}\\n&quot;;const{Representation:dg}=os;function pg(e,t,n,r){let[o,a]=t;const i=e.getContext(),s=Pd.newInstance({autoParameters:!1,wrapS:r,wrapT:r,minificationFilter:n,magnificationFilter:n,generateMipmap:!1,openGLDataType:i.FLOAT,baseLevel:0,maxLevel:0});return s.setOpenGLRenderWindow(e),s.setInternalFormat(i.RGBA32F),s.create2DFromRaw({width:o,height:a,numComps:4,dataType:&quot;Float32Array&quot;,data:null}),s.activate(),s.sendParameters(),s.deactivate(),s}function fg(e,t){return pg(e,t,Pd.Filter.NEAREST,Pd.Wrap.CLAMP_TO_EDGE)}const gg={vectorTexture:null,maskVectorTexture:null,noiseTexture:null,doEEPass:!1,doVTPass:!1,readIndex:0,quad:null,lastProgramHash:null,framebuffer:null,size:null,pingTextures:[],pongTextures:[],textures:[]};function mg(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,gg,n),Wt.obj(e,t),Wt.get(e,t,[&quot;readIndex&quot;]),Wt.setGet(e,t,[&quot;doEEPass&quot;,&quot;doVTPass&quot;,&quot;_openGLRenderWindow&quot;,&quot;vectorTexture&quot;,&quot;maskVectorTexture&quot;,&quot;noiseTexture&quot;,&quot;framebuffer&quot;,&quot;size&quot;]),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkLICPingPongBufferManager&quot;),t._openGLRenderWindow?(t.quad=function(e){const t=ld.newInstance();t.setOpenGLRenderWindow(e);const n=new Float32Array(12);for(let e=0;e<4;e++)n[3*e]=e%2*2-1,n[3*e+1]=e>1?1:-1,n[3*e+2]=0;const r=new Float32Array([0,0,1,0,0,1,1,1]),o=new Uint16Array(8);o[0]=3,o[1]=0,o[2]=1,o[3]=3,o[4]=3,o[5]=0,o[6]=3,o[7]=2;const a=xs.newInstance({numberOfComponents:3,values:n});a.setName(&quot;points&quot;);const i=xs.newInstance({numberOfComponents:1,values:o}),s=xs.newInstance({numberOfComponents:2,values:r});return t.getCABO().createVBO(i,&quot;polys&quot;,dg.SURFACE,{points:a,cellOffset:0,tcoords:s}),t}(t._openGLRenderWindow),t.context=t._openGLRenderWindow.getContext(),t.licTexture0=fg(t._openGLRenderWindow,t.size),t.seedTexture0=fg(t._openGLRenderWindow,t.size),t.licTexture1=fg(t._openGLRenderWindow,t.size),t.seedTexture1=fg(t._openGLRenderWindow,t.size),t.eeTexture=t.doEEPass?pg(t._openGLRenderWindow,t.size,Pd.Filter.NEAREST,Pd.Wrap.CLAMP_TO_EDGE):null,t.imageVectorTexture=t.doVTPass?(n=t._openGLRenderWindow,r=t.size,pg(n,r,Pd.Filter.LINEAR,Pd.Wrap.CLAMP_TO_EDGE)):null,t.pingTextures[0]=t.licTexture0,t.pingTextures[1]=t.seedTexture0,t.pongTextures[0]=t.licTexture1,t.pongTextures[1]=t.seedTexture1,t.textures[0]=t.pingTextures,t.textures[1]=t.pongTextures,e.swap=()=>{t.readIndex=1-t.readIndex},e.renderQuad=(e,n)=>{const r=t.quad,o=t.context;let a=t.quadVAO;a||(a=od.newInstance(),a.setOpenGLRenderWindow(t._openGLRenderWindow),t.quadVAO=a),t.previousProgramHash!==n.getMd5Hash()&&(a.shaderProgramChanged(),r.getCABO().bind(),a.addAttributeArray(n,r.getCABO(),&quot;vertexDC&quot;,r.getCABO().getVertexOffset(),r.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE),a.addAttributeArray(n,r.getCABO(),&quot;tcoordDC&quot;,r.getCABO().getTCoordOffset(),r.getCABO().getStride(),t.context.FLOAT,2,t.context.FALSE),t.previousProgramHash=n.getMd5Hash()),o.drawArrays(o.TRIANGLES,0,r.getCABO().getElementCount()),a.release()},e.getLastLICBuffer=()=>0===t.readIndex?t.licTexture0:t.licTexture1,e.getLastSeedBuffer=()=>0===t.readIndex?t.seedTexture0:t.seedTexture1,e.getLICBuffer=()=>1-t.readIndex==0?t.licTexture0:t.licTexture1,e.getSeedBuffer=()=>1-t.readIndex==0?t.seedTexture0:t.seedTexture1,e.getLICTextureUnit=()=>{const e=t.textures[t.readIndex][0];return e.activate(),e.getTextureUnit()},e.getSeedTextureUnit=()=>{const e=t.textures[t.readIndex][1];return e.activate(),e.getTextureUnit()},e.getNoiseTextureUnit=function(){return 0===(arguments.length>0&&void 0!==arguments[0]?arguments[0]:0)?(t.noiseTexture.activate(),t.noiseTexture.getTextureUnit()):(t.eeTexture.activate(),t.eeTexture.getTextureUnit())},e.getVectorTextureUnit=()=>(t.vectorTexture.activate(),t.vectorTexture.getTextureUnit()),e.getImageVectorTextureUnit=()=>t.imageVectorTexture?(t.imageVectorTexture.activate(),t.imageVectorTexture.getTextureUnit()):e.getVectorTextureUnit(),e.getMaskVectorTextureUnit=()=>t.maskVectorTexture?(t.maskVectorTexture.activate(),t.maskVectorTexture.getTextureUnit()):e.getImageVectorTextureUnit(),e.clearBuffers=function(){let e=arguments.length>0&&void 0!==arguments[0]&&arguments[0];const n=t.framebuffer,r=t.context;n.removeColorBuffer(0),n.removeColorBuffer(1),n.removeColorBuffer(2),n.removeColorBuffer(3),n.setColorBuffer(t.licTexture0,0),n.setColorBuffer(t.seedTexture0,1),n.setColorBuffer(t.licTexture1,2),n.setColorBuffer(t.seedTexture1,3);const o=[r.COLOR_ATTACHMENT0,r.COLOR_ATTACHMENT1,r.COLOR_ATTACHMENT2,r.COLOR_ATTACHMENT3];e&&(n.removeColorBuffer(4),n.setColorBuffer(t.eeTexture,4),o.push(r.COLOR_ATTACHMENT4)),r.drawBuffers(o),r.clearColor(0,1,0,0),r.disable(r.SCISSOR_TEST),r.disable(r.BLEND),r.clear(r.COLOR_BUFFER_BIT),n.removeColorBuffer(0),n.removeColorBuffer(1),n.removeColorBuffer(2),n.removeColorBuffer(3),e&&n.removeColorBuffer(4),r.drawBuffers([r.NONE])},e.clearBuffer=e=>{const n=t.framebuffer,r=t.context;n.removeColorBuffer(0),n.setColorBuffer(e,0),r.drawBuffers([r.COLOR_ATTACHMENT0]),r.clearColor(0,1,0,0),r.disable(r.SCISSOR_TEST),r.disable(r.BLEND),r.clear(r.COLOR_BUFFER_BIT),n.removeColorBuffer(e,0),r.drawBuffers([r.NONE])},e.activateVectorTextures=()=>{t.imageVectorTexture?t.imageVectorTexture.activate():t.vectorTexture.activate(),t.maskVectorTexture&&t.maskVectorTexture.activate()},e.deactivateVectorTextures=()=>{t.imageVectorTexture?t.imageVectorTexture.deactivate():t.vectorTexture.deactivate(),t.maskVectorTexture&&t.maskVectorTexture.deactivate()},e.activateNoiseTexture=function(){switch(arguments.length>0&&void 0!==arguments[0]?arguments[0]:0){case 0:t.noiseTexture.activate();break;case 1:t.eeTexture.activate();break;default:console.error(&quot;Wrong LIC pass number&quot;)}},e.deactivateNoiseTexture=function(){switch(arguments.length>0&&void 0!==arguments[0]?arguments[0]:0){case 0:t.noiseTexture.deactivate();break;case 1:t.eeTexture.deactivate();break;default:console.error(&quot;Wrong LIC pass number&quot;)}},e.attachLICBuffers=()=>{const e=t.textures[t.readIndex],n=t.textures[1-t.readIndex],r=t.framebuffer,o=t.context;e[0].activate(),e[1].activate(),r.removeColorBuffer(0),r.removeColorBuffer(1),r.setColorBuffer(n[0],0),r.setColorBuffer(n[1],1),o.drawBuffers([o.COLOR_ATTACHMENT0,o.COLOR_ATTACHMENT1])},e.detachLICBuffers=()=>{const e=t.textures[t.readIndex],n=t.context,r=t.framebuffer;e[0].deactivate(),e[1].deactivate(),r.removeColorBuffer(0),r.removeColorBuffer(1),n.drawBuffers([n.NONE])},e.attachImageVectorBuffer=()=>{const e=t.framebuffer,n=t.context;t.vectorTexture.activate(),e.removeColorBuffer(0),e.setColorBuffer(t.imageVectorTexture,0),n.drawBuffers([n.COLOR_ATTACHMENT0])},e.detachImageVectorBuffer=()=>{const e=t.context,n=t.framebuffer;t.vectorTexture.deactivate(),n.removeColorBuffer(0),e.drawBuffers([e.NONE])},e.attachEEBuffer=()=>{t.textures[t.readIndex][0].activate(),t.framebuffer.removeColorBuffer(0),t.framebuffer.setColorBuffer(t.eeTexture,0);const e=t.context;e.drawBuffers([e.COLOR_ATTACHMENT0])},e.detachEEBuffer=()=>{const e=t.context;t.framebuffer.removeColorBuffer(0),e.drawBuffers([e.NONE]),t.textures[t.readIndex][0].deactivate()},e.detachBuffers=()=>{const e=t.context,n=t.framebuffer;n.removeColorBuffer(0),n.removeColorBuffer(1),e.drawBuffers([e.NONE]);const r=t.textures[t.readIndex],o=t.textures[1-t.readIndex];r[0]&&r[0].deactivate(),r[1]&&r[1].deactivate(),o[0]&&o[0].deactivate(),o[1]&&o[1].deactivate(),t.eeTexture&&t.eeTexture.deactivate(),t.noiseTexture&&t.noiseTexture.deactivate()},e.getWriteIndex=()=>1-t.readIndex,e.detachBuffers()):console.error(&quot;Pass renderwindow to ping pong manager&quot;);var n,r}(e,t)}var hg={newInstance:Wt.newInstance(mg,&quot;vtkLICPingPongBufferManager&quot;),extend:mg};const vg=0,Tg=1,yg=2,bg=3,xg=1,Cg={shadersNeedBuild:!0,stepSize:1,numberOfSteps:10,enhancedLIC:!0,enhanceContrast:!1,lowContrastEnhancementFactor:0,highContrastEnhancementFactor:0,antiAlias:0,componentIds:[0,1],normalizeVectors:!0,maskThreshold:0,transformVectors:!0,bufs:null,isComposite:!0};function Sg(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Cg,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;context&quot;,&quot;_openGLRenderWindow&quot;,&quot;nuberOfSteps&quot;,&quot;stepSize&quot;,&quot;normalizeVectors&quot;,&quot;maskThreshold&quot;,&quot;enhancedLIC&quot;,&quot;enhanceContrast&quot;,&quot;lowLICContrastEnhancementFactor&quot;,&quot;highLICContrastEnhancementFactor&quot;,&quot;antiAlias&quot;,&quot;componentIds&quot;,&quot;isComposite&quot;]),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){function n(e,t){e.setUniformi(&quot;texLIC&quot;,t.getLICTextureUnit()),e.setUniformi(&quot;texSeedPts&quot;,t.getSeedTextureUnit())}function r(e,t,n){e.attachLICBuffers(),e.renderQuad(t,n),e.detachLICBuffers(),e.swap()}t.classHierarchy.push(&quot;vtkLineIntegralConvolution2D&quot;),e.buildAShader=e=>t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(ug,e,&quot;&quot;),e.dumpTextureValues=function(e,n){let[r,o]=n,a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:t.context,i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:t._openGLRenderWindow,s=arguments.length>4&&void 0!==arguments[4]?arguments[4]:4;const l=Sp.newInstance(),c=a;let u=null;return l.setOpenGLRenderWindow(i),l.saveCurrentBindingsAndBuffers(),l.create(r,o),l.populateFramebuffer(),l.setColorBuffer(e),u=new Float32Array(r*o*s),c.readPixels(0,0,r,o,4===s?c.RGBA:c.RGB,c.FLOAT,u),l.restorePreviousBindingsAndBuffers(),u},e.getTextureMinMax=function(n,r){let o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:t.context,a=arguments.length>3&&void 0!==arguments[3]?arguments[3]:t._openGLRenderWindow;const i=e.dumpTextureValues(n,r,o,a,4);let s=Number.MAX_VALUE,l=Number.MIN_VALUE;for(let e=0;e<i.length;e+=4)if(0===i[e+1]){const t=i[e];t<s&&(s=t),t>l&&(l=t)}return{min:s,max:l}},e.getComponentSelectionProgram=e=>{const t=&quot;xyzw&quot;;return`.${t[e[0]]}${t[e[1]]}`},e.buildShaders=()=>{t.LIC0ShaderProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_LIC0.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n/**\\nThis shader initializes the convolution for the LIC computation.\\n*/\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\nuniform sampler2D texMaskVectors;\\nuniform sampler2D texNoise;\\nuniform sampler2D texLIC;\\n\\nuniform int   uStepNo;         // in step 0 initialize lic and seeds, else just seeds\\nuniform int   uPassNo;         // in pass 1 hpf of pass 0 is convolved.\\nuniform float uMaskThreshold;  // if |V| < uMaskThreshold render transparent\\nuniform vec2  uNoiseBoundsPt1; // tc of upper right pt of noise texture\\n\\nin vec2 tcoordVC;\\n\\n// convert from vector coordinate space to noise coordinate space.\\n// the noise texture is tiled across the *whole* domain\\nvec2 VectorTCToNoiseTC(vec2 vectc)\\n{\\n  return vectc/uNoiseBoundsPt1;\\n}\\n\\n// get the texture coordidnate to lookup noise value. this\\n// depends on the pass number.\\nvec2 getNoiseTC(vec2 vectc)\\n{\\n  // in pass 1 : convert from vector tc to noise tc\\n  // in pass 2 : use vector tc\\n  if (uPassNo == 0)\\n    {\\n    return VectorTCToNoiseTC(vectc);\\n    }\\n  else\\n    {\\n    return vectc;\\n    }\\n}\\n\\n// look up noise value at the given location. The location\\n// is supplied in vector texture coordinates, hence the\\n// need to convert to noise texture coordinates.\\nfloat getNoise(vec2 vectc)\\n{\\n  return texture2D(texNoise, getNoiseTC(vectc)).r;\\n}\\n\\nvoid main(void)\\n{\\n  vec2 vectc = tcoordVC.st;\\n\\n  // lic => (convolution, mask, 0, step count)\\n  if (uStepNo == 0)\\n    {\\n    float maskCriteria = length(texture2D(texMaskVectors, vectc).xyz);\\n    float maskFlag;\\n    if (maskCriteria <= uMaskThreshold)\\n      {\\n      maskFlag = 1.0;\\n      }\\n    else\\n      {\\n      maskFlag = 0.0;\\n      }\\n    float noise = getNoise(vectc);\\n    LICOutput = vec4(noise, maskFlag, 0.0, 1.0);\\n    }\\n  else\\n    {\\n    LICOutput = texture2D(texLIC, vectc);\\n    }\\n\\n  // initial seed\\n  SeedOutput = vec4(vectc, 0.0, 1.0);\\n}\\n&quot;);const n=td.substitute(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_VT.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// move vector field to normalized image space\\n// pre-processing for vtkLineIntegralConvolution2D\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\n// Fragment shader used by the gaussian blur filter render pass.\\n\\nuniform sampler2D texVectors; // input texture\\nuniform vec2      uTexSize;   // size of texture\\n\\nin vec2 tcoordVC;\\n\\nvoid main(void)\\n{\\n  //VTK::LICComponentSelection::Impl\\n  V = V/uTexSize;\\n  gl_FragData[0] = vec4(V, 0.0, 1.0);\\n}\\n&quot;,&quot;//VTK::LICComponentSelection::Impl&quot;,`vec2 V = texture2D(texVectors, tcoordVC.st)${e.getComponentSelectionProgram(t.componentIds)};`).result;t.VTProgram=e.buildAShader(n);const r=td.substitute(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_fs1.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\nuniform sampler2D  texVectors;\\nuniform sampler2D  texNoise;\\nuniform sampler2D  texLIC;\\nuniform sampler2D  texSeedPts;\\n\\nuniform int   uPassNo;          // in pass 1 hpf of pass 0 is convolved.\\nuniform float uStepSize;        // step size in parametric space\\n\\nuniform vec2  uNoiseBoundsPt1;  // tc of upper right pt of noise texture\\n\\nin vec2 tcoordVC;\\n\\n//VTK::LICVectorLookup::Impl\\n\\n// We need to do this manually since CLAMP_TO_BORDER and and borderColor\\n// are very poorly supported in webgl\\nvec2 clampToBorder(vec2 uv){\\n  if(uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0)\\n  {\\n    return vec2(0.0, 0.0);\\n  }\\n  return getVector(uv);\\n}\\n\\n// convert from vector coordinate space to noise coordinate space.\\n// the noise texture is tiled across the whole domain\\nvec2 VectorTCToNoiseTC(vec2 vectc)\\n{\\n  return vectc/uNoiseBoundsPt1;\\n}\\n\\n// get the texture coordidnate to lookup noise value.\\n// in pass 1 repeatedly tile the noise texture across\\n// the computational domain.\\nvec2 getNoiseTC(vec2 tc)\\n{\\n  if (uPassNo == 0)\\n    {\\n    return VectorTCToNoiseTC(tc);\\n    }\\n  else\\n    {\\n    return tc;\\n    }\\n}\\n\\n// look up noise value at the given location. The location\\n// is supplied in vector texture coordinates, hence the need\\n// to convert to either noise or lic texture coordinates in\\n// pass 1 and 2 respectively.\\nfloat getNoise(vec2 vectc)\\n{\\n  return texture2D(texNoise, getNoiseTC(vectc)).r;\\n}\\n\\n// fourth-order Runge-Kutta streamline integration\\n// no bounds checks are made, therefore it's essential\\n// to have the entire texture initialized to 0\\n// and set clamp to border and have border color 0\\n// an integer is set if the step was taken, keeping\\n// an accurate step count is necessary to prevent\\n// boundary artifacts. Don't count the step if\\n// all vector lookups are identically 0. This is\\n// a proxy for \\&quot;stepped outside valid domain\\&quot;\\nvec2 rk4(vec2 pt0, float dt, out bool count)\\n{\\n  count=true;\\n  float dtHalf = dt * 0.5;\\n  vec2 pt1;\\n\\n  vec2 v0 = clampToBorder(pt0);\\n  pt1 = pt0 + v0 * dtHalf;\\n\\n  vec2 v1 = clampToBorder(pt1);\\n  pt1 = pt0 + v1 * dtHalf;\\n\\n  vec2 v2 = clampToBorder(pt1);\\n  pt1 = pt0 + v2 * dt;\\n\\n  vec2 v3 = clampToBorder(pt1);\\n  vec2 vSum = v0 + v1 + v1 + v2 + v2 + v3;\\n\\n  if (vSum == vec2(0.0, 0.0))\\n    {\\n      count = false;\\n    }\\n\\n  pt1 = pt0 + (vSum) * (dt * (1.0/6.0));\\n\\n return pt1;\\n}\\n\\nvoid main(void)\\n{\\n  vec2 lictc = tcoordVC.st;\\n  vec4 lic = texture2D(texLIC, lictc);\\n  vec2 pt0 = texture2D(texSeedPts, lictc).st;\\n\\n  bool count;\\n  vec2 pt1 = rk4(pt0, uStepSize, count);\\n\\n  if (count)\\n    {\\n    // accumulate lic step\\n    // (lic, mask, 0, step count)\\n    float noise = getNoise(pt1);\\n    LICOutput = vec4(lic.r + noise, lic.g, 0.0, lic.a + 1.0);\\n    SeedOutput = vec4(pt1, 0.0, 1.0);\\n    }\\n  else\\n    {\\n    // keep existing values\\n    LICOutput = lic;\\n    SeedOutput = vec4(pt0, 0.0, 1.0);\\n    }\\n}\\n&quot;,&quot;//VTK::LICVectorLookup::Impl&quot;,function(){return arguments.length>0&&void 0!==arguments[0]&&!arguments[0]?&quot;\\n    vec2 getVector( vec2 vectc )\\n\\n      {\\n\\n      return texture2D( texVectors, vectc ).xy;\\n\\n      }\\n\\n    &quot;:&quot;\\n    vec2 getVector( vec2 vectc )\\n\\n      {\\n\\n      vec2 V = texture2D( texVectors, vectc ).xy;\\n\\n      // normalize if |V| not 0\\n\\n      float lenV = length( V );\\n\\n      if ( lenV > 1.0e-8 )\\n\\n        {\\n\\n        return V/lenV;\\n\\n        }\\n\\n      else\\n\\n        {\\n\\n        return vec2( 0.0, 0.0 );\\n\\n        }\\n\\n      }\\n\\n    &quot;}(t.normalizeVectors),!0).result;t.LICIShaderProgram=e.buildAShader(r),t.LICNShaderProgram=e.buildAShader(&quot; //VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_LICN.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\n/**\\nThis shader finalizes the convolution for the LIC computation\\napplying the normalization. eg. if box kernel is used the this\\nis the number of steps taken.\\n*/\\n\\nuniform sampler2D texLIC;\\n\\nin vec2 tcoordVC;\\n\\nvoid main(void)\\n{\\n  vec4 conv = texture2D(texLIC, tcoordVC.st);\\n  conv.r = conv.r/conv.a;\\n  // lic => (convolution, mask, 0, 1)\\n  LICOutput = vec4(conv.rg , 0.0, 1.0);\\n  SeedOutput = vec4(0.0, 0.0, 0.0, 0.0);\\n}\\n&quot;),t.CEProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_CE.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// gray scale contrast enhance stage implemented via histogram stretching\\n// if the min and max are tweaked it can generate out-of-range values\\n// these will be clamped in 0 to 1\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\n\\nuniform sampler2D texLIC;  // most recent lic pass\\nuniform float uMin;        // min gray scale color value\\nuniform float uMaxMinDiff; // max-min\\n\\nin vec2 tcoordVC;\\n\\nvoid main( void )\\n{\\n  vec4 lic = texture2D(texLIC, tcoordVC.st);\\n  if (lic.g!=0.0)\\n    {\\n    LICOutput = lic;\\n    }\\n  else\\n    {\\n    float CElic = clamp((lic.r - uMin)/uMaxMinDiff, 0.0, 1.0);\\n    LICOutput = vec4(CElic, lic.gb, 1.0);\\n    }\\n    SeedOutput = vec4(0.0, 0.0, 0.0, 0.0);\\n}\\n&quot;),t.EEProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_fs2.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// high-pass filter stage employed by vtkLineIntegralConvolution2D\\n// between LIC pass 1 and LIC pass 2. filtered LIC pass 1, becomes\\n// noise for pass2.\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 EEOutput;\\n\\nuniform sampler2D texLIC; // most recent lic pass\\nuniform float     uDx;    // fragment size\\nuniform float     uDy;    // fragment size\\n\\nin vec2 tcoordVC;\\n\\n// kernel for simple laplace edge enhancement.\\n// p=Laplace(p)+p\\nfloat K[9] = float[9](\\n  -1.0, -1.0, -1.0,\\n  -1.0,  9.0, -1.0,\\n  -1.0, -1.0, -1.0\\n  );\\n\\n// determine if the fragment was masked\\nbool Masked(float val) { return val != 0.0; }\\n\\nvoid main(void)\\n{\\n  // tex coord neighbor offsets\\n  vec2 fragDx[9] = vec2[9](\\n    vec2(-uDx, uDy), vec2(0.0, uDy), vec2(uDx, uDy),\\n    vec2(-uDx, 0.0), vec2(0.0, 0.0), vec2(uDx, 0.0),\\n    vec2(-uDx,-uDy), vec2(0.0,-uDy), vec2(uDx,-uDy)\\n    );\\n\\n  vec2 lictc = tcoordVC.st;\\n\\n  // compute the convolution but don't use convovled values if\\n  // any masked fragments on the stencil. Fragments outside\\n  // the valid domain are masked during initialization, and\\n  // texture wrap parameters are clamp to border with border\\n  // color that contains masked flag\\n  float conv = 0.0;\\n  bool dontUse = false;\\n  for (int i=0; i<9; ++i)\\n    {\\n    vec2 tc = lictc + fragDx[i];\\n    vec4 lic = texture2D(texLIC, tc);\\n    dontUse = dontUse || Masked(lic.g);\\n    conv = conv + K[i] * lic.r;\\n    }\\n\\n  if (dontUse)\\n    {\\n    EEOutput = vec4(texture2D(texLIC, lictc).rg, 0.0, 1.0);\\n    }\\n  else\\n    {\\n    conv = clamp(conv, 0.0, 1.0);\\n    EEOutput = vec4(conv,texture2D(texLIC, lictc).g, 0.0, 1.0);\\n    }\\n\\n}\\n&quot;),t.AAHProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_AAH.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// Anti-alias stage in vtkLineIntegralConvolution2D\\n// horizontal pass of a Gaussian convolution\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\nuniform sampler2D texLIC; // input texture\\nuniform float     uDx;    // fragment size\\n\\nin vec2 tcoordVC;\\n\\n// factored 3x3 Gaussian kernel\\n// K^T*K = G\\nfloat K[3] = float[3](0.141421356, 0.707106781, 0.141421356);\\n\\n// determine if the fragment was masked\\nbool Masked(float val){ return val != 0.0; }\\n\\nvoid main(void)\\n{\\n// neighbor offsets\\nvec2 fragDx[3] = vec2[3](vec2(-uDx,0.0), vec2(0.0,0.0), vec2(uDx,0.0));\\n\\n  vec2 lictc = tcoordVC.st;\\n  vec4 lic[3];\\n  bool dontUse = false;\\n  float conv = 0.0;\\n  for (int i=0; i<3; ++i)\\n    {\\n    vec2 tc = lictc + fragDx[i];\\n    lic[i] = texture2D(texLIC, tc);\\n    dontUse = dontUse || Masked(lic[i].g);\\n    conv = conv + K[i] * lic[i].r;\\n    }\\n  // output is (conv, mask, skip, 1)\\n  if (dontUse)\\n    {\\n    LICOutput = vec4(lic[1].rg, 1.0, 1.0);\\n    }\\n  else\\n    {\\n    LICOutput = vec4(conv, lic[1].gb, 1.0);\\n    }\\n  SeedOutput = vec4(0.0, 0.0, 0.0, 0.0);\\n}\\n&quot;),t.AAVProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_AAV.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// Anti-alias stage in vtkLineIntegralConvolution2D\\n// vertical pass of a Gaussian convolution\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\nuniform sampler2D texLIC; // input texture\\nuniform float     uDy;    // fragment size\\n\\nin vec2 tcoordVC;\\n\\n\\n// factored 3x3 Gaussian kernel\\n// K^T*K = G\\nfloat K[3] = float[3](0.141421356, 0.707106781, 0.141421356);\\n\\n// determine if the fragment was masked\\nbool Masked(float val){ return val != 0.0; }\\n\\nvoid main(void)\\n{\\n// neighbor offsets\\nvec2 fragDy[3] = vec2[3](vec2(0.0,-uDy), vec2(0.0,0.0), vec2(0.0,uDy));\\n\\n\\n  vec2 lictc = tcoordVC.st;\\n  vec4 lic[3];\\n  bool dontUse = false;\\n  float conv = 0.0;\\n  for (int i=0; i<3; ++i)\\n    {\\n    vec2 tc = lictc + fragDy[i];\\n    lic[i] = texture2D(texLIC, tc);\\n    dontUse = dontUse || Masked(lic[i].g);\\n    conv = conv + K[i] * lic[i].r;\\n    }\\n  // output is (conv, mask, skip, 1)\\n  if (dontUse)\\n    {\\n    LICOutput = vec4(lic[1].rg, 1.0, 1.0);\\n    }\\n  else\\n    {\\n    LICOutput = vec4(conv, lic[1].gb, 1.0);\\n    }\\n  SeedOutput = vec4(0.0, 0.0, 0.0, 0.0);\\n}\\n&quot;)},e.executeLIC=(o,a,i,s,l,c)=>{if(t._openGLRenderWindow=l,t.context=l.getContext(),Object.assign(t,c),o[0]<=0||o[1]<=0)return null;const u=[1/o[0],1/o[1]];let d=t.stepSize*Math.sqrt(u[0]*u[0]+u[1]*u[1]);d<=0&&(d=1e-10);const p=t.context;let f=t.framebuffer;const g=f?.getSize();f&&g&&o[0]===g&&o[1]===g||(f=Sp.newInstance(),f.setOpenGLRenderWindow(t._openGLRenderWindow),f.saveCurrentBindingsAndBuffers(),f.create(...o),f.populateFramebuffer(),f.restorePreviousBindingsAndBuffers(),t.framebuffer=f),f.saveCurrentBindingsAndBuffers(),f.bind(),p.viewport(0,0,...o),p.scissor(0,0,...o),t.shadersNeedBuild&&(e.buildShaders(),t.shadersNeedBuild=!1),t.bufs?(t.bufs.setVectorTexture(a),t.bufs.setMaskVectorTexture(i),t.bufs.setNoiseTexture(s)):t.bufs=hg.newInstance({openGLRenderWindow:l,doEEPass:t.enhancedLIC,doVTPass:t.transformVectors,vectorTexture:a,maskVectorTexture:i,noiseTexture:s,framebuffer:f,size:o});const m=[(s.getWidth()+1)/o[0],(s.getHeight()+1)/o[1]],h=1/o[0],v=1/o[1],T=t._openGLRenderWindow.getShaderCache();if(t.transformVectors){const e=t.VTProgram;T.readyShaderProgram(e),t.bufs.attachImageVectorBuffer(),e.setUniform2f(&quot;uTexSize&quot;,...o),e.setUniformi(&quot;texVectors&quot;,t.bufs.getVectorTextureUnit()),p.clearColor(0,0,0,0),p.clear(p.COLOR_BUFFER_BIT),t.bufs.renderQuad(o,e),t.bufs.detachImageVectorBuffer()}t.bufs.clearBuffers(t.enhancedLIC),t.bufs.activateVectorTextures(),t.bufs.activateNoiseTexture(0);const{LIC0ShaderProgram:y}=t;T.readyShaderProgram(y),y.setUniformi(&quot;uStepNo&quot;,0),y.setUniformi(&quot;uPassNo&quot;,0),y.setUniformf(&quot;uMaskThreshold&quot;,t.maskThreshold),y.setUniform2f(&quot;uNoiseBoundsPt1&quot;,...m),y.setUniformi(&quot;texMaskVectors&quot;,t.bufs.getMaskVectorTextureUnit()),y.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),y.setUniformi(&quot;texNoise&quot;,t.bufs.getNoiseTextureUnit(0)),r(t.bufs,o,y);const{LICIShaderProgram:b}=t;T.readyShaderProgram(b),b.setUniformi(&quot;uPassNo&quot;,0),b.setUniformf(&quot;uStepSize&quot;,-d),b.setUniform2f(&quot;uNoiseBoundsPt1&quot;,...m),b.setUniformi(&quot;texVectors&quot;,t.bufs.getImageVectorTextureUnit()),b.setUniformi(&quot;texNoise&quot;,t.bufs.getNoiseTextureUnit(0));for(let e=0;e<t.numberOfSteps;++e)n(b,t.bufs),r(t.bufs,o,b);T.readyShaderProgram(y),y.setUniformi(&quot;uStepNo&quot;,1),n(y,t.bufs),r(t.bufs,o,y),T.readyShaderProgram(b),b.setUniformf(&quot;uStepSize&quot;,d);for(let e=0;e<t.numberOfSteps;++e)n(b,t.bufs),r(t.bufs,o,b);t.bufs.deactivateNoiseTexture(0),t.bufs.deactivateVectorTextures();const{LICNShaderProgram:x}=t;if(T.readyShaderProgram(x),x.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),r(t.bufs,o,x),t.enhancedLIC){t.enhanceContrast!==Tg&&t.enhanceContrast!==bg||e.contrastEnhance(!1,o),t.bufs.attachEEBuffer();const{EEProgram:a}=t;T.readyShaderProgram(a),a.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),a.setUniformf(&quot;uDx&quot;,h),a.setUniformf(&quot;uDy&quot;,v),t.bufs.renderQuad(o,a),t.bufs.detachEEBuffer(),t.bufs.detachBuffers(),t.bufs.clearBuffers(!1),t.bufs.activateVectorTextures(),t.bufs.activateNoiseTexture(1),T.readyShaderProgram(y),y.setUniformi(&quot;uStepNo&quot;,0),y.setUniformi(&quot;uPassNo&quot;,1),n(y,t.bufs),y.setUniformi(&quot;texNoise&quot;,t.bufs.getNoiseTextureUnit(1)),r(t.bufs,o,y),T.readyShaderProgram(b),b.setUniformi(&quot;uPassNo&quot;,1),b.setUniformf(&quot;uStepSize&quot;,-d),b.setUniformi(&quot;texNoise&quot;,t.bufs.getNoiseTextureUnit(1));const i=t.numberOfSteps/2;for(let e=0;e<i;++e)n(b,t.bufs),r(t.bufs,o,b);T.readyShaderProgram(y),y.setUniformi(&quot;uStepNo&quot;,1),n(y,t.bufs),r(t.bufs,o,y),T.readyShaderProgram(b),b.setUniformf(&quot;uStepSize&quot;,d);for(let e=0;e<i;++e)n(b,t.bufs),r(t.bufs,o,b);t.bufs.deactivateNoiseTexture(1),t.bufs.deactivateVectorTextures(),T.readyShaderProgram(x),x.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),x.setUniformi(&quot;texSeedPts&quot;,t.bufs.getSeedTextureUnit()),r(t.bufs,o,x)}if(t.antiAlias){const e=t.AAHProgram;T.readyShaderProgram(e),e.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),e.setUniformf(&quot;uDx&quot;,h);const a=t.AAVProgram;T.readyShaderProgram(a),a.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),a.setUniformf(&quot;uDy&quot;,v);for(let i=0;i<t.antiAlias;++i)T.readyShaderProgram(e),n(e,t.bufs),r(t.bufs,o,e),T.readyShaderProgram(a),n(a,t.bufs),r(t.bufs,o,a)}return t.enhanceContrast!==Tg&&t.enhanceContrast!==bg||e.contrastEnhance(!0,o),t.bufs.detachBuffers(),f.restorePreviousBindingsAndBuffers(),t.bufs.getLastLICBuffer()},e.contrastEnhance=(n,o)=>{const a=t._openGLRenderWindow.getShaderCache();let{min:i,max:s}=e.getTextureMinMax(t.bufs.getLastLICBuffer(),o,t.context,t._openGLRenderWindow);(s<=i||s>1||i<0)&&(console.error(&quot;Invalid color range: &quot;,i,s),i=0,s=1);let l=s-i;n&&(i+=l*t.lowLICContrastEnhancementFactor,s-=l*t.highLICContrastEnhancementFactor,l=s-i);const{CEProgram:c}=t;a.readyShaderProgram(c),c.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),c.setUniformf(&quot;uMin&quot;,i),c.setUniformf(&quot;uMaxMinDiff&quot;,l),r(t.bufs,o,c)}}(e,t)}var Ag={newInstance:Wt.newInstance(Sg,&quot;vtkLineIntegralConvolution2D&quot;),extend:Sg};const Ig={enableLIC:!1,nuberOfSteps:40,stepSize:.25,transformVectors:!0,normalizeVectors:!0,maskOnSurface:!1,maskThreshold:0,maskColor:[0,0,0],maskIntensity:0,enhancedLIC:!0,enhanceContrast:vg,lowLICContrastEnhancementFactor:0,highLICContrastEnhancementFactor:0,lowColorContrastEnhancementFactor:0,highColorContrastEnhancementFactor:0,antiAlias:0,colorMode:0,LICIntensity:1,mapModeBias:0,noiseTextureSize:200,noiseTextureType:xg,noiseGrainSize:8,noiseImpulseProbability:.1,noiseImpulseBackgroundValue:0,noiseGeneratorSeed:0,minNoiseValue:0,maxNoiseValue:1,numberOfNoiseLevels:2,shadersNeedBuilding:!0,reallocateTextures:!0,rebuildNoiseTexture:!1,viewPortScale:1};function wg(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ig,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;enableLIC&quot;,&quot;numberOfSteps&quot;,&quot;stepSize&quot;,&quot;normalizeVectors&quot;,&quot;transformVectors&quot;,&quot;maskOnSurface&quot;,&quot;maskThreshold&quot;,&quot;maskColor&quot;,&quot;maskIntensity&quot;,&quot;enhancedLIC&quot;,&quot;enhanceContrast&quot;,&quot;lowLICContrastEnhancementFactor&quot;,&quot;highLICContrastEnhancementFactor&quot;,&quot;lowColorContrastEnhancementFactor&quot;,&quot;highColorContrastEnhancementFactor&quot;,&quot;antiAlias&quot;,&quot;colorMode&quot;,&quot;LICIntensity&quot;,&quot;mapModeBias&quot;,&quot;noiseTextureSize&quot;,&quot;noiseTextureType&quot;,&quot;noiseGrainSize&quot;,&quot;minNoiseValue&quot;,&quot;maxNoiseValue&quot;,&quot;numberOfNoiseLevels&quot;,&quot;noiseImpulseProbability&quot;,&quot;noiseImpulseBackgroundValue&quot;,&quot;noiseGeneratorSeed&quot;,&quot;viewPortScale&quot;,&quot;rebuildNoiseTexture&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkSurfaceLICInterface&quot;)}(0,t)}var Og={newInstance:Wt.newInstance(wg,&quot;vtkSurfaceLICInterface&quot;),extend:wg};const{Representation:Pg}=os;const Rg={context:null,shadersNeedBuilding:!0,reallocateTextures:!0,size:null,licInterface:null};function Mg(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Rg,n),Og.extend(e,t,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;context&quot;,&quot;_openGLRenderWindow&quot;,&quot;reallocateTextures&quot;,&quot;licInterface&quot;,&quot;size&quot;]),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLSurfaceLICInterface&quot;),e.renderQuad=(e,n)=>{const r=t.licQuad,o=t.context;let a=t.licQuadVAO;a||(a=od.newInstance(),a.setOpenGLRenderWindow(t._openGLRenderWindow),t.licQuadVAO=a),t.previousProgramHash!==n.getMd5Hash()&&(a.shaderProgramChanged(),r.getCABO().bind(),a.addAttributeArray(n,r.getCABO(),&quot;vertexDC&quot;,r.getCABO().getVertexOffset(),r.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE),a.addAttributeArray(n,r.getCABO(),&quot;tcoordDC&quot;,r.getCABO().getTCoordOffset(),r.getCABO().getStride(),t.context.FLOAT,2,t.context.FALSE),t.previousProgramHash=n.getMd5Hash()),o.drawArrays(o.TRIANGLES,0,r.getCABO().getElementCount()),a.release()},e.generateNoiseTexture=e=>{if(!t.noiseTexture||t.licInterface.getRebuildNoiseTexture()){t.licInterface.setRebuildNoiseTexture(!1),t.noiseTexture&&t.noiseTexture.releaseGraphicsResources(),oo(t.noiseGeneratorSeed,{global:!0});let n=[];const{noiseTextureType:r,noiseGrainSize:o,numberOfNoiseLevels:a,noiseImpulseProbability:i,noiseImpulseBackgroundValue:s,minNoiseValue:l,maxNoiseValue:c}=t.licInterface.get(&quot;noiseTextureType&quot;,&quot;noiseGrainSize&quot;,&quot;numberOfNoiseLevels&quot;,&quot;noiseImpulseProbability&quot;,&quot;noiseImpulseBackgroundValue&quot;,&quot;minNoiseValue&quot;,&quot;maxNoiseValue&quot;);n=r===xg?function(e,t,n,r,o,a){const i=Math.max(0,Math.min(1,n)),s=Float32Array.from({length:e*e},(()=>{let e=0;if(1===i||Math.random()>1-i)for(let t=0;t<2048;++t)e+=Math.random();return e}));let l=0,c=2049;s.forEach((e=>{c=1===i?e<c?e:c:e<c&&e>0?e:c,l=e>l?e:l}));let u=l-c;0===u&&(c=0,u=0===l?1:l);const d=t-1,p=0!==d?1/d:0,f=a-o;return s.map((e=>{const n=e<c?e:(e-c)/u,i=Math.floor(n*t);return e>=c?1===t?a:o+(i>d?d:i)*p*f:r}))}(Math.floor(e/o),a,i,s,l,c):function(e,t,n,r){let[o,a]=e;const i=r-n;return Float32Array.from({length:o*a},(()=>{let e=Math.random();return e=Math.floor(e*t)/t,e=e*i+n,e>1?1:e<0?0:e}))}([Math.ceil(e/o),Math.ceil(e/o)],a,l,c);const u=1/o,d=Float32Array.from({length:e*e*4},((t,r)=>{const a=r/4;if(r%4==0){const t=Math.floor(a%e*u),r=Math.floor(a/e*u);return n[r*(e/o)+t]}return r%4==1||r%4==3?1:0})),p=Pd.newInstance({wrapS:Pd.Wrap.REPEAT,wrapT:Pd.Wrap.REPEAT,minificationFilter:Pd.Filter.NEAREST,magnificationFilter:Pd.Filter.NEAREST,generateMipMap:!1,openGLDataType:t.context.FLOAT,baseLevel:0,maxLevel:0,autoParameters:!1});p.setOpenGLRenderWindow(t._openGLRenderWindow),p.create2DFromRaw({width:e,height:e,numComps:4,dataType:&quot;Float32Array&quot;,data:d}),p.activate(),p.sendParameters(),p.deactivate(),t.noiseTexture=p}},e.buildAShader=e=>t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(ug,e,&quot;&quot;),e.allocateTextures=()=>{const n=Pd.Filter.NEAREST,r=Pd.Filter.LINEAR,o=t._openGLRenderWindow;t.geometryImage||(t.geometryImage=e.allocateTexture(o,n)),t.vectorImage||(t.vectorImage=e.allocateTexture(o,r)),t.maskVectorImage||(t.maskVectorImage=e.allocateTexture(o,r)),t.LICImage||(t.LICImage=e.allocateTexture(o,n)),t.RGBColorImage||(t.RGBColorImage=e.allocateTexture(o,n)),t.HSLColorImage||(t.HSLColorImage=e.allocateTexture(o,n)),t.depthTexture||(t.depthTexture=e.allocateDepthTexture(o))},e.allocateTexture=(e,n)=>{const r=t.context,o=Pd.newInstance({wrapS:Pd.Wrap.CLAMP_TO_EDGE,wrapT:Pd.Wrap.CLAMP_TO_EDGE,minificationFilter:n,magnificationFilter:n,generateMipmap:!1,openGLDataType:r.FLOAT,baseLevel:0,maxLevel:0,autoParameters:!1});return o.setOpenGLRenderWindow(e),o.setInternalFormat(r.RGBA32F),o.create2DFromRaw({width:t.size[0],height:t.size[1],numComps:4,dataType:&quot;Float32Array&quot;,data:null}),o.activate(),o.sendParameters(),o.deactivate(),o},e.allocateDepthTexture=e=>{const n=t.context,r=Pd.newInstance({generateMipmap:!1,openGLDataType:n.FLOAT,autoParameters:!1});return r.setOpenGLRenderWindow(e),r.createDepthFromRaw({width:t.size[0],height:t.size[1],dataType:&quot;Float32Array&quot;,data:null}),r.activate(),r.sendParameters(),r.deactivate(),r},e.createFBO=()=>{if(!t.framebuffer){t.licHelper=null;const e=Sp.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow),e.saveCurrentBindingsAndBuffers(),e.create(...t.size),e.populateFramebuffer(),t.framebuffer=e,e.restorePreviousBindingsAndBuffers()}},e.completedGeometry=()=>{const e=t.context,n=t.framebuffer;n.removeColorBuffer(0),n.removeColorBuffer(1),n.removeColorBuffer(2),n.removeDepthBuffer(),e.drawBuffers([e.NONE]),n.restorePreviousBindingsAndBuffers()},e.buildAllShaders=()=>{t.shadersNeedBuilding&&(t.licColorPass=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkSurfaceLICMapper_fs2.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// This shader combines surface geometry, LIC, and  scalar colors.\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 RGBOutput;\\nlayout(location = 1) out vec4 HSLOutput;\\n\\nuniform sampler2D texVectors;       // vectors, depth\\nuniform sampler2D texGeomColors;    // scalar colors + lighting\\nuniform sampler2D texLIC;           // image lic\\nuniform int       uScalarColorMode; // select between blend, and map shader\\nuniform float     uLICIntensity;    // blend shader: blending factor for lic'd colors\\nuniform float     uMapBias;         // map shader: adjust the brightness of the result\\nuniform float     uMaskIntensity;   // blending factor for mask color\\nuniform vec3      uMaskColor;       // color for the masked out fragments\\n\\nin vec2 tcoordVC;\\n\\n/**\\nConvert from RGB color space into HSL colorspace.\\n*/\\nvec3 RGBToHSL(vec3 RGB)\\n{\\n  vec3 HSL = vec3(0.0, 0.0, 0.0);\\n\\n  float RGBMin = min(min(RGB.r, RGB.g), RGB.b);\\n  float RGBMax = max(max(RGB.r, RGB.g), RGB.b);\\n  float RGBMaxMinDiff = RGBMax - RGBMin;\\n\\n  HSL.z = (RGBMax + RGBMin) / 2.0;\\n\\n  if (RGBMaxMinDiff == 0.0)\\n    {\\n    // Gray scale\\n    HSL.x = 0.0;\\n    HSL.y = 0.0;\\n    }\\n  else\\n    {\\n    // Color\\n    if (HSL.z < 0.5)\\n      HSL.y = RGBMaxMinDiff / (RGBMax + RGBMin);\\n    else\\n      HSL.y = RGBMaxMinDiff / (2.0 - RGBMax - RGBMin);\\n\\n    float dR\\n      = (((RGBMax - RGB.r) / 6.0) + (RGBMaxMinDiff / 2.0)) / RGBMaxMinDiff;\\n    float dG\\n      = (((RGBMax - RGB.g) / 6.0) + (RGBMaxMinDiff / 2.0)) / RGBMaxMinDiff;\\n    float dB\\n      = (((RGBMax - RGB.b) / 6.0) + (RGBMaxMinDiff / 2.0)) / RGBMaxMinDiff;\\n\\n    if (RGB.r == RGBMax)\\n      HSL.x = dB - dG;\\n    else\\n    if (RGB.g == RGBMax)\\n      HSL.x = (1.0 / 3.0) + dR - dB;\\n    else\\n    if (RGB.b == RGBMax)\\n      HSL.x = (2.0 / 3.0) + dG - dR;\\n\\n    if (HSL.x < 0.0)\\n      HSL.x += 1.0;\\n\\n    if (HSL.x > 1.0)\\n      HSL.x -= 1.0;\\n    }\\n\\n  return HSL;\\n}\\n\\n/**\\nHelper for HSL to RGB conversion.\\n*/\\nfloat Util(float v1, float v2, float vH)\\n{\\n  if (vH < 0.0)\\n    vH += 1.0;\\n\\n  if (vH > 1.0)\\n     vH -= 1.0;\\n\\n  if ((6.0 * vH) < 1.0)\\n    return (v1 + (v2 - v1) * 6.0 * vH);\\n\\n  if ((2.0 * vH) < 1.0)\\n    return (v2);\\n\\n  if ((3.0 * vH) < 2.0)\\n    return (v1 + (v2 - v1) * ((2.0 / 3.0) - vH) * 6.0);\\n\\n  return v1;\\n}\\n\\n/**\\nConvert from HSL space into RGB space.\\n*/\\nvec3 HSLToRGB(vec3 HSL)\\n{\\n  vec3 RGB;\\n  if (HSL.y == 0.0)\\n    {\\n    // Gray\\n    RGB.r = HSL.z;\\n    RGB.g = HSL.z;\\n    RGB.b = HSL.z;\\n    }\\n  else\\n    {\\n    // Chromatic\\n    float v2;\\n    if (HSL.z < 0.5)\\n      v2 = HSL.z * (1.0 + HSL.y);\\n    else\\n      v2 = (HSL.z + HSL.y) - (HSL.y * HSL.z);\\n\\n    float v1 = 2.0 * HSL.z - v2;\\n\\n    RGB.r = Util(v1, v2, HSL.x + (1.0 / 3.0));\\n    RGB.g = Util(v1, v2, HSL.x);\\n    RGB.b = Util(v1, v2, HSL.x - (1.0 / 3.0));\\n    }\\n\\n  return RGB.rgb;\\n}\\n\\nvoid main()\\n{\\n  vec4 lic = texture2D(texLIC, tcoordVC.st);\\n  vec4 geomColor = texture2D(texGeomColors, tcoordVC.st);\\n\\n  // depth is used to determine which fragment belong to us\\n  // and we can change\\n  float depth = texture2D(texVectors, tcoordVC.st).a;\\n\\n  vec3 fragColorRGB;\\n  float valid;\\n  if (depth > 1.0e-3)\\n    {\\n    // we own it\\n    // shade LIC'ed geometry, or apply mask\\n    if (lic.g!=0.0)\\n      {\\n      // it's masked\\n      // apply fragment mask\\n      fragColorRGB = uMaskIntensity * uMaskColor + (1.0 - uMaskIntensity) * geomColor.rgb;\\n      valid = 0.0;\\n      }\\n    else\\n      {\\n      if (uScalarColorMode==0)\\n        {\\n        // blend with scalars\\n        fragColorRGB = lic.rrr * uLICIntensity + geomColor.rgb * (1.0 - uLICIntensity);\\n        }\\n      else\\n        {\\n        // multiply with scalars\\n        fragColorRGB = geomColor.rgb * clamp((uMapBias + lic.r), 0.0, 1.0);\\n        }\\n      if (lic.b != 0.0)\\n        {\\n        // didn't have the required guard pixels\\n        // don't consider it in min max estimation\\n        // for histpgram stretching\\n        valid = 0.0;\\n        }\\n      else\\n        {\\n        // ok to use in min/max estimates for histogram\\n        // stretching\\n        valid = 1.0;\\n        }\\n      }\\n    }\\n  else\\n    {\\n    // we don't own it\\n    // pass through scalars\\n    fragColorRGB = geomColor.rgb;\\n    valid = 0.0;\\n    }\\n\\n  // if no further stages this texture is\\n  // copied to the screen\\n  RGBOutput = vec4(fragColorRGB, geomColor.a);\\n\\n  // if further stages, move to hsl space for contrast\\n  // enhancement. encoding validity saves moving a texture to the cpu\\n  vec3 fragColorHSL = RGBToHSL(fragColorRGB);\\n  HSLOutput = vec4(fragColorHSL, valid);\\n}\\n&quot;),t.licCopyPass=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkSurfaceLICMapper_DCpy.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// This shader copies fragments and depths to the output buffer\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nuniform sampler2D texDepth;     // z values from vertex shader\\nuniform sampler2D texRGBColors; // final rgb LIC colors\\n\\nin vec2 tcoordVC;\\n\\nvoid main()\\n{\\n  gl_FragDepth = texture2D(texDepth, tcoordVC).x;\\n  gl_FragData[0] = texture2D(texRGBColors, tcoordVC);\\n\\n  // since we render a screen aligned quad\\n  // we're going to be writing fragments\\n  // not touched by the original geometry\\n  // it's critical not to modify those\\n  // fragments.\\n  if (gl_FragDepth == 1.0)\\n    {\\n    discard;\\n    }\\n}\\n&quot;),t.enhanceContrastPass=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkSurfaceLICMapper_CE.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// color contrast enhance stage implemented via histogram stretching\\n// on lightness channel. if the min and max are tweaked it can generate\\n// out-of-range values these will be clamped in 0 to 1\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nuniform sampler2D texGeomColors; // scalars + lighting\\nuniform sampler2D texLIC;        // image lic, mask\\nuniform sampler2D texHSLColors;  // hsla colors\\n\\nuniform float     uLMin;         // min lightness over all fragments\\nuniform float     uLMaxMinDiff;  // max - min lightness over all fragments\\n\\nin vec2 tcoordVC;\\n\\nvec3 HSLToRGB(vec3 HSL)\\n{\\n  vec3 RGB;\\n  float v;\\n  float h = HSL.x;\\n  float sl = HSL.y;\\n  float l = HSL.z;\\n\\n  v = (l <= 0.5) ? (l * (1.0 + sl)) : (l + sl - l * sl);\\n  if (v <= 0.0) {\\n    RGB = vec3(0.0,0.0,0.0);\\n  } else {\\n    float m;\\n    int sextant;\\n    float fract, vsf, mid1, mid2;\\n\\n    m = l + l - v;\\n    h *= 6.0;\\n    sextant = int(h);\\n    fract = h - float(sextant);\\n\\n    vsf = (v - m) * fract;\\n    mid1 = m + vsf;\\n    mid2 = v - vsf;\\n    switch (sextant) {\\n      case 0: RGB.r = v; RGB.g = mid1; RGB.b = m; break;\\n      case 1: RGB.r = mid2; RGB.g = v; RGB.b = m; break;\\n      case 2: RGB.r = m; RGB.g = v; RGB.b = mid1; break;\\n      case 3: RGB.r = m; RGB.g = mid2; RGB.b = v; break;\\n      case 4: RGB.r = mid1; RGB.g = m; RGB.b = v; break;\\n      case 5: RGB.r = v; RGB.g = m; RGB.b = mid2; break;\\n    }\\n  }\\n  return RGB;\\n}\\n\\nvoid main()\\n{\\n  // lookup hsl color , mask\\n  vec4 fragColor = texture2D(texHSLColors, tcoordVC.st);\\n\\n  // don't modify masked fragments (masked => lic.g==1)\\n  vec4 lic = texture2D(texLIC, tcoordVC.st);\\n  if (lic.g==0.0)\\n    {\\n    // normalize lightness channel\\n    fragColor.z = clamp((fragColor.z - uLMin)/uLMaxMinDiff, 0.0, 1.0);\\n    }\\n\\n  // back into rgb space\\n  fragColor.rgb = HSLToRGB(fragColor.xyz);\\n\\n  // add alpha\\n  vec4 geomColor = texture2D(texGeomColors, tcoordVC.st);\\n  fragColor.a = geomColor.a;\\n\\n  gl_FragData[0] = fragColor;\\n}\\n&quot;),t.shadersNeedBuilding=!1)},e.initializeResources=()=>{e.createFBO(),e.generateNoiseTexture(t.licInterface.getNoiseTextureSize()),e.allocateTextures(),e.buildAllShaders(),t.licQuad||(t.licQuad=function(e){const t=ld.newInstance();t.setOpenGLRenderWindow(e);const n=new Float32Array(12);for(let e=0;e<4;e++)n[3*e]=e%2*2-1,n[3*e+1]=e>1?1:-1,n[3*e+2]=0;const r=new Float32Array([0,0,1,0,0,1,1,1]),o=new Uint16Array(8);o[0]=3,o[1]=0,o[2]=1,o[3]=3,o[4]=3,o[5]=0,o[6]=3,o[7]=2;const a=xs.newInstance({numberOfComponents:3,values:n});a.setName(&quot;points&quot;);const i=xs.newInstance({numberOfComponents:1,values:o}),s=xs.newInstance({numberOfComponents:2,values:r});return t.getCABO().createVBO(i,&quot;polys&quot;,Pg.SURFACE,{points:a,cellOffset:0,tcoords:s}),t}(t._openGLRenderWindow)),t.licHelper||(t.licHelper=Ag.newInstance())},e.prepareForGeometry=()=>{const e=t.framebuffer;e.saveCurrentBindingsAndBuffers(),e.bind(),t.geometryImage.activate(),t.vectorImage.activate(),t.maskVectorImage.activate(),e.removeColorBuffer(0),e.removeColorBuffer(2),e.removeColorBuffer(3),e.setColorBuffer(t.geometryImage,0),e.setColorBuffer(t.vectorImage,2),e.setColorBuffer(t.maskVectorImage,3),e.setDepthBuffer(t.depthTexture);const n=t.context;n.drawBuffers([n.COLOR_ATTACHMENT0,n.NONE,n.COLOR_ATTACHMENT2,n.COLOR_ATTACHMENT3]),n.viewport(0,0,...t.size),n.scissor(0,0,...t.size),n.disable(n.BLEND),n.disable(n.DEPTH_TEST),n.disable(n.SCISSOR_TEST),n.clearColor(0,0,0,0),n.clear(n.DEPTH_BUFFER_BIT|n.COLOR_BUFFER_BIT)},e.copyToScreen=n=>{t.RGBColorImage.activate(),t.depthTexture.activate(),t.licCopyPass||e.initializeResources();const r=t.licCopyPass;t._openGLRenderWindow.getShaderCache().readyShaderProgram(r);const o=t.context;o.viewport(0,0,...n),o.scissor(0,0,...n),o.disable(o.BLEND),o.enable(o.DEPTH_TEST),o.disable(o.SCISSOR_TEST),r.setUniformi(&quot;texDepth&quot;,t.depthTexture.getTextureUnit()),r.setUniformi(&quot;texRGBColors&quot;,t.RGBColorImage.getTextureUnit()),e.renderQuad(n,r),t.RGBColorImage.deactivate(),t.depthTexture.deactivate()},e.combineColorsAndLIC=()=>{const n=t.context,r=t.framebuffer;r.saveCurrentBindingsAndBuffers(),r.bind(),r.create(...t.size),r.removeColorBuffer(0),r.removeColorBuffer(1),r.setColorBuffer(t.RGBColorImage,0),r.setColorBuffer(t.HSLColorImage,1),n.drawBuffers([n.COLOR_ATTACHMENT0,n.COLOR_ATTACHMENT1]),n.disable(n.DEPTH_TEST),n.clearColor(0,0,0,0),n.clear(n.COLOR_BUFFER_BIT),t.vectorImage.activate(),t.geometryImage.activate(),t.LICImage.activate(),t.licColorPass||e.initializeResources();const o=t.licColorPass;t._openGLRenderWindow.getShaderCache().readyShaderProgram(o),o.setUniformi(&quot;texVectors&quot;,t.vectorImage.getTextureUnit()),o.setUniformi(&quot;texGeomColors&quot;,t.geometryImage.getTextureUnit());const{colorMode:a,LICIntensity:i,mapModeBias:s,maskIntensity:l,maskColor:c,enhanceContrast:u,lowColorContrastEnhancementFactor:d,highColorContrastEnhancementFactor:p}=t.licInterface.get(&quot;colorMode&quot;,&quot;LICIntensity&quot;,&quot;mapModeBias&quot;,&quot;maskIntensity&quot;,&quot;maskColor&quot;,&quot;enhanceContrast&quot;,&quot;lowColorContrastEnhancementFactor&quot;,&quot;highColorContrastEnhancementFactor&quot;);if(o.setUniformi(&quot;texLIC&quot;,t.LICImage.getTextureUnit()),o.setUniformi(&quot;uScalarColorMode&quot;,a),o.setUniformf(&quot;uLICIntensity&quot;,i),o.setUniformf(&quot;uMapBias&quot;,s),o.setUniformf(&quot;uMaskIntensity&quot;,l),o.setUniform3f(&quot;uMaskColor&quot;,...c),e.renderQuad(t.size,o),t.vectorImage.deactivate(),t.geometryImage.deactivate(),t.LICImage.deactivate(),r.removeColorBuffer(0),r.removeColorBuffer(1),n.drawBuffers([n.NONE]),u===yg||u===bg){let o=0,a=1,i=a-o;o+=i*d,a-=i*p,i=a-o,r.setColorBuffer(t.RGBColorImage),n.drawBuffers([n.COLOR_ATTACHMENT0]),t.geometryImage.activate(),t.HSLColorImage.activate(),t.LICImage.activate(),t.enhanceContrastPass||e.initializeResources();const{enhanceContrastPass:s}=t;t._openGLRenderWindow.getShaderCache().readyShaderProgram(s),s.setUniformi(&quot;texGeomColors&quot;,t.geometryImage.getTextureUnit()),s.setUniformi(&quot;texHSLColors&quot;,t.HSLColorImage.getTextureUnit()),s.setUniformi(&quot;texLIC&quot;,t.LICImage.getTextureUnit()),s.setUniformf(&quot;uLMin&quot;,o),s.setUniformf(&quot;uLMaxMinDiff&quot;,i),e.renderQuad(t.size,s),t.geometryImage.deactivate(),t.HSLColorImage.deactivate(),t.LICImage.deactivate(),r.removeColorBuffer(0),n.drawBuffers([n.NONE])}r.restorePreviousBindingsAndBuffers()},e.applyLIC=()=>{const e=t.licInterface.get(&quot;stepSize&quot;,&quot;numberOfSteps&quot;,&quot;enhancedLIC&quot;,&quot;enhanceContrast&quot;,&quot;lowLICContrastEnhancementFactor&quot;,&quot;highLICContrastEnhancementFactor&quot;,&quot;antiAlias&quot;,&quot;normalizeVectors&quot;,&quot;maskThreshold&quot;,&quot;transformVectors&quot;),n=t.licHelper.executeLIC(t.size,t.vectorImage,t.maskVectorImage,t.noiseTexture,t._openGLRenderWindow,e);if(!n)return console.error(&quot;Failed to compute image LIC&quot;),void(t.LICImage=null);t.LICImage=n},e.setSize=n=>{Array.isArray(n)&&2===n.length&&(t.size&&t.size[0]===n[0]&&t.size[1]===n[1]||(t.size=n,e.releaseGraphicsResources()))},e.releaseGraphicsResources=()=>{t.geometryImage&&(t.geometryImage.releaseGraphicsResources(),t.geometryImage=null),t.vectorImage&&(t.vectorImage.releaseGraphicsResources(),t.vectorImage=null),t.maskVectorImage&&(t.maskVectorImage.releaseGraphicsResources(),t.maskVectorImage=null),t.LICImage&&(t.LICImage.releaseGraphicsResources(),t.LICImage=null),t.RGBColorImage&&(t.RGBColorImage.releaseGraphicsResources(),t.RGBColorImage=null),t.HSLColorImage&&(t.HSLColorImage.releaseGraphicsResources(),t.HSLColorImage=null),t.depthTexture&&(t.depthTexture.releaseGraphicsResources(),t.depthTexture=null),t.framebuffer&&(t.framebuffer.releaseGraphicsResources(),t.framebuffer=null)}}(e,t)}var Eg={newInstance:Wt.newInstance(Mg,&quot;vtkSurfaceLICInterface&quot;),extend:Mg};const{vtkErrorMacro:Vg}=Ht,Dg={canDrawLIC:!1,rebuildLICShaders:!1,rebuildLICBuffers:!1,openGLLicInterface:null};const Lg=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Dg,n),$d.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLSurfaceLICMapper&quot;);const n={...e};e.getNeedToRebuildShaders=(e,r,o)=>t.rebuildLICShaders||n.getNeedToRebuildShaders(e,r,o),e.replaceShaderValues=(e,r,o)=>{const a=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);let i=e.Vertex,s=e.Fragment;const l=t.renderable.getInputArrayToProcess(0);if(l&&t.canDrawLIC){s=td.substitute(s,&quot;//VTK::Output::Dec&quot;,[&quot;//VTK::Output::Dec&quot;,&quot;layout(location = 2) out vec4 vectorTexture;&quot;,&quot;layout(location = 3) out vec4 maskVectorTexture;&quot;]).result;const n=`${l.getName()}MC`;0===a&&t.lastBoundBO.set({lastLightComplexity:1},!0),i=td.substitute(i,&quot;//VTK::TCoord::Dec&quot;,[`attribute vec3 ${n};`,&quot;out vec3 licOutput;&quot;,&quot;//VTK::TCoord::Dec&quot;]).result,i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[`licOutput = ${n};`,&quot;//VTK::TCoord::Impl&quot;]).result,s=td.substitute(s,&quot;//VTK::TCoord::Dec&quot;,[&quot;uniform int uMaskOnSurface;&quot;,&quot;uniform mat3 normalMatrix;&quot;,&quot;in vec3 licOutput;&quot;,&quot;//VTK::TCoord::Dec&quot;]).result,s=td.substitute(s,&quot;//VTK::TCoord::Impl&quot;,[&quot;// projected vectors&quot;,&quot;  vec3 tcoordLIC = normalMatrix * licOutput;&quot;,&quot;  vec3 normN = normalize(normalVCVSOutput);&quot;,&quot;  float k = dot(tcoordLIC, normN);&quot;,&quot;  vec3 projected = (tcoordLIC - k*normN);&quot;,&quot;  vectorTexture = vec4(projected.x, projected.y, 0.0 , 1.0);&quot;,&quot;// vectors for fragment masking&quot;,&quot;  if (uMaskOnSurface == 0)&quot;,&quot;    {&quot;,&quot;    maskVectorTexture = vec4(licOutput, 1.0);&quot;,&quot;    }&quot;,&quot;  else&quot;,&quot;    {&quot;,&quot;    maskVectorTexture = vec4(projected.x, projected.y, 0.0 , 1.0);&quot;,&quot;    }&quot;,&quot;//VTK::TCoord::Impl&quot;],!1).result,e.Vertex=i}t.rebuildLICShaders=!1,e.Fragment=s,n.replaceShaderValues(e,r,o),a>0&&t.lastBoundBO.set({lastLightComplexity:a},!0)},e.setMapperShaderParameters=(e,r,o)=>{n.setMapperShaderParameters(e,r,o),t.canDrawLIC&&e.getProgram().setUniformi(&quot;uMaskOnSurface&quot;,t.maskOnSurface)},e.getNeedToRebuildBufferObjects=(e,r)=>t.rebuildLICBuffers||n.getNeedToRebuildBufferObjects(e,r),e.buildBufferObjects=(e,r)=>{if(t.canDrawLIC){const e=t.renderable.getInputArrayToProcess(0);e&&e.getNumberOfComponents()>1&&t.renderable.setCustomShaderAttributes([e.getName()])}t.rebuildLICBuffers=!1,n.buildBufferObjects(e,r)},e.pushState=e=>{t.stateCache={[e.BLEND]:e.isEnabled(e.BLEND),[e.DEPTH_TEST]:e.isEnabled(e.DEPTH_TEST),[e.SCISSOR_TEST]:e.isEnabled(e.SCISSOR_TEST),[e.CULL_FACE]:e.isEnabled(e.CULL_FACE)}},e.popState=e=>{const n=n=>t.stateCache[n]?e.enable(n):e.disable(n);n(e.BLEND),n(e.DEPTH_TEST),n(e.SCISSOR_TEST),n(e.CULL_FACE)},e.renderPiece=(r,o)=>{let a=!0;t._openGLRenderWindow.getWebgl2()||(Vg(&quot;SurfaceLICMapper Requires WebGL 2&quot;),a=!1),t.context.getExtension(&quot;EXT_color_buffer_float&quot;)&&t.context.getExtension(&quot;OES_texture_float_linear&quot;)||(Vg(&quot;SurfaceLICMapper requires the EXT_color_buffer_float and OES_texture_float_linear WebGL2 extensions.&quot;),a=!1),t.currentInput=t.renderable.getInputData(),t.currentInput||(Vg(&quot;No input&quot;),a=!1);let i=t.renderable.getLicInterface();i||(i=Og.newInstance(),t.renderable.setLicInterface(i)),t.openGLLicInterface||(t.openGLLicInterface=Eg.newInstance()),i!==t.openGLLicInterface.getLicInterface()&&t.openGLLicInterface.setLicInterface(i);const s=t.renderable.getInputArrayToProcess(0);if(i.getEnableLIC()&&(!s||s.getNumberOfComponents()<2)&&(Vg(&quot;No vector input array&quot;),a=!1),i.getEnableLIC()||(a=!1),t.canDrawLIC!==a&&(t.rebuildLICShaders=!0,t.rebuildLICBuffers=!0),t.canDrawLIC=a,!a||!i.getEnableLIC())return void n.renderPiece(r,o);const l=t.context,c=o.getProperty().getBackfaceCulling(),u=o.getProperty().getFrontfaceCulling();c||u?u?(t._openGLRenderWindow.enableCullFace(),l.cullFace(l.FRONT)):(t._openGLRenderWindow.enableCullFace(),l.cullFace(l.BACK)):t._openGLRenderWindow.disableCullFace();const d=t._openGLRenderWindow.getSize(),p=d.map((e=>Math.round(e*i.getViewPortScale())));t.openGLLicInterface.setSize(p),t.openGLLicInterface.setOpenGLRenderWindow(t._openGLRenderWindow),t.openGLLicInterface.setContext(t.context),e.pushState(t.context),t.openGLLicInterface.initializeResources(),t.openGLLicInterface.prepareForGeometry(),e.popState(t.context),n.renderPieceStart(r,o),n.renderPieceDraw(r,o),n.renderPieceFinish(r,o),e.pushState(t.context),t.VBOBuildTime.modified(),t.openGLLicInterface.completedGeometry(),t.context.disable(t.context.CULL_FACE),t.openGLLicInterface.applyLIC(),t.openGLLicInterface.combineColorsAndLIC(),t.openGLLicInterface.copyToScreen(d),e.popState(t.context)}}(e,t),Ct(e,t,[&quot;openGLLicInterface&quot;])}),&quot;vtkOpenGLSurfaceLICMapper&quot;);Jt(&quot;vtkSurfaceLICMapper&quot;,Lg);const{vtkErrorMacro:Bg}=Ht,Ng={};const Fg=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ng,n),$d.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLSphereMapper&quot;);const n={...e};e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkSphereMapperVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// this shader implements imposters in OpenGL for Spheres\\n\\nattribute vec4 vertexMC;\\nattribute vec2 offsetMC;\\n\\n// optional normal declaration\\n//VTK::Normal::Dec\\n\\n//VTK::Picking::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\nuniform mat3 normalMatrix; // transform model coordinate directions to view coordinates\\n\\n// material property values\\n//VTK::Color::Dec\\n\\n// clipping plane vars\\n//VTK::Clip::Dec\\n\\n// camera and actor matrix values\\n//VTK::Camera::Dec\\n\\nvarying vec4 vertexVCVSOutput;\\nvarying float radiusVCVSOutput;\\nvarying vec3 centerVCVSOutput;\\n\\nuniform int cameraParallel;\\nuniform float scaleFactor;\\n\\nvoid main()\\n{\\n  //VTK::Picking::Impl\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Clip::Impl\\n\\n  // compute the projected vertex position\\n  vec2 scaledOffsetMC = scaleFactor * offsetMC;\\n  vertexVCVSOutput = MCVCMatrix * vertexMC;\\n  centerVCVSOutput = vertexVCVSOutput.xyz;\\n  radiusVCVSOutput = length(scaledOffsetMC)*0.5;\\n\\n  // make the triangle face the camera\\n  if (cameraParallel == 0)\\n    {\\n    vec3 dir = normalize(-vertexVCVSOutput.xyz);\\n    vec3 base2 = normalize(cross(dir,vec3(1.0,0.0,0.0)));\\n    vec3 base1 = cross(base2,dir);\\n    vertexVCVSOutput.xyz = vertexVCVSOutput.xyz + scaledOffsetMC.x*base1 + scaledOffsetMC.y*base2;\\n    }\\n  else\\n    {\\n    // add in the offset\\n    vertexVCVSOutput.xy = vertexVCVSOutput.xy + scaledOffsetMC;\\n    }\\n\\n  gl_Position = VCPCMatrix * vertexVCVSOutput;\\n}\\n&quot;,e.Fragment=Md,e.Geometry=&quot;&quot;},e.replaceShaderValues=(e,r,o)=>{let a=e.Vertex,i=e.Fragment;a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 VCPCMatrix;\\n&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Dec&quot;,[&quot;varying vec4 vertexVCVSOutput;&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vec4 vertexVC = vertexVCVSOutput;\\n&quot;]).result,i=td.substitute(i,&quot;//VTK::Normal::Dec&quot;,[&quot;uniform float invertedDepth;\\n&quot;,&quot;uniform int cameraParallel;\\n&quot;,&quot;varying float radiusVCVSOutput;\\n&quot;,&quot;varying vec3 centerVCVSOutput;\\n&quot;,&quot;uniform mat4 VCPCMatrix;\\n&quot;]).result;let s=&quot;&quot;;t.context.getExtension(&quot;EXT_frag_depth&quot;)&&(s=&quot;gl_FragDepthEXT = (pos.z / pos.w + 1.0) / 2.0;\\n&quot;),t._openGLRenderWindow.getWebgl2()&&(s=&quot;gl_FragDepth = (pos.z / pos.w + 1.0) / 2.0;\\n&quot;),i=td.substitute(i,&quot;//VTK::Depth::Impl&quot;,[&quot;  vec3 EyePos;\\n&quot;,&quot;  vec3 EyeDir;\\n&quot;,&quot;  if (cameraParallel != 0) {\\n&quot;,&quot;    EyePos = vec3(vertexVC.x, vertexVC.y, vertexVC.z + 3.0*radiusVCVSOutput);\\n&quot;,&quot;    EyeDir = vec3(0.0,0.0,-1.0); }\\n&quot;,&quot;  else {\\n&quot;,&quot;    EyeDir = vertexVC.xyz;\\n&quot;,&quot;    EyePos = vec3(0.0,0.0,0.0);\\n&quot;,&quot;    float lengthED = length(EyeDir);\\n&quot;,&quot;    EyeDir = normalize(EyeDir);\\n&quot;,&quot;    if (lengthED > radiusVCVSOutput*3.0) {\\n&quot;,&quot;      EyePos = vertexVC.xyz - EyeDir*3.0*radiusVCVSOutput; }\\n&quot;,&quot;    }\\n&quot;,&quot;  EyePos = EyePos - centerVCVSOutput;\\n&quot;,&quot;  EyePos = EyePos/radiusVCVSOutput;\\n&quot;,&quot;  float b = 2.0*dot(EyePos,EyeDir);\\n&quot;,&quot;  float c = dot(EyePos,EyePos) - 1.0;\\n&quot;,&quot;  float d = b*b - 4.0*c;\\n&quot;,&quot;  vec3 normalVCVSOutput = vec3(0.0,0.0,1.0);\\n&quot;,&quot;  if (d < 0.0) { discard; }\\n&quot;,&quot;  else {\\n&quot;,&quot;    float t = (-b - invertedDepth*sqrt(d))*0.5;\\n&quot;,&quot;    normalVCVSOutput = invertedDepth*normalize(EyePos + t*EyeDir);\\n&quot;,&quot;    vertexVC.xyz = normalVCVSOutput*radiusVCVSOutput + centerVCVSOutput;\\n&quot;,&quot;    }\\n&quot;,&quot;  vec4 pos = VCPCMatrix * vertexVC;\\n&quot;,s]).result,i=td.substitute(i,&quot;//VTK::Normal::Impl&quot;,&quot;&quot;).result,t.haveSeenDepthRequest&&(i=td.substitute(i,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float computedZ = (pos.z / pos.w + 1.0) / 2.0;&quot;,&quot;float iz = floor(computedZ * 65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result),e.Vertex=a,e.Fragment=i,n.replaceShaderValues(e,r,o)},e.setMapperShaderParameters=(e,r,o)=>{if(e.getCABO().getElementCount()&&(t.VBOBuildTime>e.getAttributeUpdateTime().getMTime()||e.getShaderSourceTime().getMTime()>e.getAttributeUpdateTime().getMTime())&&e.getProgram().isAttributeUsed(&quot;offsetMC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;offsetMC&quot;,12,e.getCABO().getStride(),t.context.FLOAT,2,!1)||Bg(&quot;Error setting 'offsetMC' in shader VAO.&quot;)),e.getProgram().isUniformUsed(&quot;invertedDepth&quot;)&&e.getProgram().setUniformf(&quot;invertedDepth&quot;,t.invert?-1:1),e.getProgram().isUniformUsed(&quot;scaleFactor&quot;)){const n=t.currentInput.getPointData();null!=t.renderable.getScaleArray()&&n.hasArray(t.renderable.getScaleArray())?e.getProgram().setUniformf(&quot;scaleFactor&quot;,t.renderable.getScaleFactor()):e.getProgram().setUniformf(&quot;scaleFactor&quot;,1)}n.setMapperShaderParameters(e,r,o)},e.setCameraShaderParameters=(e,n,r)=>{const o=e.getProgram(),a=n.getActiveCamera(),i=t.openGLCamera.getKeyMatrices(n);o.isUniformUsed(&quot;VCPCMatrix&quot;)&&o.setUniformMatrix(&quot;VCPCMatrix&quot;,i.vcpc);const s=new Float64Array(16);if(o.isUniformUsed(&quot;MCVCMatrix&quot;))if(r.getIsIdentity())p(s,i.wcvc),e.getCABO().getCoordShiftAndScaleEnabled()&&b(s,s,e.getCABO().getInverseShiftAndScaleMatrix()),o.setUniformMatrix(&quot;MCVCMatrix&quot;,s);else{const n=t.openGLActor.getKeyMatrices();b(s,i.wcvc,n.mcwc),e.getCABO().getCoordShiftAndScaleEnabled()&&b(s,s,e.getCABO().getInverseShiftAndScaleMatrix()),o.setUniformMatrix(&quot;MCVCMatrix&quot;,s)}o.isUniformUsed(&quot;cameraParallel&quot;)&&e.getProgram().setUniformi(&quot;cameraParallel&quot;,a.getParallelProjection())},e.getOpenGLMode=(e,n)=>t.context.TRIANGLES,e.buildBufferObjects=(e,n)=>{const r=t.currentInput;if(null===r)return;t.renderable.mapScalars(r,1);const o=t.renderable.getColorMapColors(),a=t.primitives[t.primTypes.Tris].getCABO(),i=r.getPointData(),s=r.getPoints(),l=s.getNumberOfPoints(),c=s.getData();let u=null;null!=t.renderable.getScaleArray()&&i.hasArray(t.renderable.getScaleArray())&&(u=i.getArray(t.renderable.getScaleArray()).getData());let d=null,p=0,f=null;o?(p=o.getNumberOfComponents(),a.setColorOffset(0),a.setColorBOStride(4),d=o.getData(),f=new Uint8Array(3*l*4),a.getColorBO()||a.setColorBO(zu.newInstance()),a.getColorBO().setOpenGLRenderWindow(t._openGLRenderWindow)):a.getColorBO()&&a.setColorBO(null),a.setColorComponents(p);const g=new Float32Array(5*l*3);a.setStride(20);const m=Math.cos(vo(30));let h=0,v=0;const{useShiftAndScale:T,coordShift:y,coordScale:b}=Wu(s);T&&a.setCoordShiftAndScale(y,b);let x=0,C=0;for(let e=0;e<l;++e){let n=t.renderable.getRadius();u&&(n=u[e]),h=3*e;const r=(c[h++]-y[0])*b[0],o=(c[h++]-y[1])*b[1],a=(c[h++]-y[2])*b[2];g[x++]=r,g[x++]=o,g[x++]=a,g[x++]=-2*n*m,g[x++]=-n,d&&(v=e*p,f[C++]=d[v],f[C++]=d[v+1],f[C++]=d[v+2],f[C++]=d[v+3]),g[x++]=r,g[x++]=o,g[x++]=a,g[x++]=2*n*m,g[x++]=-n,d&&(f[C++]=d[v],f[C++]=d[v+1],f[C++]=d[v+2],f[C++]=d[v+3]),g[x++]=r,g[x++]=o,g[x++]=a,g[x++]=0,g[x++]=2*n,d&&(f[C++]=d[v],f[C++]=d[v+1],f[C++]=d[v+2],f[C++]=d[v+3])}a.setElementCount(x/5),a.upload(g,Fu.ARRAY_BUFFER),o&&a.getColorBO().upload(f,Fu.ARRAY_BUFFER),t.VBOBuildTime.modified()}}(e,t)}),&quot;vtkOpenGLSphereMapper&quot;);Jt(&quot;vtkSphereMapper&quot;,Fg);const{vtkErrorMacro:_g}=Ht,kg={};const Gg=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,kg,n),$d.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLStickMapper&quot;);const n={...e};e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkStickMapperVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// this shader implements imposters in OpenGL for Sticks\\n\\nattribute vec4 vertexMC;\\nattribute vec3 orientMC;\\nattribute vec4 offsetMC;\\nattribute float radiusMC;\\n\\n// optional normal declaration\\n//VTK::Normal::Dec\\n\\n//VTK::Picking::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\nuniform mat3 normalMatrix; // transform model coordinate directions to view coordinates\\n\\n// material property values\\n//VTK::Color::Dec\\n\\n// clipping plane vars\\n//VTK::Clip::Dec\\n\\n// camera and actor matrix values\\n//VTK::Camera::Dec\\n\\nvarying vec4 vertexVCVSOutput;\\nvarying float radiusVCVSOutput;\\nvarying float lengthVCVSOutput;\\nvarying vec3 centerVCVSOutput;\\nvarying vec3 orientVCVSOutput;\\n\\nuniform int cameraParallel;\\n\\nvoid main()\\n{\\n  //VTK::Picking::Impl\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Clip::Impl\\n\\n  vertexVCVSOutput = MCVCMatrix * vertexMC;\\n  centerVCVSOutput = vertexVCVSOutput.xyz;\\n  radiusVCVSOutput = radiusMC;\\n  lengthVCVSOutput = length(orientMC);\\n  orientVCVSOutput = normalMatrix * normalize(orientMC);\\n\\n  // make sure it is pointing out of the screen\\n  if (orientVCVSOutput.z < 0.0)\\n    {\\n    orientVCVSOutput = -orientVCVSOutput;\\n    }\\n\\n  // make the basis\\n  vec3 xbase;\\n  vec3 ybase;\\n  vec3 dir = vec3(0.0,0.0,1.0);\\n  if (cameraParallel == 0)\\n    {\\n    dir = normalize(-vertexVCVSOutput.xyz);\\n    }\\n  if (abs(dot(dir,orientVCVSOutput)) == 1.0)\\n    {\\n    xbase = normalize(cross(vec3(0.0,1.0,0.0),orientVCVSOutput));\\n    ybase = cross(xbase,orientVCVSOutput);\\n    }\\n  else\\n    {\\n    xbase = normalize(cross(orientVCVSOutput,dir));\\n    ybase = cross(orientVCVSOutput,xbase);\\n    }\\n\\n  vec3 offsets = offsetMC.xyz*2.0-1.0;\\n  vertexVCVSOutput.xyz = vertexVCVSOutput.xyz +\\n    radiusVCVSOutput*offsets.x*xbase +\\n    radiusVCVSOutput*offsets.y*ybase +\\n    0.5*lengthVCVSOutput*offsets.z*orientVCVSOutput;\\n\\n  gl_Position = VCPCMatrix * vertexVCVSOutput;\\n}\\n&quot;,e.Fragment=Md,e.Geometry=&quot;&quot;},e.replaceShaderValues=(e,r,o)=>{let a=e.Vertex,i=e.Fragment;a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 VCPCMatrix;\\n&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Dec&quot;,&quot;varying vec4 vertexVCVSOutput;&quot;).result,i=td.substitute(i,&quot;//VTK::PositionVC::Impl&quot;,&quot;  vec4 vertexVC = vertexVCVSOutput;\\n&quot;).result,i=td.substitute(i,&quot;//VTK::Normal::Dec&quot;,[&quot;uniform int cameraParallel;\\n&quot;,&quot;varying float radiusVCVSOutput;\\n&quot;,&quot;varying vec3 orientVCVSOutput;\\n&quot;,&quot;varying float lengthVCVSOutput;\\n&quot;,&quot;varying vec3 centerVCVSOutput;\\n&quot;,&quot;uniform mat4 VCPCMatrix;\\n&quot;]).result;let s=&quot;&quot;;t.context.getExtension(&quot;EXT_frag_depth&quot;)&&(s=&quot;  gl_FragDepthEXT = (pos.z / pos.w + 1.0) / 2.0;\\n&quot;),t._openGLRenderWindow.getWebgl2()&&(s=&quot;gl_FragDepth = (pos.z / pos.w + 1.0) / 2.0;\\n&quot;),i=td.substitute(i,&quot;//VTK::Depth::Impl&quot;,[&quot;  vec3 EyePos;\\n&quot;,&quot;  vec3 EyeDir;\\n&quot;,&quot;  if (cameraParallel != 0) {\\n&quot;,&quot;    EyePos = vec3(vertexVC.x, vertexVC.y, vertexVC.z + 3.0*radiusVCVSOutput);\\n&quot;,&quot;    EyeDir = vec3(0.0,0.0,-1.0); }\\n&quot;,&quot;  else {\\n&quot;,&quot;    EyeDir = vertexVC.xyz;\\n&quot;,&quot;    EyePos = vec3(0.0,0.0,0.0);\\n&quot;,&quot;    float lengthED = length(EyeDir);\\n&quot;,&quot;    EyeDir = normalize(EyeDir);\\n&quot;,&quot;    if (lengthED > radiusVCVSOutput*3.0) {\\n&quot;,&quot;      EyePos = vertexVC.xyz - EyeDir*3.0*radiusVCVSOutput; }\\n&quot;,&quot;    }\\n&quot;,&quot;  EyePos = EyePos - centerVCVSOutput;\\n&quot;,&quot;  vec3 base1;\\n&quot;,&quot;  if (abs(orientVCVSOutput.z) < 0.99) {\\n&quot;,&quot;    base1 = normalize(cross(orientVCVSOutput,vec3(0.0,0.0,1.0))); }\\n&quot;,&quot;  else {\\n&quot;,&quot;    base1 = normalize(cross(orientVCVSOutput,vec3(0.0,1.0,0.0))); }\\n&quot;,&quot;  vec3 base2 = cross(orientVCVSOutput,base1);\\n&quot;,&quot;  EyePos = vec3(dot(EyePos,base1),dot(EyePos,base2),dot(EyePos,orientVCVSOutput));\\n&quot;,&quot;  EyeDir = vec3(dot(EyeDir,base1),dot(EyeDir,base2),dot(EyeDir,orientVCVSOutput));\\n&quot;,&quot;  EyePos = EyePos/radiusVCVSOutput;\\n&quot;,&quot;  float a = EyeDir.x*EyeDir.x + EyeDir.y*EyeDir.y;\\n&quot;,&quot;  float b = 2.0*(EyePos.x*EyeDir.x + EyePos.y*EyeDir.y);\\n&quot;,&quot;  float c = EyePos.x*EyePos.x + EyePos.y*EyePos.y - 1.0;\\n&quot;,&quot;  float d = b*b - 4.0*a*c;\\n&quot;,&quot;  vec3 normalVCVSOutput = vec3(0.0,0.0,1.0);\\n&quot;,&quot;  if (d < 0.0) { discard; }\\n&quot;,&quot;  else {\\n&quot;,&quot;    float t =  (-b - sqrt(d))/(2.0*a);\\n&quot;,&quot;    float tz = EyePos.z + t*EyeDir.z;\\n&quot;,&quot;    vec3 iPoint = EyePos + t*EyeDir;\\n&quot;,&quot;    if (abs(iPoint.z)*radiusVCVSOutput > lengthVCVSOutput*0.5) {\\n&quot;,&quot;      float t2 = (-b + sqrt(d))/(2.0*a);\\n&quot;,&quot;      float tz2 = EyePos.z + t2*EyeDir.z;\\n&quot;,&quot;      if (tz2*radiusVCVSOutput > lengthVCVSOutput*0.5 || tz*radiusVCVSOutput < -0.5*lengthVCVSOutput) { discard; }\\n&quot;,&quot;      else {\\n&quot;,&quot;        normalVCVSOutput = orientVCVSOutput;\\n&quot;,&quot;        float t3 = (lengthVCVSOutput*0.5/radiusVCVSOutput - EyePos.z)/EyeDir.z;\\n&quot;,&quot;        iPoint = EyePos + t3*EyeDir;\\n&quot;,&quot;        vertexVC.xyz = radiusVCVSOutput*(iPoint.x*base1 + iPoint.y*base2 + iPoint.z*orientVCVSOutput) + centerVCVSOutput;\\n&quot;,&quot;        }\\n&quot;,&quot;      }\\n&quot;,&quot;    else {\\n&quot;,&quot;      normalVCVSOutput = iPoint.x*base1 + iPoint.y*base2;\\n&quot;,&quot;      vertexVC.xyz = radiusVCVSOutput*(normalVCVSOutput + iPoint.z*orientVCVSOutput) + centerVCVSOutput;\\n&quot;,&quot;      }\\n&quot;,&quot;    }\\n&quot;,&quot;  vec4 pos = VCPCMatrix * vertexVC;\\n&quot;,s]).result,i=td.substitute(i,&quot;//VTK::Normal::Impl&quot;,&quot;&quot;).result,t.haveSeenDepthRequest&&(i=td.substitute(i,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float computedZ = (pos.z / pos.w + 1.0) / 2.0;&quot;,&quot;float iz = floor(computedZ * 65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result),e.Vertex=a,e.Fragment=i,n.replaceShaderValues(e,r,o)},e.setMapperShaderParameters=(e,r,o)=>{e.getCABO().getElementCount()&&(t.VBOBuildTime>e.getAttributeUpdateTime().getMTime()||e.getShaderSourceTime().getMTime()>e.getAttributeUpdateTime().getMTime())&&(e.getProgram().isAttributeUsed(&quot;orientMC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;orientMC&quot;,12,e.getCABO().getStride(),t.context.FLOAT,3,!1)||_g(&quot;Error setting 'orientMC' in shader VAO.&quot;)),e.getProgram().isAttributeUsed(&quot;offsetMC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO().getColorBO(),&quot;offsetMC&quot;,0,e.getCABO().getColorBOStride(),t.context.UNSIGNED_BYTE,3,!0)||_g(&quot;Error setting 'offsetMC' in shader VAO.&quot;)),e.getProgram().isAttributeUsed(&quot;radiusMC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;radiusMC&quot;,24,e.getCABO().getStride(),t.context.FLOAT,1,!1)||_g(&quot;Error setting 'radiusMC' in shader VAO.&quot;))),n.setMapperShaderParameters(e,r,o)},e.setCameraShaderParameters=(e,n,r)=>{const o=e.getProgram(),a=n.getActiveCamera(),i=t.openGLCamera.getKeyMatrices(n);if(o.isUniformUsed(&quot;VCPCMatrix&quot;)&&o.setUniformMatrix(&quot;VCPCMatrix&quot;,i.vcpc),r.getIsIdentity())o.isUniformUsed(&quot;MCVCMatrix&quot;)&&o.setUniformMatrix(&quot;MCVCMatrix&quot;,i.wcvc),o.isUniformUsed(&quot;normalMatrix&quot;)&&o.setUniformMatrix3x3(&quot;normalMatrix&quot;,i.normalMatrix);else{const e=t.openGLActor.getKeyMatrices();if(o.isUniformUsed(&quot;MCVCMatrix&quot;)){const t=new Float64Array(16);b(t,i.wcvc,e.mcwc),o.setUniformMatrix(&quot;MCVCMatrix&quot;,t)}if(o.isUniformUsed(&quot;normalMatrix&quot;)){const t=new Float64Array(9);Te(t,i.normalMatrix,e.normalMatrix),o.setUniformMatrix3x3(&quot;normalMatrix&quot;,t)}}o.isUniformUsed(&quot;cameraParallel&quot;)&&e.getProgram().setUniformi(&quot;cameraParallel&quot;,a.getParallelProjection())},e.getOpenGLMode=(e,n)=>t.context.TRIANGLES,e.buildBufferObjects=(e,n)=>{const r=t.currentInput;if(null===r)return;t.renderable.mapScalars(r,1);const o=t.renderable.getColorMapColors(),a=t.primitives[t.primTypes.Tris].getCABO(),i=r.getPointData(),s=r.getPoints(),l=s.getNumberOfPoints(),c=s.getData();let u=3;u+=4;let d=null,p=0;a.setColorBOStride(4),a.getColorBO()||a.setColorBO(zu.newInstance()),a.getColorBO().setOpenGLRenderWindow(t._openGLRenderWindow),o&&(p=o.getNumberOfComponents(),a.setColorOffset(4),d=o.getData(),a.setColorBOStride(8)),a.setColorComponents(p),a.setStride(28);const f=new Float32Array(7*l*12),g=new Uint8Array(12*l*(d?8:4));let m=null,h=null;null!=t.renderable.getScaleArray()&&i.hasArray(t.renderable.getScaleArray())&&(m=i.getArray(t.renderable.getScaleArray()).getData()),null!=t.renderable.getOrientationArray()&&i.hasArray(t.renderable.getOrientationArray())?h=i.getArray(t.renderable.getOrientationArray()).getData():_g([&quot;Error setting orientationArray.\\n&quot;,&quot;You have to specify the stick orientation&quot;]);const v=[0,1,3,0,3,2,2,3,5,2,5,4];let T=0,y=0,b=0,x=0;for(let e=0;e<l;++e){let n=t.renderable.getLength(),r=t.renderable.getRadius();m&&(n=m[2*e],r=m[2*e+1]);for(let t=0;t<v.length;++t)T=3*e,f[b++]=c[T++],f[b++]=c[T++],f[b++]=c[T++],T=3*e,f[b++]=h[T++]*n,f[b++]=h[T++]*n,f[b++]=h[T++]*n,f[b++]=r,g[x++]=v[t]%2*255,g[x++]=v[t]>=4?255:0,g[x++]=v[t]>=2?255:0,g[x++]=255,y=e*p,d&&(g[x++]=d[y],g[x++]=d[y+1],g[x++]=d[y+2],g[x++]=d[y+3])}a.setElementCount(b/7),a.upload(f,Fu.ARRAY_BUFFER),a.getColorBO().upload(g,Fu.ARRAY_BUFFER),t.VBOBuildTime.modified()}}(e,t)}),&quot;vtkOpenGLStickMapper&quot;);Jt(&quot;vtkStickMapper&quot;,Gg);const Ug=[];Ug[&quot;-&quot;.charCodeAt(0)]=62,Ug[&quot;_&quot;.charCodeAt(0)]=63;const zg=&quot;ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/&quot;;for(let e=0;e<64;e++)Ug[zg.charCodeAt(e)]=e;function Wg(e){return void 0!==Ug[e.charCodeAt(0)]}function Hg(e,t,n,r){const{start:o,count:a}=t,i=a%4,s=Math.floor(a/4);let l=o,c=null,u=n;for(let t=0;t<s;t++){for(;!Wg(e[l]);)l++;for(c=Ug[e.charCodeAt(l++)]<<18;!Wg(e[l]);)l++;for(c|=Ug[e.charCodeAt(l++)]<<12;!Wg(e[l]);)l++;for(c|=Ug[e.charCodeAt(l++)]<<6;!Wg(e[l]);)l++;c|=Ug[e.charCodeAt(l++)],r[u++]=c>>16&255,r[u++]=c>>8&255,r[u++]=255&c}switch(i){case 3:for(;!Wg(e[l]);)l++;for(c=Ug[e.charCodeAt(l++)]<<10;!Wg(e[l]);)l++;for(c|=Ug[e.charCodeAt(l++)]<<4;!Wg(e[l]);)l++;c|=Ug[e.charCodeAt(l++)]>>2,r[u++]=c>>8&255,r[u++]=255&c;break;case 2:for(;!Wg(e[l]);)l++;for(c=Ug[e.charCodeAt(l++)]<<2;!Wg(e[l]);)l++;c|=Ug[e.charCodeAt(l++)]>>4,r[u++]=255&c;break;case 1:throw new Error(&quot;BASE64: remain 1 should not happen&quot;)}return u}function jg(e,t,n){const r=(e<<16)+(t<<8)+n;return zg[r>>18]+zg[r>>12&63]+zg[r>>6&63]+zg[63&r]}function Kg(e){const t=new Uint8Array(e),n=e.byteLength%3,r=e.byteLength-n,o=Array(r/3);for(let e=0;e<o.length;e++){const n=3*e;o[e]=jg(t[n],t[n+1],t[n+2])}if(n>0){const e=jg(t[r],t[r+1]||0,t[r+2]||0);1===n?o.push(`${e.substr(0,2)}==`):2===n&&o.push(`${e.substr(0,3)}=`)}return o.join(&quot;&quot;)}var $g={toArrayBuffer:function(e){const t=function(e){const t=e.length,n=[];let r=null;for(let o=0;o<t;o++)Wg(e[o])?(r||(r={start:o,count:0}),r.count++,r.end=o):&quot;=&quot;===e[o]&&r&&(n.push(r),r=null);return r&&n.push(r),n}(e),n=t[t.length-1].end+1,r=(4-n%4)%4,o=new ArrayBuffer(3*(n+r)/4-r),a=new Uint8Array(o);let i=0;for(let n=0;n<t.length;n++)i+=Hg(e,t[n],i,a),i+=(4-t[n].count%4)%4;return o},fromArrayBuffer:Kg};const qg={};function Xg(e,t){qg[e]=t}var Yg={get:function(){let e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return qg[arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;http&quot;](e)},has:function(e){return!!qg[e]},registerType:Xg},Zg=Uint8Array,Qg=Uint16Array,Jg=Uint32Array,em=new Zg([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),tm=new Zg([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),nm=new Zg([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),rm=function(e,t){for(var n=new Qg(31),r=0;r<31;++r)n[r]=t+=1<<e[r-1];var o=new Jg(n[30]);for(r=1;r<30;++r)for(var a=n[r];a<n[r+1];++a)o[a]=a-n[r]<<5|r;return[n,o]},om=rm(em,2),am=om[0],im=om[1];am[28]=258,im[258]=28;for(var sm=rm(tm,0),lm=sm[0],cm=(sm[1],new Qg(32768)),um=0;um<32768;++um){var dm=(43690&um)>>>1|(21845&um)<<1;dm=(61680&(dm=(52428&dm)>>>2|(13107&dm)<<2))>>>4|(3855&dm)<<4,cm[um]=((65280&dm)>>>8|(255&dm)<<8)>>>1}var pm=function(e,t,n){for(var r=e.length,o=0,a=new Qg(t);o<r;++o)e[o]&&++a[e[o]-1];var i,s=new Qg(t);for(o=0;o<t;++o)s[o]=s[o-1]+a[o-1]<<1;if(n){i=new Qg(1<<t);var l=15-t;for(o=0;o<r;++o)if(e[o])for(var c=o<<4|e[o],u=t-e[o],d=s[e[o]-1]++<<u,p=d|(1<<u)-1;d<=p;++d)i[cm[d]>>>l]=c}else for(i=new Qg(r),o=0;o<r;++o)e[o]&&(i[o]=cm[s[e[o]-1]++]>>>15-e[o]);return i},fm=new Zg(288);for(um=0;um<144;++um)fm[um]=8;for(um=144;um<256;++um)fm[um]=9;for(um=256;um<280;++um)fm[um]=7;for(um=280;um<288;++um)fm[um]=8;var gm=new Zg(32);for(um=0;um<32;++um)gm[um]=5;var mm=pm(fm,9,1),hm=pm(gm,5,1),vm=function(e){for(var t=e[0],n=1;n<e.length;++n)e[n]>t&&(t=e[n]);return t},Tm=function(e,t,n){var r=t/8|0;return(e[r]|e[r+1]<<8)>>(7&t)&n},ym=function(e,t){var n=t/8|0;return(e[n]|e[n+1]<<8|e[n+2]<<16)>>(7&t)},bm=function(e,t,n){(null==t||t<0)&&(t=0),(null==n||n>e.length)&&(n=e.length);var r=new(2==e.BYTES_PER_ELEMENT?Qg:4==e.BYTES_PER_ELEMENT?Jg:Zg)(n-t);return r.set(e.subarray(t,n)),r},xm=[&quot;unexpected EOF&quot;,&quot;invalid block type&quot;,&quot;invalid length/literal&quot;,&quot;invalid distance&quot;,&quot;stream finished&quot;,&quot;no stream handler&quot;,,&quot;no callback&quot;,&quot;invalid UTF-8 data&quot;,&quot;extra field too long&quot;,&quot;date not in range 1980-2099&quot;,&quot;filename too long&quot;,&quot;stream finishing&quot;,&quot;invalid zip data&quot;],Cm=function(e,t,n){var r=new Error(t||xm[e]);if(r.code=e,Error.captureStackTrace&&Error.captureStackTrace(r,Cm),!n)throw r;return r},Sm=function(e,t,n){var r=e.length;if(!r||n&&n.f&&!n.l)return t||new Zg(0);var o=!t||n,a=!n||n.i;n||(n={}),t||(t=new Zg(3*r));var i,s=function(e){var n=t.length;if(e>n){var r=new Zg(Math.max(2*n,e));r.set(t),t=r}},l=n.f||0,c=n.p||0,u=n.b||0,d=n.l,p=n.d,f=n.m,g=n.n,m=8*r;do{if(!d){l=Tm(e,c,1);var h=Tm(e,c+1,3);if(c+=3,!h){var v=e[(i=c,(P=4+((i+7)/8|0))-4)]|e[P-3]<<8,T=P+v;if(T>r){a&&Cm(0);break}o&&s(u+v),t.set(e.subarray(P,T),u),n.b=u+=v,n.p=c=8*T,n.f=l;continue}if(1==h)d=mm,p=hm,f=9,g=5;else if(2==h){var y=Tm(e,c,31)+257,b=Tm(e,c+10,15)+4,x=y+Tm(e,c+5,31)+1;c+=14;for(var C=new Zg(x),S=new Zg(19),A=0;A<b;++A)S[nm[A]]=Tm(e,c+3*A,7);c+=3*b;var I=vm(S),w=(1<<I)-1,O=pm(S,I,1);for(A=0;A<x;){var P,R=O[Tm(e,c,w)];if(c+=15&R,(P=R>>>4)<16)C[A++]=P;else{var M=0,E=0;for(16==P?(E=3+Tm(e,c,3),c+=2,M=C[A-1]):17==P?(E=3+Tm(e,c,7),c+=3):18==P&&(E=11+Tm(e,c,127),c+=7);E--;)C[A++]=M}}var V=C.subarray(0,y),D=C.subarray(y);f=vm(V),g=vm(D),d=pm(V,f,1),p=pm(D,g,1)}else Cm(1);if(c>m){a&&Cm(0);break}}o&&s(u+131072);for(var L=(1<<f)-1,B=(1<<g)-1,N=c;;N=c){var F=(M=d[ym(e,c)&L])>>>4;if((c+=15&M)>m){a&&Cm(0);break}if(M||Cm(2),F<256)t[u++]=F;else{if(256==F){N=c,d=null;break}var _=F-254;if(F>264){var k=em[A=F-257];_=Tm(e,c,(1<<k)-1)+am[A],c+=k}var G=p[ym(e,c)&B],U=G>>>4;if(G||Cm(3),c+=15&G,D=lm[U],U>3&&(k=tm[U],D+=ym(e,c)&(1<<k)-1,c+=k),c>m){a&&Cm(0);break}o&&s(u+131072);for(var z=u+_;u<z;u+=4)t[u]=t[u-D],t[u+1]=t[u+1-D],t[u+2]=t[u+2-D],t[u+3]=t[u+3-D];u=z}}n.l=d,n.p=N,n.b=u,n.f=l,d&&(l=1,n.m=f,n.d=p,n.n=g)}while(!l);return u==t.length?t:bm(t,0,u)},Am=new Zg(0),Im=function(e,t){return e[t]|e[t+1]<<8},wm=function(e,t){return(e[t]|e[t+1]<<8|e[t+2]<<16|e[t+3]<<24)>>>0},Om=function(e,t){return wm(e,t)+4294967296*wm(e,t+4)};function Pm(e,t){return Sm(e,t)}function Rm(e,t){return Sm(e.subarray(function(e){31==e[0]&&139==e[1]&&8==e[2]||Cm(6,&quot;invalid gzip data&quot;);var t=e[3],n=10;4&t&&(n+=e[10]|2+(e[11]<<8));for(var r=(t>>3&1)+(t>>4&1);r>0;r-=!e[n++]);return n+(2&t)}(e),-8),t||new Zg((r=(n=e).length,(n[r-4]|n[r-3]<<8|n[r-2]<<16|n[r-1]<<24)>>>0)));var n,r}function Mm(e,t){return Sm(((8!=(15&(n=e)[0])||n[0]>>>4>7||(n[0]<<8|n[1])%31)&&Cm(6,&quot;invalid zlib data&quot;),32&n[1]&&Cm(6,&quot;invalid zlib data: preset dictionaries not supported&quot;),e.subarray(2,-4)),t);var n}function Em(e,t){return 31==e[0]&&139==e[1]&&8==e[2]?Rm(e,t):8!=(15&e[0])||e[0]>>4>7||(e[0]<<8|e[1])%31?Pm(e,t):Mm(e,t)}var Vm=&quot;undefined&quot;!=typeof TextEncoder&&new TextEncoder,Dm=&quot;undefined&quot;!=typeof TextDecoder&&new TextDecoder;try{Dm.decode(Am,{stream:!0})}catch(e){}function Lm(e,t){if(t){for(var n=&quot;&quot;,r=0;r<e.length;r+=16384)n+=String.fromCharCode.apply(null,e.subarray(r,r+16384));return n}if(Dm)return Dm.decode(e);var o=function(e){for(var t=&quot;&quot;,n=0;;){var r=e[n++],o=(r>127)+(r>223)+(r>239);if(n+o>e.length)return[t,bm(e,n-1)];o?3==o?(r=((15&r)<<18|(63&e[n++])<<12|(63&e[n++])<<6|63&e[n++])-65536,t+=String.fromCharCode(55296|r>>10,56320|1023&r)):t+=1&o?String.fromCharCode((31&r)<<6|63&e[n++]):String.fromCharCode((15&r)<<12|(63&e[n++])<<6|63&e[n++]):t+=String.fromCharCode(r)}}(e),a=o[0];return o[1].length&&Cm(8),a}var Bm=function(e,t){return t+30+Im(e,t+26)+Im(e,t+28)},Nm=function(e,t,n){var r=Im(e,t+28),o=Lm(e.subarray(t+46,t+46+r),!(2048&Im(e,t+8))),a=t+46+r,i=wm(e,t+20),s=n&&4294967295==i?Fm(e,a):[i,wm(e,t+24),wm(e,t+42)],l=s[0],c=s[1],u=s[2];return[Im(e,t+10),l,c,o,a+Im(e,t+30)+Im(e,t+32),u]},Fm=function(e,t){for(;1!=Im(e,t);t+=4+Im(e,t+2));return[Om(e,t+12),Om(e,t+4),Om(e,t+20)]};function _m(e,t){for(var n={},r=e.length-22;101010256!=wm(e,r);--r)(!r||e.length-r>65558)&&Cm(13);var o=Im(e,r+8);if(!o)return{};var a=wm(e,r+16),i=4294967295==a;i&&(r=wm(e,r-12),101075792!=wm(e,r)&&Cm(13),o=wm(e,r+32),a=wm(e,r+48));for(var s=t&&t.filter,l=0;l<o;++l){var c=Nm(e,a,i),u=c[0],d=c[1],p=c[2],f=c[3],g=c[4],m=c[5],h=Bm(e,m);a=g,s&&!s({name:f,size:d,originalSize:p,compression:u})||(u?8==u?n[f]=Pm(e.subarray(h,h+d),new Zg(p)):Cm(14,&quot;unknown compression type &quot;+u):n[f]=bm(e,h,h+d))}return n}function km(){const e=new ArrayBuffer(4),t=new Uint8Array(e),n=new Uint32Array(e);return t[0]=161,t[1]=178,t[2]=195,t[3]=212,3569595041===n[0]?&quot;LittleEndian&quot;:2712847316===n[0]?&quot;BigEndian&quot;:null}&quot;function&quot;==typeof queueMicrotask?queueMicrotask:&quot;function&quot;==typeof setTimeout&&setTimeout;var Gm=km(),Um=function(e,t){if(t<2)return;const n=new Int8Array(e),r=n.length,o=[];for(let e=0;e<r;e+=t){for(let r=0;r<t;r++)o.push(n[e+r]);for(let r=0;r<t;r++)n[e+r]=o.pop()}};const{vtkErrorMacro:zm,vtkDebugMacro:Wm}=Wt;let Hm=0;function jm(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};const r=new XMLHttpRequest;return r.open(e,t,!0),n.headers&&Object.entries(n.headers).forEach((e=>{let[t,n]=e;return r.setRequestHeader(t,n)})),n.progressCallback&&r.addEventListener(&quot;progress&quot;,n.progressCallback),r}const Km={fetchArray:function(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return n.ref&&!n.ref.pending?new Promise(((o,a)=>{let i=null;i=n.ref.url?n.ref.url:[t,n.ref.basepath,r.compression?`${n.ref.id}.gz`:n.ref.id].join(&quot;/&quot;);const s=jm(&quot;GET&quot;,i,r);s.onreadystatechange=t=>{1===s.readyState&&(n.ref.pending=!0,1==++Hm&&e?.invokeBusy&&e.invokeBusy(!0)),4===s.readyState&&(n.ref.pending=!1,200===s.status||0===s.status?(n.buffer=s.response,r.compression&&(&quot;string&quot;===n.dataType||&quot;JSON&quot;===n.dataType?n.buffer=Lm(Em(new Uint8Array(n.buffer))):n.buffer=Em(new Uint8Array(n.buffer)).buffer),&quot;JSON&quot;===n.ref.encode?n.values=JSON.parse(n.buffer):(Gm!==n.ref.encode&&Gm&&(Wm(`Swap bytes of ${n.name}`),Um(n.buffer,ls[n.dataType])),n.values=Wt.newTypedArray(n.dataType,n.buffer)),n.values.length!==n.size&&zm(`Error in FetchArray: ${n.name}, does not have the proper array size. Got ${n.values.length}, instead of ${n.size}`),delete n.ref,0==--Hm&&e?.invokeBusy&&e.invokeBusy(!1),e?.modified&&e.modified(),o(n)):a({xhr:s,e:t}))},s.responseType=r.compression||&quot;string&quot;!==n.dataType?&quot;arraybuffer&quot;:&quot;text&quot;,s.send()})):Promise.resolve(n)},fetchJSON:function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return new Promise(((r,o)=>{const a=jm(&quot;GET&quot;,t,n);a.onreadystatechange=t=>{1===a.readyState&&1==++Hm&&e?.invokeBusy&&e.invokeBusy(!0),4===a.readyState&&(0==--Hm&&e?.invokeBusy&&e.invokeBusy(!1),200===a.status||0===a.status?n.compression?r(JSON.parse(Lm(Em(new Uint8Array(a.response))))):r(JSON.parse(a.responseText)):o({xhr:a,e:t}))},a.responseType=n.compression?&quot;arraybuffer&quot;:&quot;text&quot;,a.send()}))},fetchText:function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return n&&n.compression&&&quot;gz&quot;!==n.compression&&(zm(&quot;Supported algorithms are: [gz]&quot;),zm(`Unkown compression algorithm: ${n.compression}`)),new Promise(((r,o)=>{const a=jm(&quot;GET&quot;,t,n);a.onreadystatechange=t=>{1===a.readyState&&1==++Hm&&e?.invokeBusy&&e.invokeBusy(!0),4===a.readyState&&(0==--Hm&&e?.invokeBusy&&e.invokeBusy(!1),200===a.status||0===a.status?n.compression?r(Lm(Em(new Uint8Array(a.response)))):r(a.responseText):o({xhr:a,e:t}))},a.responseType=n.compression?&quot;arraybuffer&quot;:&quot;text&quot;,a.send()}))},fetchBinary:function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return t&&t.compression&&&quot;gz&quot;!==t.compression&&(zm(&quot;Supported algorithms are: [gz]&quot;),zm(`Unkown compression algorithm: ${t.compression}`)),new Promise(((n,r)=>{const o=jm(&quot;GET&quot;,e,t);o.onreadystatechange=e=>{4===o.readyState&&(200===o.status||0===o.status?t.compression?n(Em(new Uint8Array(o.response)).buffer):n(o.response):r({xhr:o,e:e}))},o.responseType=&quot;arraybuffer&quot;,o.send()}))},fetchImage:function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return new Promise(((e,r)=>{const o=new Image;n.crossOrigin&&(o.crossOrigin=n.crossOrigin),o.onload=()=>e(o),o.onerror=r,o.src=t}))}};Xg(&quot;http&quot;,(e=>Km));const{vtkDebugMacro:$m}=Wt,qm={position:[0,0,1],focalPoint:[0,0,0],viewUp:[0,1,0],directionOfProjection:[0,0,-1],parallelProjection:!1,useHorizontalViewAngle:!1,viewAngle:30,parallelScale:1,clippingRange:[.01,1000.01],windowCenter:[0,0],viewPlaneNormal:[0,0,1],useOffAxisProjection:!1,screenBottomLeft:[-.5,-.5,-.5],screenBottomRight:[.5,-.5,-.5],screenTopRight:[.5,.5,-.5],freezeFocalPoint:!1,projectionMatrix:null,viewMatrix:null,modelTransformMatrix:null,cameraLightTransform:u(),physicalTranslation:[0,0,0],physicalScale:1,physicalViewUp:[0,1,0],physicalViewNorth:[0,0,-1]};function Xm(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,qm,n),Wt.obj(e,t),Wt.get(e,t,[&quot;distance&quot;]),Wt.setGet(e,t,[&quot;parallelProjection&quot;,&quot;useHorizontalViewAngle&quot;,&quot;viewAngle&quot;,&quot;parallelScale&quot;,&quot;useOffAxisProjection&quot;,&quot;freezeFocalPoint&quot;,&quot;physicalScale&quot;]),Wt.getArray(e,t,[&quot;directionOfProjection&quot;,&quot;viewPlaneNormal&quot;,&quot;position&quot;,&quot;focalPoint&quot;]),Wt.setGetArray(e,t,[&quot;clippingRange&quot;,&quot;windowCenter&quot;],2),Wt.setGetArray(e,t,[&quot;viewUp&quot;,&quot;screenBottomLeft&quot;,&quot;screenBottomRight&quot;,&quot;screenTopRight&quot;,&quot;physicalTranslation&quot;,&quot;physicalViewUp&quot;,&quot;physicalViewNorth&quot;],3),function(e,t){t.classHierarchy.push(&quot;vtkCamera&quot;);const n=new Float64Array(3),r=new Float64Array([0,0,-1]),o=new Float64Array([0,1,0]),a=m(new Float64Array(16)),i=m(new Float64Array(16)),s=new Float64Array(3),l=new Float64Array(3),c=new Float64Array(3),u=m(new Float64Array(16)),d=m(new Float64Array(16)),f=new Float64Array(3),g=new Float64Array(3);function T(){t.viewPlaneNormal[0]=-t.directionOfProjection[0],t.viewPlaneNormal[1]=-t.directionOfProjection[1],t.viewPlaneNormal[2]=-t.directionOfProjection[2]}e.orthogonalizeViewUp=()=>{const n=e.getViewMatrix();t.viewUp[0]=n[4],t.viewUp[1]=n[5],t.viewUp[2]=n[6],e.modified()},e.setPosition=(n,r,o)=>{n===t.position[0]&&r===t.position[1]&&o===t.position[2]||(t.position[0]=n,t.position[1]=r,t.position[2]=o,e.computeDistance(),e.modified())},e.setFocalPoint=(n,r,o)=>{n===t.focalPoint[0]&&r===t.focalPoint[1]&&o===t.focalPoint[2]||(t.focalPoint[0]=n,t.focalPoint[1]=r,t.focalPoint[2]=o,e.computeDistance(),e.modified())},e.setDistance=n=>{if(t.distance===n)return;t.distance=n,t.distance<1e-20&&(t.distance=1e-20,$m(&quot;Distance is set to minimum.&quot;));const r=t.directionOfProjection;t.focalPoint[0]=t.position[0]+r[0]*t.distance,t.focalPoint[1]=t.position[1]+r[1]*t.distance,t.focalPoint[2]=t.position[2]+r[2]*t.distance,e.modified()},e.computeDistance=()=>{const e=t.focalPoint[0]-t.position[0],n=t.focalPoint[1]-t.position[1],r=t.focalPoint[2]-t.position[2];if(t.distance=Math.sqrt(e*e+n*n+r*r),t.distance<1e-20){t.distance=1e-20,$m(&quot;Distance is set to minimum.&quot;);const e=t.directionOfProjection;t.focalPoint[0]=t.position[0]+e[0]*t.distance,t.focalPoint[1]=t.position[1]+e[1]*t.distance,t.focalPoint[2]=t.position[2]+e[2]*t.distance}t.directionOfProjection[0]=e/t.distance,t.directionOfProjection[1]=n/t.distance,t.directionOfProjection[2]=r/t.distance,T()},e.dolly=n=>{if(n<=0)return;const r=t.distance/n;e.setPosition(t.focalPoint[0]-r*t.directionOfProjection[0],t.focalPoint[1]-r*t.directionOfProjection[1],t.focalPoint[2]-r*t.directionOfProjection[2])},e.roll=n=>{const r=t.position,o=t.focalPoint,a=t.viewUp,i=new Float64Array([a[0],a[1],a[2],0]);m(u);const s=new Float64Array([o[0]-r[0],o[1]-r[1],o[2]-r[2]]);S(u,u,vo(n),s),La(i,i,u),t.viewUp[0]=i[0],t.viewUp[1]=i[1],t.viewUp[2]=i[2],e.modified()},e.azimuth=n=>{const r=t.focalPoint;m(d),x(d,d,r),S(d,d,vo(n),t.viewUp),x(d,d,[-r[0],-r[1],-r[2]]),In(f,t.position,d),e.setPosition(f[0],f[1],f[2])},e.yaw=n=>{const r=t.position;m(d),x(d,d,r),S(d,d,vo(n),t.viewUp),x(d,d,[-r[0],-r[1],-r[2]]),In(g,t.focalPoint,d),e.setFocalPoint(g[0],g[1],g[2])},e.elevation=n=>{const r=t.focalPoint,o=e.getViewMatrix(),a=[-o[0],-o[1],-o[2]];m(d),x(d,d,r),S(d,d,vo(n),a),x(d,d,[-r[0],-r[1],-r[2]]),In(f,t.position,d),e.setPosition(f[0],f[1],f[2])},e.pitch=n=>{const r=t.position,o=e.getViewMatrix(),a=[o[0],o[1],o[2]];m(d),x(d,d,r),S(d,d,vo(n),a),x(d,d,[-r[0],-r[1],-r[2]]),In(g,t.focalPoint,d),e.setFocalPoint(...g)},e.zoom=n=>{n<=0||(t.parallelProjection?t.parallelScale/=n:t.viewAngle/=n,e.modified())},e.translate=(n,r,o)=>{const a=[n,r,o];Ro(t.position,a,t.position),Ro(t.focalPoint,a,t.focalPoint),e.computeDistance(),e.modified()},e.applyTransform=n=>{const r=[...t.viewUp,1],o=[],a=[],i=[];r[0]+=t.position[0],r[1]+=t.position[1],r[2]+=t.position[2],La(o,[...t.position,1],n),La(a,[...t.focalPoint,1],n),La(i,r,n),i[0]-=o[0],i[1]-=o[1],i[2]-=o[2],e.setPosition(...o.slice(0,3)),e.setFocalPoint(...a.slice(0,3)),e.setViewUp(...i.slice(0,3))},e.getThickness=()=>t.clippingRange[1]-t.clippingRange[0],e.setThickness=n=>{let r=n;r<1e-20&&(r=1e-20,$m(&quot;Thickness is set to minimum.&quot;)),e.setClippingRange(t.clippingRange[0],t.clippingRange[0]+r)},e.setThicknessFromFocalPoint=n=>{let r=n;r<1e-20&&(r=1e-20,$m(&quot;Thickness is set to minimum.&quot;)),e.setClippingRange(t.distance-r/2,t.distance+r/2)},e.setRoll=e=>{},e.getRoll=()=>{},e.setObliqueAngles=(e,t)=>{},e.getOrientation=()=>{},e.getOrientationWXYZ=()=>{},e.getFrustumPlanes=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:1,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:new Float64Array(24);const r=[[1,0,0,1],[-1,0,0,1],[0,1,0,1],[0,-1,0,1],[0,0,1,1],[0,0,-1,1]],o=e.getCompositeProjectionMatrix(t,-1,1);for(let e=0;e<6;e++)La(r[e],r[e],o),_o(r[e]),n[4*e+0]=r[e][0],n[4*e+1]=r[e][1],n[4*e+2]=r[e][2],n[4*e+3]=r[e][3];return n},e.getCameraLightTransformMatrix=e=>(p(e,t.cameraLightTransform),e),e.computeCameraLightTransform=()=>{p(a,e.getViewMatrix()),v(a,a),P(i,[t.distance,t.distance,t.distance]),b(a,a,i),m(t.cameraLightTransform),x(t.cameraLightTransform,a,[0,0,-1])},e.deepCopy=e=>{},e.physicalOrientationToWorldDirection=e=>{const t=_a(e[0],e[1],e[2],e[3]),n=Ba(),r=_a(0,0,1,0);var o,a;return a=t,(o=n)[0]=-a[0],o[1]=-a[1],o[2]=-a[2],o[3]=a[3],Fa(r,t,r),Fa(r,r,n),[r[0],r[1],r[2]]},e.getPhysicalToWorldMatrix=t=>{e.getWorldToPhysicalMatrix(t),v(t,t)},e.getWorldToPhysicalMatrix=e=>{m(e);const n=[3];Bo(t.physicalViewNorth,t.physicalViewUp,n),e[0]=n[0],e[1]=n[1],e[2]=n[2],e[4]=t.physicalViewUp[0],e[5]=t.physicalViewUp[1],e[6]=t.physicalViewUp[2],e[8]=-t.physicalViewNorth[0],e[9]=-t.physicalViewNorth[1],e[10]=-t.physicalViewNorth[2],h(e,e),hn(s,1/t.physicalScale,1/t.physicalScale,1/t.physicalScale),C(e,e,s),x(e,e,t.physicalTranslation)},e.computeViewParametersFromViewMatrix=i=>{v(a,i),In(s,n,a),e.computeDistance();const u=t.distance;e.setPosition(s[0],s[1],s[2]),In(l,r,a),Tn(l,l,s),Cn(l,l),e.setDirectionOfProjection(l[0],l[1],l[2]),In(c,o,a),Tn(c,c,s),Cn(c,c),e.setViewUp(c[0],c[1],c[2]),e.setDistance(u)},e.computeViewParametersFromPhysicalMatrix=t=>{e.getWorldToPhysicalMatrix(a),b(a,t,a),e.computeViewParametersFromViewMatrix(a)},e.setModelTransformMatrix=e=>{t.modelTransformMatrix=e},e.getModelTransformMatrix=()=>t.modelTransformMatrix,e.setViewMatrix=n=>{t.viewMatrix=n,t.viewMatrix&&(p(a,t.viewMatrix),e.computeViewParametersFromViewMatrix(a),h(t.viewMatrix,t.viewMatrix))},e.getViewMatrix=()=>{if(t.viewMatrix)return t.modelTransformMatrix?(b(a,t.viewMatrix,t.modelTransformMatrix),a):t.viewMatrix;X(a,t.position,t.focalPoint,t.viewUp),h(a,a);const e=new Float64Array(16);return t.modelTransformMatrix?b(e,a,t.modelTransformMatrix):p(e,a),e},e.setProjectionMatrix=e=>{t.projectionMatrix=e},e.getProjectionMatrix=(e,n,r)=>{const o=new Float64Array(16);if(m(o),t.projectionMatrix){const e=1/t.physicalScale;return hn(s,e,e,e),p(o,t.projectionMatrix),C(o,o,s),h(o,o),o}m(a);const i=t.clippingRange[1]-t.clippingRange[0],l=[t.clippingRange[0]+(n+1)*i/2,t.clippingRange[0]+(r+1)*i/2];if(t.parallelProjection){const n=t.parallelScale*e,r=t.parallelScale,o=(t.windowCenter[0]-1)*n,i=(t.windowCenter[0]+1)*n,s=(t.windowCenter[1]-1)*r,c=(t.windowCenter[1]+1)*r;$(a,o,i,s,c,l[0],l[1]),h(a,a)}else{if(t.useOffAxisProjection)throw new Error(&quot;Off-Axis projection is not supported at this time&quot;);{const n=Math.tan(vo(t.viewAngle)/2);let r,o;!0===t.useHorizontalViewAngle?(r=t.clippingRange[0]*n,o=t.clippingRange[0]*n/e):(r=t.clippingRange[0]*n*e,o=t.clippingRange[0]*n);const i=(t.windowCenter[0]-1)*r,s=(t.windowCenter[0]+1)*r,c=(t.windowCenter[1]-1)*o,u=(t.windowCenter[1]+1)*o,d=l[0],p=l[1];a[0]=2*d/(s-i),a[5]=2*d/(u-c),a[2]=(i+s)/(s-i),a[6]=(c+u)/(u-c),a[10]=-(d+p)/(p-d),a[14]=-1,a[11]=-2*d*p/(p-d),a[15]=0}}return p(o,a),o},e.getCompositeProjectionMatrix=(t,n,r)=>{const o=e.getViewMatrix(),a=e.getProjectionMatrix(t,n,r);return b(a,o,a),a},e.setDirectionOfProjection=(e,n,r)=>{if(t.directionOfProjection[0]===e&&t.directionOfProjection[1]===n&&t.directionOfProjection[2]===r)return;t.directionOfProjection[0]=e,t.directionOfProjection[1]=n,t.directionOfProjection[2]=r;const o=t.directionOfProjection;t.focalPoint[0]=t.position[0]+o[0]*t.distance,t.focalPoint[1]=t.position[1]+o[1]*t.distance,t.focalPoint[2]=t.position[2]+o[2]*t.distance,T()},e.setDeviceAngles=(n,r,o,a)=>{const i=[3];Bo(t.physicalViewNorth,t.physicalViewUp,i);const s=m(new Float64Array(16));S(s,s,vo(n),t.physicalViewUp),S(s,s,vo(r),i),S(s,s,vo(o),t.physicalViewNorth),S(s,s,vo(-a),t.physicalViewUp);const l=new Float64Array([-t.physicalViewUp[0],-t.physicalViewUp[1],-t.physicalViewUp[2]]),c=new Float64Array(t.physicalViewNorth);In(l,l,s),In(c,c,s),e.setDirectionOfProjection(l[0],l[1],l[2]),e.setViewUp(c[0],c[1],c[2]),e.modified()},e.setOrientationWXYZ=(t,n,r,o)=>{const a=m(new Float64Array(16));if(0!==t&&(0!==n||0!==r||0!==o)){const e=vo(t),i=Ba();Na(i,[n,r,o],e),G(a,i)}const i=new Float64Array(3);In(i,[0,0,-1],a);const s=new Float64Array(3);In(s,[0,1,0],a),e.setDirectionOfProjection(...i),e.setViewUp(...s),e.modified()},e.computeClippingRange=e=>{let n=null,r=null;n=t.viewPlaneNormal,r=t.position;const o=-n[0],a=-n[1],i=-n[2],s=-(o*r[0]+a*r[1]+i*r[2]),l=[o*e[0]+a*e[2]+i*e[4]+s,1e-18];for(let t=0;t<2;t++)for(let n=0;n<2;n++)for(let r=0;r<2;r++){const c=o*e[r]+a*e[2+n]+i*e[4+t]+s;l[0]=c<l[0]?c:l[0],l[1]=c>l[1]?c:l[1]}return l}}(e,t)}var Ym={newInstance:Wt.newInstance(Xm,&quot;vtkCamera&quot;),extend:Xm};const Zm={switch:!0,intensity:1,color:[1,1,1],position:[0,0,1],focalPoint:[0,0,0],positional:!1,exponent:1,coneAngle:30,coneFalloff:5,attenuationValues:[1,0,0],transformMatrix:null,lightType:&quot;SceneLight&quot;,shadowAttenuation:1,direction:[0,0,0],directionMTime:0};function Qm(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Zm,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;intensity&quot;,&quot;switch&quot;,&quot;positional&quot;,&quot;exponent&quot;,&quot;coneAngle&quot;,&quot;coneFalloff&quot;,&quot;transformMatrix&quot;,&quot;lightType&quot;,&quot;shadowAttenuation&quot;,&quot;attenuationValues&quot;]),Wt.setGetArray(e,t,[&quot;color&quot;,&quot;position&quot;,&quot;focalPoint&quot;,&quot;attenuationValues&quot;],3),function(e,t){t.classHierarchy.push(&quot;vtkLight&quot;);const n=new Float64Array(3);e.getTransformedPosition=()=>(t.transformMatrix?In(n,t.position,t.transformMatrix):hn(n,t.position[0],t.position[1],t.position[2]),n),e.getTransformedFocalPoint=()=>(t.transformMatrix?In(n,t.focalPoint,t.transformMatrix):hn(n,t.focalPoint[0],t.focalPoint[1],t.focalPoint[2]),n),e.getDirection=()=>(t.directionMTime<t.mtime&&(Rn(t.direction,t.focalPoint,t.position),Fo(t.direction),t.directionMTime=t.mtime),t.direction),e.setDirection=e=>{const n=new Float64Array(3);Rn(n,t.position,e),t.focalPoint=n},e.setDirectionAngle=(t,n)=>{const r=vo(t),o=vo(n);e.setPosition(Math.cos(r)*Math.sin(o),Math.sin(r),Math.cos(r)*Math.cos(o)),e.setFocalPoint(0,0,0),e.setPositional(0)},e.setLightTypeToHeadLight=()=>{e.setLightType(&quot;HeadLight&quot;)},e.setLightTypeToCameraLight=()=>{e.setLightType(&quot;CameraLight&quot;)},e.setLightTypeToSceneLight=()=>{e.setTransformMatrix(null),e.setLightType(&quot;SceneLight&quot;)},e.lightTypeIsHeadLight=()=>&quot;HeadLight&quot;===t.lightType,e.lightTypeIsSceneLight=()=>&quot;SceneLight&quot;===t.lightType,e.lightTypeIsCameraLight=()=>&quot;CameraLight&quot;===t.lightType}(e,t)}var Jm={newInstance:Wt.newInstance(Qm,&quot;vtkLight&quot;),extend:Qm,LIGHT_TYPES:[&quot;HeadLight&quot;,&quot;CameraLight&quot;,&quot;SceneLight&quot;]};const{vtkErrorMacro:eh}=Wt;const th={background:[0,0,0],background2:[.2,.2,.2],gradientBackground:!1,viewport:[0,0,1,1],aspect:[1,1],pixelAspect:[1,1],props:[],actors2D:[]};function nh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,th,n),Wt.obj(e,t),Wt.event(e,t,&quot;event&quot;),Wt.setGetArray(e,t,[&quot;viewport&quot;],4),Wt.setGetArray(e,t,[&quot;background&quot;,&quot;background2&quot;],3),function(e,t){function n(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];t.push(e);const r=e.getNestedProps();if(r&&r.length)for(let e=0;e<r.length;e++)n(r[e],t);return t}t.classHierarchy.push(&quot;vtkViewport&quot;),e.getViewProps=()=>t.props,e.hasViewProp=e=>t.props.includes(e),e.addViewProp=n=>{n&&!e.hasViewProp(n)&&t.props.push(n)},e.removeViewProp=e=>{const n=t.props.filter((t=>t!==e));t.props.length!==n.length&&(t.props=n)},e.removeAllViewProps=()=>{t.props=[]},e.getViewPropsWithNestedProps=()=>{let r=[];const o=e.getActors2D();o.sort(((e,t)=>e.getLayerNumber()-t.getLayerNumber()));const a=t.props.filter((e=>!o.includes(e)));for(let e=0;e<a.length;e++)n(a[e],r);return r=r.concat(o),r},e.addActor2D=e.addViewProp,e.removeActor2D=t=>{e.removeViewProp(t)},e.getActors2D=()=>(t.actors2D=[],t.props.forEach((e=>{t.actors2D=t.actors2D.concat(e.getActors2D())})),t.actors2D),e.displayToView=()=>eh(&quot;call displayToView on your view instead&quot;),e.viewToDisplay=()=>eh(&quot;callviewtodisplay on your view instead&quot;),e.getSize=()=>eh(&quot;call getSize on your View instead&quot;),e.normalizedDisplayToProjection=(t,n,r)=>{const o=e.normalizedDisplayToNormalizedViewport(t,n,r);return e.normalizedViewportToProjection(o[0],o[1],o[2])},e.normalizedDisplayToNormalizedViewport=(e,n,r)=>{const o=[t.viewport[2]-t.viewport[0],t.viewport[3]-t.viewport[1]];return[(e-t.viewport[0])/o[0],(n-t.viewport[1])/o[1],r]},e.normalizedViewportToProjection=(e,t,n)=>[2*e-1,2*t-1,2*n-1],e.projectionToNormalizedDisplay=(t,n,r)=>{const o=e.projectionToNormalizedViewport(t,n,r);return e.normalizedViewportToNormalizedDisplay(o[0],o[1],o[2])},e.normalizedViewportToNormalizedDisplay=(e,n,r)=>{const o=[t.viewport[2]-t.viewport[0],t.viewport[3]-t.viewport[1]];return[e*o[0]+t.viewport[0],n*o[1]+t.viewport[1],r]},e.projectionToNormalizedViewport=(e,t,n)=>[.5*(e+1),.5*(t+1),.5*(n+1)],e.PickPropFrom=()=>eh(&quot;vtkViewport::PickPropFrom - NOT IMPLEMENTED&quot;)}(e,t)}var rh={newInstance:Wt.newInstance(nh,&quot;vtkViewport&quot;),extend:nh};const{vtkDebugMacro:oh,vtkErrorMacro:ah,vtkWarningMacro:ih}=Ht;function sh(e){return()=>ah(`vtkRenderer::${e} - NOT IMPLEMENTED`)}const lh={pickedProp:null,activeCamera:null,allBounds:[],ambient:[1,1,1],allocatedRenderTime:100,timeFactor:1,automaticLightCreation:!0,twoSidedLighting:!0,lastRenderTimeInSeconds:-1,renderWindow:null,lights:[],actors:[],volumes:[],lightFollowCamera:!0,numberOfPropsRendered:0,propArray:null,pathArray:null,layer:0,preserveColorBuffer:!1,preserveDepthBuffer:!1,computeVisiblePropBounds:Pa(),interactive:!0,nearClippingPlaneTolerance:0,clippingRangeExpansion:.05,erase:!0,draw:!0,useShadows:!1,useDepthPeeling:!1,occlusionRatio:0,maximumNumberOfPeels:4,selector:null,delegate:null,texturedBackground:!1,backgroundTexture:null,environmentTexture:null,environmentTextureDiffuseStrength:1,environmentTextureSpecularStrength:1,useEnvironmentTextureAsBackground:!1,pass:0};function ch(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};for(Object.assign(t,lh,n),rh.extend(e,t,n),t.background||(t.background=[0,0,0,1]);t.background.length<3;)t.background.push(0);3===t.background.length&&t.background.push(1),Tt(e,t,[&quot;_renderWindow&quot;,&quot;allocatedRenderTime&quot;,&quot;timeFactor&quot;,&quot;lastRenderTimeInSeconds&quot;,&quot;numberOfPropsRendered&quot;,&quot;lastRenderingUsedDepthPeeling&quot;,&quot;selector&quot;]),Ct(e,t,[&quot;twoSidedLighting&quot;,&quot;lightFollowCamera&quot;,&quot;automaticLightCreation&quot;,&quot;erase&quot;,&quot;draw&quot;,&quot;nearClippingPlaneTolerance&quot;,&quot;clippingRangeExpansion&quot;,&quot;backingStore&quot;,&quot;interactive&quot;,&quot;layer&quot;,&quot;preserveColorBuffer&quot;,&quot;preserveDepthBuffer&quot;,&quot;useDepthPeeling&quot;,&quot;occlusionRatio&quot;,&quot;maximumNumberOfPeels&quot;,&quot;delegate&quot;,&quot;backgroundTexture&quot;,&quot;texturedBackground&quot;,&quot;environmentTexture&quot;,&quot;environmentTextureDiffuseStrength&quot;,&quot;environmentTextureSpecularStrength&quot;,&quot;useEnvironmentTextureAsBackground&quot;,&quot;useShadows&quot;,&quot;pass&quot;]),St(e,t,[&quot;actors&quot;,&quot;volumes&quot;,&quot;lights&quot;]),It(e,t,[&quot;background&quot;],4,1),wt(0,t,[&quot;renderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkRenderer&quot;);const n={type:&quot;ComputeVisiblePropBoundsEvent&quot;,renderer:e},r={type:&quot;ResetCameraClippingRangeEvent&quot;,renderer:e},o={type:&quot;ResetCameraEvent&quot;,renderer:e};e.updateCamera=()=>(t.activeCamera||(oh(&quot;No cameras are on, creating one.&quot;),e.getActiveCameraAndResetIfCreated()),t.activeCamera.render(e),!0),e.updateLightsGeometryToFollowCamera=()=>{const n=e.getActiveCameraAndResetIfCreated();t.lights.forEach((e=>{e.lightTypeIsSceneLight()||(e.lightTypeIsHeadLight()?(e.setPositionFrom(n.getPositionByReference()),e.setFocalPointFrom(n.getFocalPointByReference()),e.modified(n.getMTime())):e.lightTypeIsCameraLight()?e.setTransformMatrix(n.getCameraLightTransformMatrix(u())):ah(&quot;light has unknown light type&quot;,e.get()))}))},e.updateLightGeometry=()=>!t.lightFollowCamera||e.updateLightsGeometryToFollowCamera(),e.allocateTime=sh(&quot;allocateTime&quot;),e.updateGeometry=sh(&quot;updateGeometry&quot;),e.getVTKWindow=()=>t._renderWindow,e.setLayer=n=>{oh(e.getClassName(),e,&quot;setting Layer to &quot;,n),t.layer!==n&&(t.layer=n,e.modified()),e.setPreserveColorBuffer(!!n)},e.setActiveCamera=n=>t.activeCamera!==n&&(t.activeCamera=n,e.modified(),e.invokeEvent({type:&quot;ActiveCameraEvent&quot;,camera:n}),!0),e.makeCamera=()=>{const t=Ym.newInstance();return e.invokeEvent({type:&quot;CreateCameraEvent&quot;,camera:t}),t},e.getActiveCamera=()=>(t.activeCamera||(t.activeCamera=e.makeCamera()),t.activeCamera),e.getActiveCameraAndResetIfCreated=()=>(t.activeCamera||(e.getActiveCamera(),e.resetCamera()),t.activeCamera),e.getActors=()=>(t.actors=[],t.props.forEach((e=>{t.actors=t.actors.concat(e.getActors())})),t.actors),e.addActor=e.addViewProp,e.removeActor=n=>{t.actors=t.actors.filter((e=>e!==n)),e.removeViewProp(n),e.modified()},e.removeAllActors=()=>{e.getActors().forEach((t=>{e.removeViewProp(t)})),t.actors=[],e.modified()},e.getVolumes=()=>(t.volumes=[],t.props.forEach((e=>{t.volumes=t.volumes.concat(e.getVolumes())})),t.volumes),e.addVolume=e.addViewProp,e.removeVolume=n=>{t.volumes=t.volumes.filter((e=>e!==n)),e.removeViewProp(n),e.modified()},e.removeAllVolumes=()=>{e.getVolumes().forEach((t=>{e.removeViewProp(t)})),t.volumes=[],e.modified()},e.hasLight=e=>t.lights.includes(e),e.addLight=n=>{n&&!e.hasLight(n)&&(t.lights.push(n),e.modified())},e.removeLight=n=>{t.lights=t.lights.filter((e=>e!==n)),e.modified()},e.removeAllLights=()=>{t.lights=[],e.modified()},e.setLightCollection=n=>{t.lights=n,e.modified()},e.makeLight=Jm.newInstance,e.createLight=()=>{t.automaticLightCreation&&(t._createdLight&&(e.removeLight(t._createdLight),t._createdLight.delete(),t._createdLight=null),t._createdLight=e.makeLight(),e.addLight(t._createdLight),t._createdLight.setLightTypeToHeadLight(),t._createdLight.setPosition(e.getActiveCamera().getPosition()),t._createdLight.setFocalPoint(e.getActiveCamera().getFocalPoint()))},e.normalizedDisplayToWorld=(t,n,r,o)=>{let a=e.normalizedDisplayToProjection(t,n,r);return a=e.projectionToView(a[0],a[1],a[2],o),e.viewToWorld(a[0],a[1],a[2])},e.worldToNormalizedDisplay=(t,n,r,o)=>{let a=e.worldToView(t,n,r);return a=e.viewToProjection(a[0],a[1],a[2],o),e.projectionToNormalizedDisplay(a[0],a[1],a[2])},e.viewToWorld=(e,n,r)=>{if(null===t.activeCamera)return ah(&quot;ViewToWorld: no active camera, cannot compute view to world, returning 0,0,0&quot;),[0,0,0];const o=t.activeCamera.getViewMatrix();v(o,o),h(o,o);const a=new Float64Array([e,n,r]);return In(a,a,o),a},e.projectionToView=(e,n,r,o)=>{if(null===t.activeCamera)return ah(&quot;ProjectionToView: no active camera, cannot compute projection to view, returning 0,0,0&quot;),[0,0,0];const a=t.activeCamera.getProjectionMatrix(o,-1,1);v(a,a),h(a,a);const i=new Float64Array([e,n,r]);return In(i,i,a),i},e.worldToView=(e,n,r)=>{if(null===t.activeCamera)return ah(&quot;WorldToView: no active camera, cannot compute view to world, returning 0,0,0&quot;),[0,0,0];const o=t.activeCamera.getViewMatrix();h(o,o);const a=new Float64Array([e,n,r]);return In(a,a,o),a},e.viewToProjection=(e,n,r,o)=>{if(null===t.activeCamera)return ah(&quot;ViewToProjection: no active camera, cannot compute view to projection, returning 0,0,0&quot;),[0,0,0];const a=t.activeCamera.getProjectionMatrix(o,-1,1);h(a,a);const i=new Float64Array([e,n,r]);return In(i,i,a),i},e.computeVisiblePropBounds=()=>{t.allBounds[0]=Gi.INIT_BOUNDS[0],t.allBounds[1]=Gi.INIT_BOUNDS[1],t.allBounds[2]=Gi.INIT_BOUNDS[2],t.allBounds[3]=Gi.INIT_BOUNDS[3],t.allBounds[4]=Gi.INIT_BOUNDS[4],t.allBounds[5]=Gi.INIT_BOUNDS[5];let r=!0;e.invokeEvent(n);for(let e=0;e<t.props.length;++e){const n=t.props[e];if(n.getVisibility()&&n.getUseBounds()){const e=n.getBounds();e&&ya(e)&&(r=!1,e[0]<t.allBounds[0]&&(t.allBounds[0]=e[0]),e[1]>t.allBounds[1]&&(t.allBounds[1]=e[1]),e[2]<t.allBounds[2]&&(t.allBounds[2]=e[2]),e[3]>t.allBounds[3]&&(t.allBounds[3]=e[3]),e[4]<t.allBounds[4]&&(t.allBounds[4]=e[4]),e[5]>t.allBounds[5]&&(t.allBounds[5]=e[5]))}}return r&&(Ta(t.allBounds),oh(&quot;Can't compute bounds, no 3D props are visible&quot;)),t.allBounds},e.resetCamera=function(){const n=(arguments.length>0&&void 0!==arguments[0]?arguments[0]:null)||e.computeVisiblePropBounds(),r=[0,0,0];if(!ya(n))return oh(&quot;Cannot reset camera!&quot;),!1;let a=null;if(!e.getActiveCamera())return ah(&quot;Trying to reset non-existent camera&quot;),!1;a=t.activeCamera.getViewPlaneNormal(),t.activeCamera.setViewAngle(30),r[0]=(n[0]+n[1])/2,r[1]=(n[2]+n[3])/2,r[2]=(n[4]+n[5])/2;let i=n[1]-n[0],s=n[3]-n[2],l=n[5]-n[4];i*=i,s*=s,l*=l;let c=i+s+l;c=0===c?1:c,c=.5*Math.sqrt(c);const u=vo(t.activeCamera.getViewAngle()),d=c,p=c/Math.sin(.5*u),f=t.activeCamera.getViewUp();return Math.abs(Lo(f,a))>.999&&(ih(&quot;Resetting view-up since view plane normal is parallel&quot;),t.activeCamera.setViewUp(-f[2],f[0],f[1])),t.activeCamera.setFocalPoint(r[0],r[1],r[2]),t.activeCamera.setPosition(r[0]+p*a[0],r[1]+p*a[1],r[2]+p*a[2]),e.resetCameraClippingRange(n),t.activeCamera.setParallelScale(d),t.activeCamera.setPhysicalScale(c),t.activeCamera.setPhysicalTranslation(-r[0],-r[1],-r[2]),e.invokeEvent(o),!0},e.resetCameraClippingRange=function(){const n=(arguments.length>0&&void 0!==arguments[0]?arguments[0]:null)||e.computeVisiblePropBounds();if(!ya(n))return oh(&quot;Cannot reset camera clipping range!&quot;),!1;if(e.getActiveCameraAndResetIfCreated(),!t.activeCamera)return ah(&quot;Trying to reset clipping range of non-existent camera&quot;),!1;const o=t.activeCamera.computeClippingRange(n);let a=0;if(t.activeCamera.getParallelProjection())a=.2*t.activeCamera.getParallelScale();else{const e=vo(t.activeCamera.getViewAngle());a=.2*Math.tan(e/2)*o[1]}return o[1]-o[0]<a&&(a=a-o[1]+o[0],o[1]+=a/2,o[0]-=a/2),o[0]<0&&(o[0]=0),o[0]=.99*o[0]-(o[1]-o[0])*t.clippingRangeExpansion,o[1]=1.01*o[1]+(o[1]-o[0])*t.clippingRangeExpansion,o[0]=o[0]>=o[1]?.01*o[1]:o[0],t.nearClippingPlaneTolerance||(t.nearClippingPlaneTolerance=.01),o[0]<t.nearClippingPlaneTolerance*o[1]&&(o[0]=t.nearClippingPlaneTolerance*o[1]),t.activeCamera.setClippingRange(o[0],o[1]),e.invokeEvent(r),!1},e.setRenderWindow=e=>{e!==t._renderWindow&&(t._vtkWindow=e,t._renderWindow=e)},e.visibleActorCount=()=>t.props.filter((e=>e.getVisibility())).length,e.visibleVolumeCount=e.visibleActorCount,e.getMTime=()=>{let e=t.mtime;const n=t.activeCamera?t.activeCamera.getMTime():0;n>e&&(e=n);const r=t._createdLight?t._createdLight.getMTime():0;return r>e&&(e=r),e},e.getTransparent=()=>!!t.preserveColorBuffer,e.isActiveCameraCreated=()=>!!t.activeCamera}(e,t)}var uh={newInstance:Mt(ch,&quot;vtkRenderer&quot;),extend:ch};const dh=Object.create(null);function ph(e,t){dh[e]=t}function fh(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return dh[e]&&dh[e](t)}const gh={defaultViewAPI:&quot;WebGL&quot;,renderers:[],views:[],interactor:null,neverRendered:!0,numberOfLayers:1,childRenderWindows:[]};function mh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,gh,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;interactor&quot;,&quot;numberOfLayers&quot;,&quot;_views&quot;,&quot;defaultViewAPI&quot;]),Wt.get(e,t,[&quot;neverRendered&quot;]),Wt.getArray(e,t,[&quot;renderers&quot;,&quot;childRenderWindows&quot;]),Wt.moveToProtected(e,t,[&quot;views&quot;]),Wt.event(e,t,&quot;completion&quot;),function(e,t){t.classHierarchy.push(&quot;vtkRenderWindow&quot;),e.addRenderer=n=>{e.hasRenderer(n)||(n.setRenderWindow(e),t.renderers.push(n),e.modified())},e.removeRenderer=n=>{t.renderers=t.renderers.filter((e=>e!==n)),e.modified()},e.hasRenderer=e=>-1!==t.renderers.indexOf(e),e.newAPISpecificView=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return fh(e||t.defaultViewAPI,n)},e.addView=n=>{e.hasView(n)||(n.setRenderable(e),t._views.push(n),e.modified())},e.removeView=n=>{t._views=t._views.filter((e=>e!==n)),e.modified()},e.hasView=e=>-1!==t._views.indexOf(e),e.preRender=()=>{t.renderers.forEach((e=>{e.isActiveCameraCreated()||e.resetCamera()}))},e.render=()=>{e.preRender(),t.interactor?t.interactor.render():t._views.forEach((e=>e.traverseAllPasses()))},e.getStatistics=()=>{const e={propCount:0,invisiblePropCount:0,gpuMemoryMB:0};return t._views.forEach((t=>{t.getGraphicsMemoryInfo&&(e.gpuMemoryMB+=t.getGraphicsMemoryInfo()/1e6)})),t.renderers.forEach((n=>{const r=n.getViewProps(),o=t._views[0].getViewNodeFor(n);r.forEach((t=>{if(t.getVisibility()){e.propCount+=1;const n=t.getMapper&&t.getMapper();if(n&&n.getPrimitiveCount){const t=o.getViewNodeFor(n);if(t){t.getAllocatedGPUMemoryInBytes&&(e.gpuMemoryMB+=t.getAllocatedGPUMemoryInBytes()/1e6);const r=n.getPrimitiveCount();Object.keys(r).forEach((t=>{e[t]||(e[t]=0),e[t]+=r[t]}))}}}else e.invisiblePropCount+=1}))})),e.str=Object.keys(e).map((t=>`${t}: ${e[t]}`)).join(&quot;\\n&quot;),e},e.captureImages=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;image/png&quot;,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return Wt.setImmediate(e.render),t._views.map((e=>e.captureNextImage?e.captureNextImage(n,r):void 0)).filter((e=>!!e))},e.addRenderWindow=n=>!t.childRenderWindows.includes(n)&&(t.childRenderWindows.push(n),e.modified(),!0),e.removeRenderWindow=n=>{const r=t.childRenderWindows.findIndex((e=>e===n));return!(r<0||(t.childRenderWindows.splice(r,1),e.modified(),0))}}(e,t)}var hh={newInstance:Wt.newInstance(mh,&quot;vtkRenderWindow&quot;),extend:mh,registerViewConstructor:ph,listViewAPIs:function(){return Object.keys(dh)},newAPISpecificView:fh};const vh={Unknown:0,LeftController:1,RightController:2},Th={Unknown:0,Trigger:1,TrackPad:2,Grip:3,Thumbstick:4,A:5,B:6,ApplicationMenu:7};var yh={Device:vh,Input:Th,Axis:{Unknown:0,TouchpadX:1,TouchpadY:2,ThumbstickX:3,ThumbstickY:4},MouseButton:{LeftButton:1,MiddleButton:2,RightButton:3}};const{Device:bh,Input:xh}=yh,{vtkWarningMacro:Ch,vtkErrorMacro:Sh,normalizeWheel:Ah,vtkOnceErrorMacro:Ih}=Wt,wh={ctrlKey:!1,altKey:!1,shiftKey:!1},Oh={&quot;xr-standard&quot;:[xh.Trigger,xh.Grip,xh.TrackPad,xh.Thumbstick,xh.A,xh.B]},Ph=[&quot;StartAnimation&quot;,&quot;Animation&quot;,&quot;EndAnimation&quot;,&quot;PointerEnter&quot;,&quot;PointerLeave&quot;,&quot;MouseEnter&quot;,&quot;MouseLeave&quot;,&quot;StartMouseMove&quot;,&quot;MouseMove&quot;,&quot;EndMouseMove&quot;,&quot;LeftButtonPress&quot;,&quot;LeftButtonRelease&quot;,&quot;MiddleButtonPress&quot;,&quot;MiddleButtonRelease&quot;,&quot;RightButtonPress&quot;,&quot;RightButtonRelease&quot;,&quot;KeyPress&quot;,&quot;KeyDown&quot;,&quot;KeyUp&quot;,&quot;StartMouseWheel&quot;,&quot;MouseWheel&quot;,&quot;EndMouseWheel&quot;,&quot;StartPinch&quot;,&quot;Pinch&quot;,&quot;EndPinch&quot;,&quot;StartPan&quot;,&quot;Pan&quot;,&quot;EndPan&quot;,&quot;StartRotate&quot;,&quot;Rotate&quot;,&quot;EndRotate&quot;,&quot;Button3D&quot;,&quot;Move3D&quot;,&quot;StartPointerLock&quot;,&quot;EndPointerLock&quot;,&quot;StartInteraction&quot;,&quot;Interaction&quot;,&quot;EndInteraction&quot;,&quot;AnimationFrameRateUpdate&quot;];function Rh(e){e.cancelable&&e.preventDefault()}function Mh(e){const t=Object.create(null);return e.forEach((e=>{let{pointerId:n,position:r}=e;t[n]=r})),t}const Eh={renderWindow:null,interactorStyle:null,picker:null,pickingManager:null,initialized:!1,enabled:!1,enableRender:!0,currentRenderer:null,lightFollowCamera:!0,desiredUpdateRate:30,stillUpdateRate:2,container:null,recognizeGestures:!0,currentGesture:&quot;Start&quot;,animationRequest:null,lastFrameTime:.1,recentAnimationFrameRate:10,wheelTimeoutID:0,moveTimeoutID:0,lastGamepadValues:{},preventDefaultOnPointerDown:!1,preventDefaultOnPointerUp:!1,mouseScrollDebounceByPass:!1};function Vh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Eh,n),Wt.obj(e,t),t._animationExtendedEnd=0,Wt.event(e,t,&quot;RenderEvent&quot;),Ph.forEach((n=>Wt.event(e,t,n))),Wt.get(e,t,[&quot;initialized&quot;,&quot;interactorStyle&quot;,&quot;lastFrameTime&quot;,&quot;recentAnimationFrameRate&quot;,&quot;_view&quot;]),Wt.setGet(e,t,[&quot;container&quot;,&quot;lightFollowCamera&quot;,&quot;enabled&quot;,&quot;enableRender&quot;,&quot;recognizeGestures&quot;,&quot;desiredUpdateRate&quot;,&quot;stillUpdateRate&quot;,&quot;picker&quot;,&quot;preventDefaultOnPointerDown&quot;,&quot;preventDefaultOnPointerUp&quot;,&quot;mouseScrollDebounceByPass&quot;]),Wt.moveToProtected(e,t,[&quot;view&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkRenderWindowInteractor&quot;);const n={...e},r=new Set,o=new Map;let a=1;function i(n,r){t._forcedRenderer||(t.currentRenderer=e.findPokedRenderer(n,r))}e.start=()=>{(t.initialized||(e.initialize(),t.initialized))&&e.startEventLoop()},e.setRenderWindow=e=>{Sh(&quot;you want to call setView(view) instead of setRenderWindow on a vtk.js interactor&quot;)},e.setInteractorStyle=n=>{t.interactorStyle!==n&&(null!=t.interactorStyle&&t.interactorStyle.setInteractor(null),t.interactorStyle=n,null!=t.interactorStyle&&t.interactorStyle.getInteractor()!==e&&t.interactorStyle.setInteractor(e))},e.initialize=()=>{t.initialized=!0,e.enable(),e.render()},e.enable=()=>e.setEnabled(!0),e.disable=()=>e.setEnabled(!1),e.startEventLoop=()=>Ch(&quot;empty event loop&quot;),e.getCurrentRenderer=()=>(t.currentRenderer||i(0,0),t.currentRenderer);const s=t._getScreenEventPositionFor||function(e){const n=t._view.getCanvas(),r=n.getBoundingClientRect(),a=n.width/r.width,s=n.height/r.height,l={x:a*(e.clientX-r.left),y:s*(r.height-e.clientY+r.top),z:0,movementX:a*e.movementX,movementY:s*e.movementY};return(o.size<=1||!t.currentRenderer)&&i(l.x,l.y),l};function l(e){return{controlKey:e.ctrlKey,altKey:e.altKey,shiftKey:e.shiftKey}}function c(e){const t=l(e);return{key:e.key,keyCode:e.charCode,...t}}function u(e){return e.pointerType||&quot;&quot;}const d=()=>{if(null===t.container)return;const{container:n}=t;n.addEventListener(&quot;contextmenu&quot;,Rh),n.addEventListener(&quot;wheel&quot;,e.handleWheel),n.addEventListener(&quot;DOMMouseScroll&quot;,e.handleWheel),n.addEventListener(&quot;pointerenter&quot;,e.handlePointerEnter),n.addEventListener(&quot;pointerleave&quot;,e.handlePointerLeave),n.addEventListener(&quot;pointermove&quot;,e.handlePointerMove,{passive:!1}),n.addEventListener(&quot;pointerdown&quot;,e.handlePointerDown,{passive:!1}),n.addEventListener(&quot;pointerup&quot;,e.handlePointerUp),n.addEventListener(&quot;pointercancel&quot;,e.handlePointerCancel),n.addEventListener(&quot;keypress&quot;,e.handleKeyPress),n.addEventListener(&quot;keydown&quot;,e.handleKeyDown),document.addEventListener(&quot;keyup&quot;,e.handleKeyUp),document.addEventListener(&quot;pointerlockchange&quot;,e.handlePointerLockChange),n.tabIndex=0,n.style.touchAction=&quot;none&quot;,n.style.userSelect=&quot;none&quot;,n.style.webkitTapHighlightColor=&quot;rgba(0,0,0,0)&quot;};e.bindEvents=e=>{null!==e&&n.setContainer(e)&&d()};const p=()=>{clearTimeout(t.moveTimeoutID),clearTimeout(t.wheelTimeoutID),t.moveTimeoutID=0,t.wheelTimeoutID=0,a=1;const{container:n}=t;n&&(n.removeEventListener(&quot;contextmenu&quot;,Rh),n.removeEventListener(&quot;wheel&quot;,e.handleWheel),n.removeEventListener(&quot;DOMMouseScroll&quot;,e.handleWheel),n.removeEventListener(&quot;pointerenter&quot;,e.handlePointerEnter),n.removeEventListener(&quot;pointerleave&quot;,e.handlePointerLeave),n.removeEventListener(&quot;pointermove&quot;,e.handlePointerMove,{passive:!1}),n.removeEventListener(&quot;pointerdown&quot;,e.handlePointerDown,{passive:!1}),n.removeEventListener(&quot;pointerup&quot;,e.handlePointerUp),n.removeEventListener(&quot;pointercancel&quot;,e.handlePointerCancel),n.removeEventListener(&quot;keypress&quot;,e.handleKeyPress),n.removeEventListener(&quot;keydown&quot;,e.handleKeyDown)),document.removeEventListener(&quot;keyup&quot;,e.handleKeyUp),document.removeEventListener(&quot;pointerlockchange&quot;,e.handlePointerLockChange),o.clear()};function f(){t._view&&t.enabled&&t.enableRender&&(t.inRender=!0,t._view.traverseAllPasses(),t.inRender=!1),e.invokeRenderEvent()}e.unbindEvents=()=>{p(),n.setContainer(null)},e.handleKeyPress=t=>{const n=c(t);e.keyPressEvent(n)},e.handleKeyDown=t=>{const n=c(t);e.keyDownEvent(n)},e.handleKeyUp=t=>{const n=c(t);e.keyUpEvent(n)},e.handlePointerEnter=t=>{const n={...l(t),position:s(t),deviceType:u(t)};e.pointerEnterEvent(n),&quot;mouse&quot;===n.deviceType&&e.mouseEnterEvent(n)},e.handlePointerLeave=t=>{const n={...l(t),position:s(t),deviceType:u(t)};e.pointerLeaveEvent(n),&quot;mouse&quot;===n.deviceType&&e.mouseLeaveEvent(n)},e.handlePointerDown=n=>{if(!(n.button>2||e.isPointerLocked()))switch(t.preventDefaultOnPointerDown&&Rh(n),n.target.hasPointerCapture(n.pointerId)&&n.target.releasePointerCapture(n.pointerId),t.container.setPointerCapture(n.pointerId),o.has(n.pointerId)&&Ch(&quot;[RenderWindowInteractor] duplicate pointerId detected&quot;),o.set(n.pointerId,{pointerId:n.pointerId,position:s(n)}),n.pointerType){case&quot;pen&quot;:case&quot;touch&quot;:e.handleTouchStart(n);break;default:e.handleMouseDown(n)}},e.handlePointerUp=n=>{if(o.has(n.pointerId))switch(t.preventDefaultOnPointerUp&&Rh(n),o.delete(n.pointerId),t.container.releasePointerCapture(n.pointerId),n.pointerType){case&quot;pen&quot;:case&quot;touch&quot;:e.handleTouchEnd(n);break;default:e.handleMouseUp(n)}},e.handlePointerCancel=t=>{if(o.has(t.pointerId))switch(o.delete(t.pointerId),t.pointerType){case&quot;pen&quot;:case&quot;touch&quot;:e.handleTouchEnd(t);break;default:e.handleMouseUp(t)}},e.handlePointerMove=t=>{switch(o.has(t.pointerId)&&(o.get(t.pointerId).position=s(t)),t.pointerType){case&quot;pen&quot;:case&quot;touch&quot;:e.handleTouchMove(t);break;default:e.handleMouseMove(t)}},e.handleMouseDown=t=>{const n={...l(t),position:s(t),deviceType:u(t)};switch(t.button){case 0:e.leftButtonPressEvent(n);break;case 1:e.middleButtonPressEvent(n);break;case 2:e.rightButtonPressEvent(n);break;default:Sh(`Unknown mouse button pressed: ${t.button}`)}},e.requestPointerLock=()=>{t.container&&t.container.requestPointerLock()},e.exitPointerLock=()=>document.exitPointerLock?.(),e.isPointerLocked=()=>!!t.container&&document.pointerLockElement===t.container,e.handlePointerLockChange=()=>{e.isPointerLocked()?e.startPointerLockEvent():e.endPointerLockEvent()},e.requestAnimation=n=>{void 0!==n?r.has(n)?Ch(&quot;requester is already registered for animating&quot;):(r.add(n),t.animationRequest||1!==r.size||t.xrAnimation||(t._animationStartTime=Date.now(),t._animationFrameCount=0,t.animationRequest=requestAnimationFrame(e.handleAnimation),e.startAnimationEvent())):Sh(&quot;undefined requester, can not start animating&quot;)},e.extendAnimation=n=>{const o=Date.now()+n;t._animationExtendedEnd=Math.max(t._animationExtendedEnd,o),t.animationRequest||0!==r.size||t.xrAnimation||(t._animationStartTime=Date.now(),t._animationFrameCount=0,t.animationRequest=requestAnimationFrame(e.handleAnimation),e.startAnimationEvent())},e.isAnimating=()=>t.xrAnimation||null!==t.animationRequest,e.cancelAnimation=function(n){let o=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(r.has(n))r.delete(n),t.animationRequest&&0===r.size&&Date.now()>t._animationExtendedEnd&&(cancelAnimationFrame(t.animationRequest),t.animationRequest=null,e.endAnimationEvent(),e.render());else if(!o){const e=n&&n.getClassName?n.getClassName():n;Ch(`${e} did not request an animation`)}},e.switchToXRAnimation=()=>{t.animationRequest&&(cancelAnimationFrame(t.animationRequest),t.animationRequest=null),t.xrAnimation=!0},e.returnFromXRAnimation=()=>{t.xrAnimation=!1,0!==r.size&&(t.recentAnimationFrameRate=10,t.animationRequest=requestAnimationFrame(e.handleAnimation))},e.updateXRGamepads=(n,r,o)=>{n.inputSources.forEach((n=>{const a=null==n.gripSpace?null:r.getPose(n.gripSpace,o),i=null==n.gripSpace?null:r.getPose(n.targetRaySpace,o),s=n.gamepad,l=n.handedness;if(s){s.index in t.lastGamepadValues||(t.lastGamepadValues[s.index]={left:{buttons:{}},right:{buttons:{}},none:{buttons:{}}});for(let r=0;r<s.buttons.length;++r)r in t.lastGamepadValues[s.index][l].buttons||(t.lastGamepadValues[s.index][l].buttons[r]=!1),t.lastGamepadValues[s.index][l].buttons[r]!==s.buttons[r].pressed&&null!=a&&(e.button3DEvent({gamepad:s,position:a.transform.position,orientation:a.transform.orientation,targetPosition:i.transform.position,targetOrientation:i.transform.orientation,pressed:s.buttons[r].pressed,device:&quot;left&quot;===n.handedness?bh.LeftController:bh.RightController,input:Oh[s.mapping]&&Oh[s.mapping][r]?Oh[s.mapping][r]:xh.Trigger}),t.lastGamepadValues[s.index][l].buttons[r]=s.buttons[r].pressed),t.lastGamepadValues[s.index][l].buttons[r]&&null!=a&&e.move3DEvent({gamepad:s,position:a.transform.position,orientation:a.transform.orientation,targetPosition:i.transform.position,targetOrientation:i.transform.orientation,device:&quot;left&quot;===n.handedness?bh.LeftController:bh.RightController})}}))},e.handleMouseMove=n=>{const r={...l(n),position:s(n),deviceType:u(n)};0===t.moveTimeoutID?e.startMouseMoveEvent(r):(e.mouseMoveEvent(r),clearTimeout(t.moveTimeoutID)),t.moveTimeoutID=setTimeout((()=>{e.endMouseMoveEvent(),t.moveTimeoutID=0}),200)},e.handleAnimation=()=>{const n=Date.now();t._animationFrameCount++,n-t._animationStartTime>1e3&&t._animationFrameCount>1&&(t.recentAnimationFrameRate=1e3*(t._animationFrameCount-1)/(n-t._animationStartTime),t.lastFrameTime=1/t.recentAnimationFrameRate,e.animationFrameRateUpdateEvent(),t._animationStartTime=n,t._animationFrameCount=1),e.animationEvent(),f(),r.size>0||Date.now()<t._animationExtendedEnd?t.animationRequest=requestAnimationFrame(e.handleAnimation):(cancelAnimationFrame(t.animationRequest),t.animationRequest=null,e.endAnimationEvent(),e.render())},e.handleWheel=n=>{Rh(n);const r={...Ah(n),...l(n),position:s(n),deviceType:u(n)};0===t.wheelTimeoutID&&(a=Math.abs(r.spinY)>=.3?Math.abs(r.spinY):1),r.spinY/=a,0===t.wheelTimeoutID?(e.startMouseWheelEvent(r),e.mouseWheelEvent(r)):(e.mouseWheelEvent(r),clearTimeout(t.wheelTimeoutID)),t.mouseScrollDebounceByPass?(e.extendAnimation(600),e.endMouseWheelEvent(),t.wheelTimeoutID=0):t.wheelTimeoutID=setTimeout((()=>{e.extendAnimation(600),e.endMouseWheelEvent(),t.wheelTimeoutID=0}),200)},e.handleMouseUp=t=>{const n={...l(t),position:s(t),deviceType:u(t)};switch(t.button){case 0:e.leftButtonReleaseEvent(n);break;case 1:e.middleButtonReleaseEvent(n);break;case 2:e.rightButtonReleaseEvent(n);break;default:Sh(`Unknown mouse button released: ${t.button}`)}},e.handleTouchStart=n=>{const r=[...o.values()];if(t.recognizeGestures&&r.length>1){const t=Mh(o);if(2===r.length){const t={...l(wh),position:r[0].position,deviceType:u(n)};e.leftButtonReleaseEvent(t)}e.recognizeGesture(&quot;TouchStart&quot;,t)}else if(1===r.length){const t={...l(wh),position:s(n),deviceType:u(n)};e.leftButtonPressEvent(t)}},e.handleTouchMove=n=>{const r=[...o.values()];if(t.recognizeGestures&&r.length>1){const t=Mh(o);e.recognizeGesture(&quot;TouchMove&quot;,t)}else if(1===r.length){const t={...l(wh),position:r[0].position,deviceType:u(n)};e.mouseMoveEvent(t)}},e.handleTouchEnd=n=>{const r=[...o.values()];if(t.recognizeGestures)if(0===r.length){const t={...l(wh),position:s(n),deviceType:u(n)};e.leftButtonReleaseEvent(t)}else if(1===r.length){const t=Mh(o);e.recognizeGesture(&quot;TouchEnd&quot;,t);const a={...l(wh),position:r[0].position,deviceType:u(n)};e.leftButtonPressEvent(a)}else{const t=Mh(o);e.recognizeGesture(&quot;TouchMove&quot;,t)}else if(1===r.length){const t={...l(wh),position:r[0].position,deviceType:u(n)};e.leftButtonReleaseEvent(t)}},e.setView=n=>{t._view!==n&&(t._view=n,t._view.getRenderable().setInteractor(e),e.modified())},e.getFirstRenderer=()=>t._view?.getRenderable()?.getRenderersByReference()?.[0],e.findPokedRenderer=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;if(!t._view)return null;const r=t._view?.getRenderable()?.getRenderers();if(!r||0===r.length)return null;r.sort(((e,t)=>e.getLayer()-t.getLayer()));let o=null,a=null,i=null,s=r.length;for(;s--;){const l=r[s];if(t._view.isInViewport(e,n,l)&&l.getInteractive()){i=l;break}null===o&&l.getInteractive()&&(o=l),null===a&&t._view.isInViewport(e,n,l)&&(a=l)}return null===i&&(i=o),null===i&&(i=a),null==i&&(i=r[0]),i},e.render=()=>{e.isAnimating()||t.inRender||f()},Ph.forEach((n=>{const r=n.charAt(0).toLowerCase()+n.slice(1);e[`${r}Event`]=r=>{if(!t.enabled)return;if(!e.getCurrentRenderer())return void Ih(&quot;\\n          Can not forward events without a current renderer on the interactor.\\n        &quot;);const o={type:n,pokedRenderer:t.currentRenderer,firstRenderer:e.getFirstRenderer(),...r};e[`invoke${n}`](o)}})),e.recognizeGesture=(n,r)=>{if(Object.keys(r).length>2)return;if(t.startingEventPositions||(t.startingEventPositions={}),&quot;TouchStart&quot;===n)return Object.keys(r).forEach((e=>{t.startingEventPositions[e]=r[e]})),void(t.currentGesture=&quot;Start&quot;);if(&quot;TouchEnd&quot;===n)return&quot;Pinch&quot;===t.currentGesture&&(e.render(),e.endPinchEvent()),&quot;Rotate&quot;===t.currentGesture&&(e.render(),e.endRotateEvent()),&quot;Pan&quot;===t.currentGesture&&(e.render(),e.endPanEvent()),t.currentGesture=&quot;Start&quot;,void(t.startingEventPositions={});let o=0;const a=[],i=[];Object.keys(r).forEach((e=>{a[o]=r[e],i[o]=t.startingEventPositions[e],o++}));const s=Math.sqrt((i[0].x-i[1].x)*(i[0].x-i[1].x)+(i[0].y-i[1].y)*(i[0].y-i[1].y)),l=Math.sqrt((a[0].x-a[1].x)*(a[0].x-a[1].x)+(a[0].y-a[1].y)*(a[0].y-a[1].y));let c=To(Math.atan2(i[1].y-i[0].y,i[1].x-i[0].x)),u=To(Math.atan2(a[1].y-a[0].y,a[1].x-a[0].x)),d=u-c;u=u+180>=360?u-180:u+180,c=c+180>=360?c-180:c+180,Math.abs(u-c)<Math.abs(d)&&(d=u-c);const p=[];if(p[0]=(a[0].x-i[0].x+a[1].x-i[1].x)/2,p[1]=(a[0].y-i[0].y+a[1].y-i[1].y)/2,&quot;TouchMove&quot;===n)if(&quot;Start&quot;===t.currentGesture){let n=.01*Math.sqrt(t.container.clientWidth*t.container.clientWidth+t.container.clientHeight*t.container.clientHeight);n<15&&(n=15);const o=Math.abs(l-s),a=3.1415926*l*Math.abs(d)/360,i=Math.sqrt(p[0]*p[0]+p[1]*p[1]);if(o>n&&o>a&&o>i){t.currentGesture=&quot;Pinch&quot;;const n={scale:1,touches:r};e.startPinchEvent(n)}else if(a>n&&a>i){t.currentGesture=&quot;Rotate&quot;;const n={rotation:0,touches:r};e.startRotateEvent(n)}else if(i>n){t.currentGesture=&quot;Pan&quot;;const n={translation:[0,0],touches:r};e.startPanEvent(n)}}else{if(&quot;Rotate&quot;===t.currentGesture){const t={rotation:d,touches:r};e.rotateEvent(t)}if(&quot;Pinch&quot;===t.currentGesture){const t={scale:l/s,touches:r};e.pinchEvent(t)}if(&quot;Pan&quot;===t.currentGesture){const t={translation:p,touches:r};e.panEvent(t)}}},e.handleVisibilityChange=()=>{t._animationStartTime=Date.now(),t._animationFrameCount=0},e.setCurrentRenderer=e=>{t._forcedRenderer=!!e,t.currentRenderer=e},e.setContainer=e=>{p();const t=n.setContainer(e??null);return t&&d(),t},e.delete=()=>{for(;r.size;)e.cancelAnimation(r.values().next().value);void 0!==document.hidden&&document.removeEventListener(&quot;visibilitychange&quot;,e.handleVisibilityChange),t.container&&e.setContainer(null),n.delete()},void 0!==document.hidden&&document.addEventListener(&quot;visibilitychange&quot;,e.handleVisibilityChange,!1)}(e,t)}var Dh={newInstance:Wt.newInstance(Vh,&quot;vtkRenderWindowInteractor&quot;),extend:Vh,handledEvents:Ph,...yh};const{vtkErrorMacro:Lh,VOID:Bh}=Wt,Nh={enabled:!0,priority:0,processEvents:!0,subscribedEvents:[]};function Fh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Nh,n),Wt.obj(e,t),Wt.event(e,t,&quot;InteractionEvent&quot;),Wt.event(e,t,&quot;StartInteractionEvent&quot;),Wt.event(e,t,&quot;EndInteractionEvent&quot;),Wt.get(e,t,[&quot;_interactor&quot;,&quot;enabled&quot;]),Wt.setGet(e,t,[&quot;priority&quot;,&quot;processEvents&quot;]),Wt.moveToProtected(e,t,[&quot;interactor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkInteractorObserver&quot;);const n={...e};function r(){for(;t.subscribedEvents.length;)t.subscribedEvents.pop().unsubscribe()}function o(){Dh.handledEvents.forEach((n=>{e[`handle${n}`]&&t.subscribedEvents.push(t._interactor[`on${n}`]((r=>t.processEvents?e[`handle${n}`](r):Bh),t.priority))}))}e.setInteractor=n=>{n!==t._interactor&&(r(),t._interactor=n,n&&t.enabled&&o(),e.modified())},e.setEnabled=n=>{n!==t.enabled&&(r(),n&&(t._interactor?o():Lh(&quot;\\n          The interactor must be set before subscribing to events\\n        &quot;)),t.enabled=n,e.modified())},e.computeDisplayToWorld=(e,n,r,o)=>e?t._interactor.getView().displayToWorld(n,r,o,e):null,e.computeWorldToDisplay=(e,n,r,o)=>e?t._interactor.getView().worldToDisplay(n,r,o,e):null,e.setPriority=e=>{n.setPriority(e)&&t._interactor&&(r(),o())}}(e,t)}var _h={newInstance:Wt.newInstance(Fh,&quot;vtkInteractorObserver&quot;),extend:Fh,computeWorldToDisplay:function(e,t,n,r){return e.getRenderWindow().getViews()[0].worldToDisplay(t,n,r,e)},computeDisplayToWorld:function(e,t,n,r){return e.getRenderWindow().getViews()[0].displayToWorld(t,n,r,e)}},kh={States:{IS_START:0,IS_NONE:0,IS_ROTATE:1,IS_PAN:2,IS_SPIN:3,IS_DOLLY:4,IS_CAMERA_POSE:11,IS_WINDOW_LEVEL:1024,IS_SLICE:1025}};const{States:Gh}=kh,Uh={Rotate:Gh.IS_ROTATE,Pan:Gh.IS_PAN,Spin:Gh.IS_SPIN,Dolly:Gh.IS_DOLLY,CameraPose:Gh.IS_CAMERA_POSE,WindowLevel:Gh.IS_WINDOW_LEVEL,Slice:Gh.IS_SLICE},zh={state:Gh.IS_NONE,handleObservers:1,autoAdjustCameraClippingRange:1};function Wh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,zh,n),_h.extend(e,t,n),Wt.setGet(e,t,[&quot;focusedRenderer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkInteractorStyle&quot;),Object.keys(Uh).forEach((n=>{Wt.event(e,t,`Start${n}Event`),e[`start${n}`]=()=>{t.state===Gh.IS_NONE&&(t.state=Uh[n],t._interactor.requestAnimation(e),e.invokeStartInteractionEvent({type:&quot;StartInteractionEvent&quot;}),e[`invokeStart${n}Event`]({type:`Start${n}Event`}))},Wt.event(e,t,`End${n}Event`),e[`end${n}`]=()=>{t.state===Uh[n]&&(t.state=Gh.IS_NONE,t._interactor.cancelAnimation(e),e.invokeEndInteractionEvent({type:&quot;EndInteractionEvent&quot;}),e[`invokeEnd${n}Event`]({type:`End${n}Event`}),t._interactor.render())}})),t.getRenderer=e=>t.focusedRenderer||e.pokedRenderer,e.handleKeyPress=e=>{const n=t._interactor;let r=null;switch(e.key){case&quot;r&quot;:case&quot;R&quot;:t.getRenderer(e).resetCamera(),n.render();break;case&quot;w&quot;:case&quot;W&quot;:r=t.getRenderer(e).getActors(),r.forEach((e=>{const t=e.getProperty();t.setRepresentationToWireframe&&t.setRepresentationToWireframe()})),n.render();break;case&quot;s&quot;:case&quot;S&quot;:r=t.getRenderer(e).getActors(),r.forEach((e=>{const t=e.getProperty();t.setRepresentationToSurface&&t.setRepresentationToSurface()})),n.render();break;case&quot;v&quot;:case&quot;V&quot;:r=t.getRenderer(e).getActors(),r.forEach((e=>{const t=e.getProperty();t.setRepresentationToPoints&&t.setRepresentationToPoints()})),n.render()}}}(e,t)}var Hh={newInstance:Wt.newInstance(Wh,&quot;vtkInteractorStyle&quot;),extend:Wh,...kh};const{States:jh}=kh,Kh={motionFactor:10,zoomFactor:10};function $h(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Kh,n),Hh.extend(e,t,n),Wt.setGet(e,t,[&quot;motionFactor&quot;,&quot;zoomFactor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkInteractorStyleTrackballCamera&quot;),e.handleMouseMove=n=>{const r=n.position,o=t.getRenderer(n);switch(t.state){case jh.IS_ROTATE:e.handleMouseRotate(o,r),e.invokeInteractionEvent({type:&quot;InteractionEvent&quot;});break;case jh.IS_PAN:e.handleMousePan(o,r),e.invokeInteractionEvent({type:&quot;InteractionEvent&quot;});break;case jh.IS_DOLLY:e.handleMouseDolly(o,r),e.invokeInteractionEvent({type:&quot;InteractionEvent&quot;});break;case jh.IS_SPIN:e.handleMouseSpin(o,r),e.invokeInteractionEvent({type:&quot;InteractionEvent&quot;})}t.previousPosition=r},e.handleButton3D=n=>{!n||!n.pressed||n.device!==vh.RightController||n.input!==Th.Trigger&&n.input!==Th.TrackPad?!n||n.pressed||n.device!==vh.RightController||n.input!==Th.Trigger&&n.input!==Th.TrackPad||t.state!==jh.IS_CAMERA_POSE||e.endCameraPose():e.startCameraPose()},e.handleMove3D=n=>{t.state===jh.IS_CAMERA_POSE&&e.updateCameraPose(n)},e.updateCameraPose=e=>{const n=t.getRenderer(e).getActiveCamera(),r=n.getPhysicalTranslation(),o=.025*n.getPhysicalScale(),a=n.physicalOrientationToWorldDirection([e.orientation.x,e.orientation.y,e.orientation.z,e.orientation.w]);n.setPhysicalTranslation(r[0]+a[0]*o,r[1]+a[1]*o,r[2]+a[2]*o)},e.handleLeftButtonPress=n=>{const r=n.position;t.previousPosition=r,n.shiftKey?n.controlKey||n.altKey?e.startDolly():e.startPan():n.controlKey||n.altKey?e.startSpin():e.startRotate()},e.handleLeftButtonRelease=()=>{switch(t.state){case jh.IS_DOLLY:e.endDolly();break;case jh.IS_PAN:e.endPan();break;case jh.IS_SPIN:e.endSpin();break;case jh.IS_ROTATE:e.endRotate()}},e.handleStartMouseWheel=()=>{e.startDolly()},e.handleEndMouseWheel=()=>{e.endDolly()},e.handleStartPinch=n=>{t.previousScale=n.scale,e.startDolly()},e.handleEndPinch=()=>{e.endDolly()},e.handleStartRotate=n=>{t.previousRotation=n.rotation,e.startRotate()},e.handleEndRotate=()=>{e.endRotate()},e.handleStartPan=n=>{t.previousTranslation=n.translation,e.startPan()},e.handleEndPan=()=>{e.endPan()},e.handlePinch=n=>{e.dollyByFactor(t.getRenderer(n),n.scale/t.previousScale),t.previousScale=n.scale},e.handlePan=n=>{const r=t.getRenderer(n).getActiveCamera();let o=r.getFocalPoint();o=e.computeWorldToDisplay(t.getRenderer(n),o[0],o[1],o[2]);const a=o[2],i=n.translation,s=t.previousTranslation,l=e.computeDisplayToWorld(t.getRenderer(n),o[0]+i[0]-s[0],o[1]+i[1]-s[1],a),c=e.computeDisplayToWorld(t.getRenderer(n),o[0],o[1],a),u=[];u[0]=c[0]-l[0],u[1]=c[1]-l[1],u[2]=c[2]-l[2],o=r.getFocalPoint();const d=r.getPosition();r.setFocalPoint(u[0]+o[0],u[1]+o[1],u[2]+o[2]),r.setPosition(u[0]+d[0],u[1]+d[1],u[2]+d[2]),t._interactor.getLightFollowCamera()&&t.getRenderer(n).updateLightsGeometryToFollowCamera(),r.orthogonalizeViewUp(),t.previousTranslation=n.translation},e.handleRotate=e=>{const n=t.getRenderer(e).getActiveCamera();n.roll(e.rotation-t.previousRotation),n.orthogonalizeViewUp(),t.previousRotation=e.rotation},e.handleMouseRotate=(e,n)=>{if(!t.previousPosition)return;const r=t._interactor,o=n.x-t.previousPosition.x,a=n.y-t.previousPosition.y,i=r.getView().getViewportSize(e);let s=-.1,l=-.1;i[0]&&i[1]&&(s=-20/i[1],l=-20/i[0]);const c=o*l*t.motionFactor,u=a*s*t.motionFactor,d=e.getActiveCamera();Number.isNaN(c)||Number.isNaN(u)||(d.azimuth(c),d.elevation(u),d.orthogonalizeViewUp()),t.autoAdjustCameraClippingRange&&e.resetCameraClippingRange(),r.getLightFollowCamera()&&e.updateLightsGeometryToFollowCamera()},e.handleMouseSpin=(e,n)=>{if(!t.previousPosition)return;const r=t._interactor,o=e.getActiveCamera(),a=r.getView().getViewportCenter(e),i=To(Math.atan2(t.previousPosition.y-a[1],t.previousPosition.x-a[0])),s=To(Math.atan2(n.y-a[1],n.x-a[0]))-i;Number.isNaN(s)||(o.roll(s),o.orthogonalizeViewUp())},e.handleMousePan=(n,r)=>{if(!t.previousPosition)return;const o=n.getActiveCamera();let a=o.getFocalPoint();a=e.computeWorldToDisplay(n,a[0],a[1],a[2]);const i=a[2],s=e.computeDisplayToWorld(n,r.x,r.y,i),l=e.computeDisplayToWorld(n,t.previousPosition.x,t.previousPosition.y,i),c=[];c[0]=l[0]-s[0],c[1]=l[1]-s[1],c[2]=l[2]-s[2],a=o.getFocalPoint();const u=o.getPosition();o.setFocalPoint(c[0]+a[0],c[1]+a[1],c[2]+a[2]),o.setPosition(c[0]+u[0],c[1]+u[1],c[2]+u[2]),t._interactor.getLightFollowCamera()&&n.updateLightsGeometryToFollowCamera()},e.handleMouseDolly=(n,r)=>{if(!t.previousPosition)return;const o=r.y-t.previousPosition.y,a=t._interactor.getView().getViewportCenter(n),i=t.motionFactor*o/a[1];e.dollyByFactor(n,1.1**i)},e.handleMouseWheel=n=>{const r=1-n.spinY/t.zoomFactor;e.dollyByFactor(t.getRenderer(n),r)},e.dollyByFactor=(e,n)=>{if(Number.isNaN(n))return;const r=e.getActiveCamera();r.getParallelProjection()?r.setParallelScale(r.getParallelScale()/n):(r.dolly(n),t.autoAdjustCameraClippingRange&&e.resetCameraClippingRange()),t._interactor.getLightFollowCamera()&&e.updateLightsGeometryToFollowCamera()}}(e,t)}var qh={newInstance:Wt.newInstance($h,&quot;vtkInteractorStyleTrackballCamera&quot;),extend:$h};function Xh(e){return e}function Yh(e){return null===e||&quot;null&quot;===e?null:&quot;true&quot;===e||&quot;false&quot;!==e&&(void 0!==e&&&quot;undefined&quot;!==e?&quot;[&quot;===e[0]&&&quot;]&quot;===e[e.length-1]?e.substring(1,e.length-1).split(&quot;,&quot;).map((e=>Yh(e.trim()))):&quot;&quot;===e||Number.isNaN(Number(e))?e:Number(e):void 0)}var Zh=function(){let e=!(arguments.length>0&&void 0!==arguments[0])||arguments[0],t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:window.location.search;const n={},r=e?Yh:Xh;return new URLSearchParams(t).forEach(((e,t)=>{t&&(n[t]=!e||r(e))})),n};const Qh={delegates:[],currentOperation:null,preDelegateOperations:[],postDelegateOperations:[],currentParent:null};function Jh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Qh,n),Wt.obj(e,t),Wt.get(e,t,[&quot;currentOperation&quot;]),Wt.setGet(e,t,[&quot;delegates&quot;,&quot;_currentParent&quot;,&quot;preDelegateOperations&quot;,&quot;postDelegateOperations&quot;]),Wt.moveToProtected(e,t,[&quot;currentParent&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkRenderPass&quot;),e.getOperation=()=>t.currentOperation,e.setCurrentOperation=e=>{t.currentOperation=e,t.currentTraverseOperation=`traverse${Wt.capitalize(t.currentOperation)}`},e.getTraverseOperation=()=>t.currentTraverseOperation,e.traverse=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;t.deleted||(t._currentParent=r,t.preDelegateOperations.forEach((t=>{e.setCurrentOperation(t),n.traverse(e)})),t.delegates.forEach((t=>{t.traverse(n,e)})),t.postDelegateOperations.forEach((t=>{e.setCurrentOperation(t),n.traverse(e)})))}}(e,t)}var ev={newInstance:Wt.newInstance(Jh,&quot;vtkRenderPass&quot;),extend:Jh};const{Representation:tv}=os,{vtkErrorMacro:nv}=Wt;function rv(e){const t=td.substitute(e.Fragment,&quot;//VTK::RenderPassFragmentShader::Impl&quot;,&quot;\\n      float weight = gl_FragData[0].a * pow(max(1.1 - gl_FragCoord.z, 0.0), 2.0);\\n      gl_FragData[0] = vec4(gl_FragData[0].rgb*weight, gl_FragData[0].a);\\n      gl_FragData[1].r = weight;\\n    &quot;,!1);e.Fragment=t.result}const ov={framebuffer:null,copyShader:null,tris:null};function av(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ov,n),ev.extend(e,t,n),t.VBOBuildTime={},Wt.obj(t.VBOBuildTime,{mtime:0}),t.tris=ld.newInstance(),Wt.get(e,t,[&quot;framebuffer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLOrderIndependentTranslucentPass&quot;),e.createVertexBuffer=()=>{const e=new Float32Array([-1,-1,-1,1,-1,-1,-1,1,-1,1,1,-1]),n=new Float32Array([0,0,1,0,0,1,1,1]),r=new Uint16Array([4,0,1,3,2]),o=xs.newInstance({numberOfComponents:3,values:e});o.setName(&quot;points&quot;);const a=xs.newInstance({numberOfComponents:2,values:n});a.setName(&quot;tcoords&quot;);const i=xs.newInstance({numberOfComponents:1,values:r});t.tris.getCABO().createVBO(i,&quot;polys&quot;,tv.SURFACE,{points:o,tcoords:a,cellOffset:0}),t.VBOBuildTime.modified()},e.createFramebuffer=e=>{const n=e.getSize(),r=e.getContext();t.framebuffer=Sp.newInstance(),t.framebuffer.setOpenGLRenderWindow(e),t.framebuffer.create(...n),t.framebuffer.saveCurrentBindingsAndBuffers(),t.framebuffer.bind(),t.translucentRGBATexture=Pd.newInstance(),t.translucentRGBATexture.setInternalFormat(r.RGBA16F),t.translucentRGBATexture.setFormat(r.RGBA),t.translucentRGBATexture.setOpenGLDataType(r.HALF_FLOAT),t.translucentRGBATexture.setOpenGLRenderWindow(e),t.translucentRGBATexture.create2DFromRaw({width:n[0],height:n[1],numComps:4,dataType:&quot;Float32Array&quot;,data:null}),t.translucentRTexture=Pd.newInstance(),t.translucentRTexture.setInternalFormat(r.R16F),t.translucentRTexture.setFormat(r.RED),t.translucentRTexture.setOpenGLDataType(r.HALF_FLOAT),t.translucentRTexture.setOpenGLRenderWindow(e),t.translucentRTexture.create2DFromRaw({width:n[0],height:n[1],numComps:1,dataType:&quot;Float32Array&quot;,data:null}),t.translucentZTexture=Pd.newInstance(),t.translucentZTexture.setOpenGLRenderWindow(e),t.translucentZTexture.createDepthFromRaw({width:n[0],height:n[1],dataType:&quot;Float32Array&quot;,data:null}),t.framebuffer.setColorBuffer(t.translucentRGBATexture,0),t.framebuffer.setColorBuffer(t.translucentRTexture,1),t.framebuffer.setDepthBuffer(t.translucentZTexture)},e.createCopyShader=e=>{t.copyShader=e.getShaderCache().readyShaderProgramArray([&quot;//VTK::System::Dec&quot;,&quot;attribute vec4 vertexDC;&quot;,&quot;attribute vec2 tcoordTC;&quot;,&quot;varying vec2 tcoord;&quot;,&quot;void main() { tcoord = tcoordTC; gl_Position = vertexDC; }&quot;].join(&quot;\\n&quot;),&quot;//VTK::System::Dec\\n\\nin vec2 tcoord;\\n\\nuniform sampler2D translucentRTexture;\\nuniform sampler2D translucentRGBATexture;\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nvoid main()\\n{\\n  vec4 t1Color = texture(translucentRGBATexture, tcoord);\\n  float t2Color = texture(translucentRTexture, tcoord).r;\\n  gl_FragData[0] = vec4(t1Color.rgb/max(t2Color,0.01), 1.0 - t1Color.a);\\n}\\n&quot;,&quot;&quot;)},e.createVBO=n=>{const r=n.getContext();t.tris.setOpenGLRenderWindow(n),e.createVertexBuffer();const o=t.copyShader;t.tris.getCABO().bind(),t.copyVAO.addAttributeArray(o,t.tris.getCABO(),&quot;vertexDC&quot;,t.tris.getCABO().getVertexOffset(),t.tris.getCABO().getStride(),r.FLOAT,3,r.FALSE)||nv(&quot;Error setting vertexDC in copy shader VAO.&quot;),t.copyVAO.addAttributeArray(o,t.tris.getCABO(),&quot;tcoordTC&quot;,t.tris.getCABO().getTCoordOffset(),t.tris.getCABO().getStride(),r.FLOAT,2,r.FALSE)||nv(&quot;Error setting vertexDC in copy shader VAO.&quot;)},e.traverse=(n,r,o)=>{if(t.deleted)return;const a=n.getSize(),i=n.getContext();if(t._supported=!1,r.getSelector()||!i||!n.getWebgl2()||!i.getExtension(&quot;EXT_color_buffer_half_float&quot;)&&!i.getExtension(&quot;EXT_color_buffer_float&quot;))return e.setCurrentOperation(&quot;translucentPass&quot;),void r.traverse(e);if(t._supported=!0,null===t.framebuffer)e.createFramebuffer(n);else{const r=t.framebuffer.getSize();null===r||r[0]!==a[0]||r[1]!==a[1]?(t.framebuffer.releaseGraphicsResources(),t.translucentRGBATexture.releaseGraphicsResources(n),t.translucentRTexture.releaseGraphicsResources(n),t.translucentZTexture.releaseGraphicsResources(n),e.createFramebuffer(n)):(t.framebuffer.saveCurrentBindingsAndBuffers(),t.framebuffer.bind())}i.drawBuffers([i.COLOR_ATTACHMENT0]),i.clearBufferfv(i.COLOR,0,[0,0,0,0]),i.clearBufferfv(i.DEPTH,0,[1]),i.colorMask(!1,!1,!1,!1),o.getOpaqueActorCount()>0&&(o.setCurrentOperation(&quot;opaqueZBufferPass&quot;),r.traverse(o)),i.colorMask(!0,!0,!0,!0),i.drawBuffers([i.COLOR_ATTACHMENT0,i.COLOR_ATTACHMENT1]),i.viewport(0,0,a[0],a[1]),i.scissor(0,0,a[0],a[1]),i.clearBufferfv(i.COLOR,0,[0,0,0,1]),i.clearBufferfv(i.COLOR,1,[0,0,0,0]),i.enable(i.DEPTH_TEST),i.enable(i.BLEND),i.blendFuncSeparate(i.ONE,i.ONE,i.ZERO,i.ONE_MINUS_SRC_ALPHA),e.setCurrentOperation(&quot;translucentPass&quot;),r.traverse(e),i.drawBuffers([i.NONE]),t.framebuffer.restorePreviousBindingsAndBuffers(),null===t.copyShader?e.createCopyShader(n):n.getShaderCache().readyShaderProgram(t.copyShader),t.copyVAO||(t.copyVAO=od.newInstance(),t.copyVAO.setOpenGLRenderWindow(n)),t.copyVAO.bind(),t.VBOBuildTime.getMTime()<e.getMTime()&&e.createVBO(n),i.blendFuncSeparate(i.SRC_ALPHA,i.ONE_MINUS_SRC_ALPHA,i.ONE,i.ONE_MINUS_SRC_ALPHA),i.depthMask(!1),i.depthFunc(i.ALWAYS),i.viewport(0,0,a[0],a[1]),i.scissor(0,0,a[0],a[1]),t.translucentRGBATexture.activate(),t.copyShader.setUniformi(&quot;translucentRGBATexture&quot;,t.translucentRGBATexture.getTextureUnit()),t.translucentRTexture.activate(),t.copyShader.setUniformi(&quot;translucentRTexture&quot;,t.translucentRTexture.getTextureUnit()),i.drawArrays(i.TRIANGLES,0,t.tris.getCABO().getElementCount()),i.depthMask(!0),i.depthFunc(i.LEQUAL),t.translucentRGBATexture.deactivate(),t.translucentRTexture.deactivate();const s=r.getTiledSizeAndOrigin();i.scissor(s.lowerLeftU,s.lowerLeftV,s.usize,s.vsize),i.viewport(s.lowerLeftU,s.lowerLeftV,s.usize,s.vsize)},e.getShaderReplacement=()=>t._supported?rv:null,e.releaseGraphicsResources=n=>{t.framebuffer&&(t.framebuffer.releaseGraphicsResources(n),t.framebuffer=null),t.translucentRGBATexture&&(t.translucentRGBATexture.releaseGraphicsResources(n),t.translucentRGBATexture=null),t.translucentRTexture&&(t.translucentRTexture.releaseGraphicsResources(n),t.translucentRTexture=null),t.translucentZTexture&&(t.translucentZTexture.releaseGraphicsResources(n),t.translucentZTexture=null),t.copyVAO&&(t.copyVAO.releaseGraphicsResources(n),t.copyVAO=null),t.copyShader&&(t.copyShader.releaseGraphicsResources(n),t.copyShader=null),t.tris&&(t.tris.releaseGraphicsResources(n),t.tris=null),e.modified()}}(e,t)}var iv={newInstance:Wt.newInstance(av,&quot;vtkOpenGLOrderIndependentTranslucentPass&quot;),extend:av};const sv={opaqueActorCount:0,translucentActorCount:0,volumeCount:0,overlayActorCount:0,framebuffer:null,depthRequested:!1};function lv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,sv,n),ev.extend(e,t,n),Wt.get(e,t,[&quot;framebuffer&quot;,&quot;opaqueActorCount&quot;,&quot;translucentActorCount&quot;,&quot;volumeCount&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkForwardPass&quot;),e.traverse=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(t.deleted)return;t._currentParent=r,e.setCurrentOperation(&quot;buildPass&quot;),n.traverse(e);const o=n.getRenderable().getNumberOfLayers(),a=n.getRenderable().getRenderersByReference();for(let r=0;r<o;r++)for(let o=0;o<a.length;o++){const i=a[o],s=n.getViewNodeFor(i);if(i.getDraw()&&i.getLayer()===r){if(t.opaqueActorCount=0,t.translucentActorCount=0,t.volumeCount=0,t.overlayActorCount=0,e.setCurrentOperation(&quot;queryPass&quot;),s.traverse(e),(t.opaqueActorCount>0||t.translucentActorCount>0)&&t.volumeCount>0||t.depthRequested){const r=n.getFramebufferSize();null===t.framebuffer&&(t.framebuffer=Sp.newInstance()),t.framebuffer.setOpenGLRenderWindow(n),t.framebuffer.saveCurrentBindingsAndBuffers();const o=t.framebuffer.getSize();null!==o&&o[0]===r[0]&&o[1]===r[1]||(t.framebuffer.create(r[0],r[1]),t.framebuffer.populateFramebuffer()),t.framebuffer.bind(),e.setCurrentOperation(&quot;zBufferPass&quot;),s.traverse(e),t.framebuffer.restorePreviousBindingsAndBuffers(),t.depthRequested=!1}e.setCurrentOperation(&quot;cameraPass&quot;),s.traverse(e),t.opaqueActorCount>0&&(e.setCurrentOperation(&quot;opaquePass&quot;),s.traverse(e)),t.translucentActorCount>0&&(t.translucentPass||(t.translucentPass=iv.newInstance()),t.translucentPass.traverse(n,s,e)),t.volumeCount>0&&(e.setCurrentOperation(&quot;volumePass&quot;),s.traverse(e)),t.overlayActorCount>0&&(e.setCurrentOperation(&quot;overlayPass&quot;),s.traverse(e))}}},e.getZBufferTexture=()=>t.framebuffer?t.framebuffer.getColorTexture():null,e.requestDepth=()=>{t.depthRequested=!0},e.incrementOpaqueActorCount=()=>t.opaqueActorCount++,e.incrementTranslucentActorCount=()=>t.translucentActorCount++,e.incrementVolumeCount=()=>t.volumeCount++,e.incrementOverlayActorCount=()=>t.overlayActorCount++}(e,t)}var cv={newInstance:Wt.newInstance(lv,&quot;vtkForwardPass&quot;),extend:lv},uv=n(292);const dv=[&quot;lastShaderProgramBound&quot;,&quot;context&quot;,&quot;_openGLRenderWindow&quot;],pv={lastShaderProgramBound:null,shaderPrograms:null,context:null};function fv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,pv,n),t.shaderPrograms={},Wt.obj(e,t),Wt.setGet(e,t,dv),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkShaderCache&quot;),e.replaceShaderValues=(e,n,r)=>{let o=n;r.length>0&&(o=td.substitute(o,&quot;VSOut&quot;,&quot;GSOut&quot;).result);const a=t._openGLRenderWindow.getWebgl2();let i=&quot;\\n&quot;,s=&quot;#version 100\\n&quot;;a?s=&quot;#version 300 es\\n#define attribute in\\n#define textureCube texture\\n#define texture2D texture\\n#define textureCubeLod textureLod\\n#define texture2DLod textureLod\\n&quot;:(t.context.getExtension(&quot;OES_standard_derivatives&quot;),t.context.getExtension(&quot;EXT_frag_depth&quot;)&&(i=&quot;#extension GL_EXT_frag_depth : enable\\n&quot;),t.context.getExtension(&quot;EXT_shader_texture_lod&quot;)&&(i+=&quot;#extension GL_EXT_shader_texture_lod : enable\\n#define textureCubeLod textureCubeLodEXT\\n#define texture2DLod texture2DLodEXT&quot;)),o=td.substitute(o,&quot;//VTK::System::Dec&quot;,[`${s}\\n`,a?&quot;&quot;:&quot;#extension GL_OES_standard_derivatives : enable\\n&quot;,i,&quot;#ifdef GL_FRAGMENT_PRECISION_HIGH&quot;,&quot;precision highp float;&quot;,&quot;precision highp int;&quot;,&quot;#else&quot;,&quot;precision mediump float;&quot;,&quot;precision mediump int;&quot;,&quot;#endif&quot;]).result;let l=td.substitute(e,&quot;//VTK::System::Dec&quot;,[`${s}\\n`,&quot;#ifdef GL_FRAGMENT_PRECISION_HIGH&quot;,&quot;precision highp float;&quot;,&quot;precision highp int;&quot;,&quot;#else&quot;,&quot;precision mediump float;&quot;,&quot;precision mediump int;&quot;,&quot;#endif&quot;]).result;if(a){l=td.substitute(l,&quot;varying&quot;,&quot;out&quot;).result,o=td.substitute(o,&quot;varying&quot;,&quot;in&quot;).result;let e=&quot;&quot;,t=0;for(;o.includes(`gl_FragData[${t}]`);)o=td.substitute(o,`gl_FragData\\\\[${t}\\\\]`,`fragOutput${t}`).result,e+=`layout(location = ${t}) out vec4 fragOutput${t};\\n`,t++;o=td.substitute(o,&quot;//VTK::Output::Dec&quot;,e).result}return{VSSource:l,FSSource:o,GSSource:td.substitute(r,&quot;//VTK::System::Dec&quot;,s).result}},e.readyShaderProgramArray=(t,n,r)=>{const o=e.replaceShaderValues(t,n,r),a=e.getShaderProgram(o.VSSource,o.FSSource,o.GSSource);return e.readyShaderProgram(a)},e.readyShaderProgram=t=>t&&(t.getCompiled()||t.compileShader())&&e.bindShaderProgram(t)?t:null,e.getShaderProgram=(e,n,r)=>{const o=`${e}${n}${r}`,a=uv.hash(o);if(!(a in t.shaderPrograms)){const o=td.newInstance();return o.setContext(t.context),o.getVertexShader().setSource(e),o.getFragmentShader().setSource(n),r&&o.getGeometryShader().setSource(r),o.setMd5Hash(a),t.shaderPrograms[a]=o,o}return t.shaderPrograms[a]},e.releaseGraphicsResources=n=>{e.releaseCurrentShaderProgram(),Object.keys(t.shaderPrograms).map((e=>t.shaderPrograms[e])).forEach((e=>e.cleanup())),t.shaderPrograms={}},e.releaseCurrentShaderProgram=()=>{t.lastShaderProgramBound&&(t.lastShaderProgramBound.cleanup(),t.lastShaderProgramBound=null)},e.bindShaderProgram=e=>(t.lastShaderProgramBound===e||(t.lastShaderProgramBound&&t.lastShaderProgramBound.release(),e.bind(),t.lastShaderProgramBound=e),1)}(e,t)}var gv={newInstance:Wt.newInstance(fv,&quot;vtkShaderCache&quot;),extend:fv};const{vtkErrorMacro:mv}=Wt,hv={context:null,numberOfTextureUnits:0,textureUnits:0};function vv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,hv,n),Wt.obj(e,t),t.textureUnits=[],Wt.get(e,t,[&quot;numberOfTextureUnits&quot;]),Wt.setGet(e,t,[&quot;context&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLTextureUnitManager&quot;),e.deleteTable=()=>{for(let e=0;e<t.numberOfTextureUnits;++e)!0===t.textureUnits[e]&&mv(&quot;some texture units  were not properly released&quot;);t.textureUnits=[],t.numberOfTextureUnits=0},e.setContext=n=>{if(t.context!==n){if(0!==t.context&&e.deleteTable(),t.context=n,t.context){t.numberOfTextureUnits=n.getParameter(n.MAX_TEXTURE_IMAGE_UNITS);for(let e=0;e<t.numberOfTextureUnits;++e)t.textureUnits[e]=!1}e.modified()}},e.allocate=()=>{for(let n=0;n<t.numberOfTextureUnits;n++)if(!e.isAllocated(n))return t.textureUnits[n]=!0,n;return-1},e.allocateUnit=n=>e.isAllocated(n)?-1:(t.textureUnits[n]=!0,n),e.isAllocated=e=>t.textureUnits[e],e.free=e=>{t.textureUnits[e]=!1},e.freeAll=()=>{for(let e=0;e<t.numberOfTextureUnits;++e)t.textureUnits[e]=!1}}(e,t)}var Tv={newInstance:Wt.newInstance(vv,&quot;vtkOpenGLTextureUnitManager&quot;),extend:vv};const yv={size:void 0,selector:void 0};function bv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,yv,n),t.size||(t.size=[300,300]),Wt.getArray(e,t,[&quot;size&quot;],2),Wt.get(e,t,[&quot;selector&quot;]),qt.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkRenderWindowViewNode&quot;),e.getViewNodeFactory=()=>null,e.getAspectRatio=()=>t.size[0]/t.size[1],e.getAspectRatioForRenderer=e=>{const n=e.getViewportByReference();return t.size[0]*(n[2]-n[0])/((n[3]-n[1])*t.size[1])},e.isInViewport=(t,n,r)=>{const o=r.getViewportByReference(),a=e.getFramebufferSize();return o[0]*a[0]<=t&&o[2]*a[0]>=t&&o[1]*a[1]<=n&&o[3]*a[1]>=n},e.getViewportSize=t=>{const n=t.getViewportByReference(),r=e.getFramebufferSize();return[(n[2]-n[0])*r[0],(n[3]-n[1])*r[1]]},e.getViewportCenter=t=>{const n=e.getViewportSize(t);return[.5*n[0],.5*n[1]]},e.displayToNormalizedDisplay=(t,n,r)=>{const o=e.getFramebufferSize();return[t/o[0],n/o[1],r]},e.normalizedDisplayToDisplay=(t,n,r)=>{const o=e.getFramebufferSize();return[t*o[0],n*o[1],r]},e.worldToView=(e,t,n,r)=>r.worldToView(e,t,n),e.viewToWorld=(e,t,n,r)=>r.viewToWorld(e,t,n),e.worldToDisplay=(t,n,r,o)=>{const a=o.worldToView(t,n,r),i=e.getViewportSize(o),s=o.viewToProjection(a[0],a[1],a[2],i[0]/i[1]),l=o.projectionToNormalizedDisplay(s[0],s[1],s[2]);return e.normalizedDisplayToDisplay(l[0],l[1],l[2])},e.displayToWorld=(t,n,r,o)=>{const a=e.displayToNormalizedDisplay(t,n,r),i=o.normalizedDisplayToProjection(a[0],a[1],a[2]),s=e.getViewportSize(o),l=o.projectionToView(i[0],i[1],i[2],s[0]/s[1]);return o.viewToWorld(l[0],l[1],l[2])},e.normalizedDisplayToViewport=(t,n,r,o)=>{let a=o.getViewportByReference();a=e.normalizedDisplayToDisplay(a[0],a[1],0);const i=e.normalizedDisplayToDisplay(t,n,r);return[i[0]-a[0]-.5,i[1]-a[1]-.5,r]},e.viewportToNormalizedViewport=(t,n,r,o)=>{const a=e.getViewportSize(o);return a&&0!==a[0]&&0!==a[1]?[t/(a[0]-1),n/(a[1]-1),r]:[t,n,r]},e.normalizedViewportToViewport=(t,n,r,o)=>{const a=e.getViewportSize(o);return[t*(a[0]-1),n*(a[1]-1),r]},e.displayToLocalDisplay=(t,n,r)=>[t,e.getFramebufferSize()[1]-n-1,r],e.viewportToNormalizedDisplay=(t,n,r,o)=>{let a=o.getViewportByReference();a=e.normalizedDisplayToDisplay(a[0],a[1],0);const i=t+a[0]+.5,s=n+a[1]+.5;return e.displayToNormalizedDisplay(i,s,r)},e.getComputedDevicePixelRatio=()=>t.size[0]/e.getContainerSize()[0],e.getContainerSize=()=>{Wt.vtkErrorMacro(&quot;not implemented&quot;)},e.getPixelData=(e,t,n,r)=>{Wt.vtkErrorMacro(&quot;not implemented&quot;)},e.createSelector=()=>{Wt.vtkErrorMacro(&quot;not implemented&quot;)}}(e,t)}var xv={newInstance:Wt.newInstance(bv,&quot;vtkRenderWindowViewNode&quot;),extend:bv};const{vtkDebugMacro:Cv,vtkErrorMacro:Sv}=Wt,Av={position:&quot;absolute&quot;,top:0,left:0,width:&quot;100%&quot;,height:&quot;100%&quot;},Iv=[&quot;activateTexture&quot;,&quot;deactivateTexture&quot;,&quot;disableCullFace&quot;,&quot;enableCullFace&quot;,&quot;get3DContext&quot;,&quot;getActiveFramebuffer&quot;,&quot;getContext&quot;,&quot;getDefaultTextureByteSize&quot;,&quot;getDefaultTextureInternalFormat&quot;,&quot;getDefaultToWebgl2&quot;,&quot;getGLInformations&quot;,&quot;getGraphicsMemoryInfo&quot;,&quot;getGraphicsResourceForObject&quot;,&quot;getHardwareMaximumLineWidth&quot;,&quot;getPixelData&quot;,&quot;getShaderCache&quot;,&quot;getTextureUnitForTexture&quot;,&quot;getTextureUnitManager&quot;,&quot;getWebgl2&quot;,&quot;makeCurrent&quot;,&quot;releaseGraphicsResources&quot;,&quot;registerGraphicsResourceUser&quot;,&quot;unregisterGraphicsResourceUser&quot;,&quot;restoreContext&quot;,&quot;setActiveFramebuffer&quot;,&quot;setContext&quot;,&quot;setDefaultToWebgl2&quot;,&quot;setGraphicsResourceForObject&quot;];function wv(e,t,n){const r=e.createFramebuffer(),o=e.createTexture();e.bindTexture(e.TEXTURE_2D,o),e.texImage2D(e.TEXTURE_2D,0,t,2,2,0,t,n,null),e.bindFramebuffer(e.FRAMEBUFFER,r),e.framebufferTexture2D(e.FRAMEBUFFER,e.COLOR_ATTACHMENT0,e.TEXTURE_2D,o,0);const a=e.checkFramebufferStatus(e.FRAMEBUFFER);return e.bindFramebuffer(e.FRAMEBUFFER,null),e.bindTexture(e.TEXTURE_2D,null),a===e.FRAMEBUFFER_COMPLETE}let Ov=0;const Pv=[];function Rv(e){e.preventDefault()}function Mv(e,t){let n;t.classHierarchy.push(&quot;vtkOpenGLRenderWindow&quot;),e.getViewNodeFactory=()=>t.myFactory,t.canvas.addEventListener(&quot;webglcontextlost&quot;,Rv,!1),t.canvas.addEventListener(&quot;webglcontextrestored&quot;,e.restoreContext,!1);const r=[0,0];let o;e.onModified((function(){t.renderable&&(t.size[0]===r[0]&&t.size[1]===r[1]||(r[0]=t.size[0],r[1]=t.size[1],t.canvas.setAttribute(&quot;width&quot;,t.size[0]),t.canvas.setAttribute(&quot;height&quot;,t.size[1]))),t.viewStream&&t.viewStream.setSize(t.size[0],t.size[1]),t.canvas.style.display=t.useOffScreen?&quot;none&quot;:&quot;block&quot;,t.el&&(t.el.style.cursor=t.cursorVisibility?t.cursor:&quot;none&quot;),t.containerSize=null})),e.buildPass=n=>{if(n){if(!t.renderable)return;e.prepareNodes(),e.addMissingNodes(t.renderable.getRenderersByReference()),e.addMissingNodes(t.renderable.getChildRenderWindowsByReference()),e.removeUnusedNodes(),e.initialize(),t.children.forEach((t=>{t.setOpenGLRenderWindow?.(e)}))}},e.initialize=()=>{if(!t.initialized){if(t.rootOpenGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t.rootOpenGLRenderWindow)t.context2D=e.get2DContext();else{t.context=e.get3DContext(),e.resizeFromChildRenderWindows(),t.context&&(Ov++,Pv.forEach((e=>e(Ov)))),t.textureUnitManager=Tv.newInstance(),t.textureUnitManager.setContext(t.context),t.shaderCache.setContext(t.context);const n=t.context;n.blendFuncSeparate(n.SRC_ALPHA,n.ONE_MINUS_SRC_ALPHA,n.ONE,n.ONE_MINUS_SRC_ALPHA),n.depthFunc(n.LEQUAL),n.enable(n.BLEND)}t.initialized=!0}},e.makeCurrent=()=>{t.context.makeCurrent()},e.setContainer=n=>{t.el&&t.el!==n&&(t.canvas.parentNode!==t.el&&Sv(&quot;Error: canvas parent node does not match container&quot;),t.el.removeChild(t.canvas),t.el.contains(t.bgImage)&&t.el.removeChild(t.bgImage)),t.el!==n&&(t.el=n,t.el&&(t.el.appendChild(t.canvas),t.useBackgroundImage&&t.el.appendChild(t.bgImage)),e.modified())},e.getContainer=()=>t.el,e.getContainerSize=()=>{if(!t.containerSize&&t.el){const{width:e,height:n}=t.el.getBoundingClientRect();t.containerSize=[e,n]}return t.containerSize||t.size},e.getFramebufferSize=()=>{const e=t.activeFramebuffer?.getSize();return e||t.size},e.getPixelData=(e,n,r,o)=>{const a=new Uint8Array((r-e+1)*(o-n+1)*4);return t.context.readPixels(e,n,r-e+1,o-n+1,t.context.RGBA,t.context.UNSIGNED_BYTE,a),a},e.get3DContext=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{preserveDrawingBuffer:!1,depth:!0,alpha:!0,powerPreference:&quot;high-performance&quot;},r=null;const o=&quot;undefined&quot;!=typeof WebGL2RenderingContext;return t.webgl2=!1,t.defaultToWebgl2&&o&&(r=t.canvas.getContext(&quot;webgl2&quot;,e),r&&(t.webgl2=!0,Cv(&quot;using webgl2&quot;))),r||(Cv(&quot;using webgl1&quot;),r=t.canvas.getContext(&quot;webgl&quot;,e)||t.canvas.getContext(&quot;experimental-webgl&quot;,e)),new Proxy(r,(n||(n=function(){const e=new Map,t={apply(t,n,r){return e.has(r[0])?e.get(r[0]):t.apply(n,r)}},n=Object.create(null);return n.getParameter=(e,n,r,o)=>new Proxy(o.bind(e),t),n.depthMask=(t,n,r,o)=>{return new Proxy(o.bind(t),(a=t.DEPTH_WRITEMASK,{apply(t,n,r){return e.set(a,r[0]),t.apply(n,r)}}));var a},{get(e,t,r){if(&quot;__getUnderlyingContext&quot;===t)return()=>e;let o=Reflect.get(e,t,e);o instanceof Function&&(o=o.bind(e));const a=n[t];return a?a(e,t,r,o):o}}}()),n))},e.get2DContext=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};return t.canvas.getContext(&quot;2d&quot;,e)},e.restoreContext=()=>{const t=ev.newInstance();t.setCurrentOperation(&quot;Release&quot;),t.traverse(e,null)},e.activateTexture=n=>{const r=t._textureResourceIds.get(n);if(void 0!==r)return void t.context.activeTexture(t.context.TEXTURE0+r);const o=e.getTextureUnitManager().allocate();o<0?Sv(&quot;Hardware does not support the number of textures defined.&quot;):(t._textureResourceIds.set(n,o),t.context.activeTexture(t.context.TEXTURE0+o))},e.deactivateTexture=n=>{const r=t._textureResourceIds.get(n);void 0!==r&&(e.getTextureUnitManager().free(r),t._textureResourceIds.delete(n))},e.getTextureUnitForTexture=e=>{const n=t._textureResourceIds.get(e);return void 0!==n?n:-1},e.getDefaultTextureByteSize=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,r=arguments.length>2&&void 0!==arguments[2]&&arguments[2];if(t.webgl2)switch(e){case cs.CHAR:case cs.SIGNED_CHAR:case cs.UNSIGNED_CHAR:return 1;case n:case r:case cs.UNSIGNED_SHORT:case cs.SHORT:case cs.VOID:return 2;default:return 4}return 1},e.getDefaultTextureInternalFormat=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null,o=arguments.length>3&&void 0!==arguments[3]&&arguments[3];if(t.webgl2)switch(e){case cs.UNSIGNED_CHAR:switch(n){case 1:return t.context.R8;case 2:return t.context.RG8;case 3:return t.context.RGB8;default:return t.context.RGBA8}case r&&!o&&cs.UNSIGNED_SHORT:switch(n){case 1:return r.R16_EXT;case 2:return r.RG16_EXT;case 3:return r.RGB16_EXT;default:return r.RGBA16_EXT}case r&&!o&&cs.SHORT:switch(n){case 1:return r.R16_SNORM_EXT;case 2:return r.RG16_SNORM_EXT;case 3:return r.RGB16_SNORM_EXT;default:return r.RGBA16_SNORM_EXT}default:switch(n){case 1:return o?t.context.R16F:t.context.R32F;case 2:return o?t.context.RG16F:t.context.RG32F;case 3:return o?t.context.RGB16F:t.context.RGB32F;default:return o?t.context.RGBA16F:t.context.RGBA32F}}switch(n){case 1:return t.context.LUMINANCE;case 2:return t.context.LUMINANCE_ALPHA;case 3:return t.context.RGB;default:return t.context.RGBA}},e.setBackgroundImage=e=>{t.bgImage.src=e.src},e.setUseBackgroundImage=e=>{t.useBackgroundImage=e,t.useBackgroundImage&&!t.el.contains(t.bgImage)?t.el.appendChild(t.bgImage):!t.useBackgroundImage&&t.el.contains(t.bgImage)&&t.el.removeChild(t.bgImage)},e.captureNextImage=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;image/png&quot;,{resetCamera:r=!1,size:o=null,scale:a=1}=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(t.deleted)return null;t.imageFormat=n;const i=t.notifyStartCaptureImage;return t.notifyStartCaptureImage=!0,t._screenshot={size:o||1!==a?o||t.size.map((e=>e*a)):null},new Promise(((n,o)=>{const a=e.onImageReady((o=>{if(null===t._screenshot.size)t.notifyStartCaptureImage=i,a.unsubscribe(),t._screenshot.placeHolder&&(t.size=t._screenshot.originalSize,e.modified(),t._screenshot.cameras&&t._screenshot.cameras.forEach((e=>{let{restoreParamsFn:t,arg:n}=e;return t(n)})),e.traverseAllPasses(),t.el.removeChild(t._screenshot.placeHolder),t._screenshot.placeHolder.remove(),t._screenshot=null),n(o);else{const n=document.createElement(&quot;img&quot;);if(n.style=Av,n.src=o,t._screenshot.placeHolder=t.el.appendChild(n),t.canvas.style.display=&quot;none&quot;,t._screenshot.originalSize=t.size,t.size=t._screenshot.size,t.rootOpenGLRenderWindow?.resizeFromChildRenderWindows(),t._screenshot.size=null,e.modified(),r){const e=!0!==r;t._screenshot.cameras=t.renderable.getRenderers().map((t=>{const n=t.getActiveCamera(),o=n.get(&quot;focalPoint&quot;,&quot;position&quot;,&quot;parallelScale&quot;);return{resetCameraArgs:e?{renderer:t}:void 0,resetCameraFn:e?r:t.resetCamera,restoreParamsFn:n.set,arg:JSON.parse(JSON.stringify(o))}})),t._screenshot.cameras.forEach((e=>{let{resetCameraFn:t,resetCameraArgs:n}=e;return t(n)}))}e.traverseAllPasses()}}))}))},e.getHardwareMaximumLineWidth=()=>{if(null!=o)return o;const t=e.get3DContext(),n=t.getParameter(t.ALIASED_LINE_WIDTH_RANGE);return o=n[1],n[1]},e.getGLInformations=()=>{if(t._glInformation)return t._glInformation;const n=e.get3DContext(),r=n.getExtension(&quot;OES_texture_float&quot;),o=n.getExtension(&quot;OES_texture_half_float&quot;),a=n.getExtension(&quot;WEBGL_debug_renderer_info&quot;),i=n.getExtension(&quot;WEBGL_draw_buffers&quot;),s=n.getExtension(&quot;EXT_texture_filter_anisotropic&quot;)||n.getExtension(&quot;WEBKIT_EXT_texture_filter_anisotropic&quot;),l=[[&quot;Max Vertex Attributes&quot;,&quot;MAX_VERTEX_ATTRIBS&quot;,n.getParameter(n.MAX_VERTEX_ATTRIBS)],[&quot;Max Varying Vectors&quot;,&quot;MAX_VARYING_VECTORS&quot;,n.getParameter(n.MAX_VARYING_VECTORS)],[&quot;Max Vertex Uniform Vectors&quot;,&quot;MAX_VERTEX_UNIFORM_VECTORS&quot;,n.getParameter(n.MAX_VERTEX_UNIFORM_VECTORS)],[&quot;Max Fragment Uniform Vectors&quot;,&quot;MAX_FRAGMENT_UNIFORM_VECTORS&quot;,n.getParameter(n.MAX_FRAGMENT_UNIFORM_VECTORS)],[&quot;Max Fragment Texture Image Units&quot;,&quot;MAX_TEXTURE_IMAGE_UNITS&quot;,n.getParameter(n.MAX_TEXTURE_IMAGE_UNITS)],[&quot;Max Vertex Texture Image Units&quot;,&quot;MAX_VERTEX_TEXTURE_IMAGE_UNITS&quot;,n.getParameter(n.MAX_VERTEX_TEXTURE_IMAGE_UNITS)],[&quot;Max Combined Texture Image Units&quot;,&quot;MAX_COMBINED_TEXTURE_IMAGE_UNITS&quot;,n.getParameter(n.MAX_COMBINED_TEXTURE_IMAGE_UNITS)],[&quot;Max 2D Texture Size&quot;,&quot;MAX_TEXTURE_SIZE&quot;,n.getParameter(n.MAX_TEXTURE_SIZE)],[&quot;Max Cube Texture Size&quot;,&quot;MAX_CUBE_MAP_TEXTURE_SIZE&quot;,n.getParameter(n.MAX_CUBE_MAP_TEXTURE_SIZE)],[&quot;Max Texture Anisotropy&quot;,&quot;MAX_TEXTURE_MAX_ANISOTROPY_EXT&quot;,s&&n.getParameter(s.MAX_TEXTURE_MAX_ANISOTROPY_EXT)],[&quot;Point Size Range&quot;,&quot;ALIASED_POINT_SIZE_RANGE&quot;,n.getParameter(n.ALIASED_POINT_SIZE_RANGE).join(&quot; - &quot;)],[&quot;Line Width Range&quot;,&quot;ALIASED_LINE_WIDTH_RANGE&quot;,n.getParameter(n.ALIASED_LINE_WIDTH_RANGE).join(&quot; - &quot;)],[&quot;Max Viewport Dimensions&quot;,&quot;MAX_VIEWPORT_DIMS&quot;,n.getParameter(n.MAX_VIEWPORT_DIMS).join(&quot; - &quot;)],[&quot;Max Renderbuffer Size&quot;,&quot;MAX_RENDERBUFFER_SIZE&quot;,n.getParameter(n.MAX_RENDERBUFFER_SIZE)],[&quot;Framebuffer Red Bits&quot;,&quot;RED_BITS&quot;,n.getParameter(n.RED_BITS)],[&quot;Framebuffer Green Bits&quot;,&quot;GREEN_BITS&quot;,n.getParameter(n.GREEN_BITS)],[&quot;Framebuffer Blue Bits&quot;,&quot;BLUE_BITS&quot;,n.getParameter(n.BLUE_BITS)],[&quot;Framebuffer Alpha Bits&quot;,&quot;ALPHA_BITS&quot;,n.getParameter(n.ALPHA_BITS)],[&quot;Framebuffer Depth Bits&quot;,&quot;DEPTH_BITS&quot;,n.getParameter(n.DEPTH_BITS)],[&quot;Framebuffer Stencil Bits&quot;,&quot;STENCIL_BITS&quot;,n.getParameter(n.STENCIL_BITS)],[&quot;Framebuffer Subpixel Bits&quot;,&quot;SUBPIXEL_BITS&quot;,n.getParameter(n.SUBPIXEL_BITS)],[&quot;MSAA Samples&quot;,&quot;SAMPLES&quot;,n.getParameter(n.SAMPLES)],[&quot;MSAA Sample Buffers&quot;,&quot;SAMPLE_BUFFERS&quot;,n.getParameter(n.SAMPLE_BUFFERS)],[&quot;Supported Formats for UByte Render Targets     &quot;,&quot;UNSIGNED_BYTE RENDER TARGET FORMATS&quot;,[r&&wv(n,n.RGBA,n.UNSIGNED_BYTE)?&quot;RGBA&quot;:&quot;&quot;,r&&wv(n,n.RGB,n.UNSIGNED_BYTE)?&quot;RGB&quot;:&quot;&quot;,r&&wv(n,n.LUMINANCE,n.UNSIGNED_BYTE)?&quot;LUMINANCE&quot;:&quot;&quot;,r&&wv(n,n.ALPHA,n.UNSIGNED_BYTE)?&quot;ALPHA&quot;:&quot;&quot;,r&&wv(n,n.LUMINANCE_ALPHA,n.UNSIGNED_BYTE)?&quot;LUMINANCE_ALPHA&quot;:&quot;&quot;].join(&quot; &quot;)],[&quot;Supported Formats for Half Float Render Targets&quot;,&quot;HALF FLOAT RENDER TARGET FORMATS&quot;,[o&&wv(n,n.RGBA,o.HALF_FLOAT_OES)?&quot;RGBA&quot;:&quot;&quot;,o&&wv(n,n.RGB,o.HALF_FLOAT_OES)?&quot;RGB&quot;:&quot;&quot;,o&&wv(n,n.LUMINANCE,o.HALF_FLOAT_OES)?&quot;LUMINANCE&quot;:&quot;&quot;,o&&wv(n,n.ALPHA,o.HALF_FLOAT_OES)?&quot;ALPHA&quot;:&quot;&quot;,o&&wv(n,n.LUMINANCE_ALPHA,o.HALF_FLOAT_OES)?&quot;LUMINANCE_ALPHA&quot;:&quot;&quot;].join(&quot; &quot;)],[&quot;Supported Formats for Full Float Render Targets&quot;,&quot;FLOAT RENDER TARGET FORMATS&quot;,[r&&wv(n,n.RGBA,n.FLOAT)?&quot;RGBA&quot;:&quot;&quot;,r&&wv(n,n.RGB,n.FLOAT)?&quot;RGB&quot;:&quot;&quot;,r&&wv(n,n.LUMINANCE,n.FLOAT)?&quot;LUMINANCE&quot;:&quot;&quot;,r&&wv(n,n.ALPHA,n.FLOAT)?&quot;ALPHA&quot;:&quot;&quot;,r&&wv(n,n.LUMINANCE_ALPHA,n.FLOAT)?&quot;LUMINANCE_ALPHA&quot;:&quot;&quot;].join(&quot; &quot;)],[&quot;Max Multiple Render Targets Buffers&quot;,&quot;MAX_DRAW_BUFFERS_WEBGL&quot;,i?n.getParameter(i.MAX_DRAW_BUFFERS_WEBGL):0],[&quot;High Float Precision in Vertex Shader&quot;,&quot;HIGH_FLOAT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Medium Float Precision in Vertex Shader&quot;,&quot;MEDIUM_FLOAT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Low Float Precision in Vertex Shader&quot;,&quot;LOW_FLOAT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;High Float Precision in Fragment Shader&quot;,&quot;HIGH_FLOAT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Medium Float Precision in Fragment Shader&quot;,&quot;MEDIUM_FLOAT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Low Float Precision in Fragment Shader&quot;,&quot;LOW_FLOAT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;High Int Precision in Vertex Shader&quot;,&quot;HIGH_INT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Medium Int Precision in Vertex Shader&quot;,&quot;MEDIUM_INT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Low Int Precision in Vertex Shader&quot;,&quot;LOW_INT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;High Int Precision in Fragment Shader&quot;,&quot;HIGH_INT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Medium Int Precision in Fragment Shader&quot;,&quot;MEDIUM_INT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Low Int Precision in Fragment Shader&quot;,&quot;LOW_INT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Supported Extensions&quot;,&quot;EXTENSIONS&quot;,n.getSupportedExtensions().join(&quot;<br/>\\t\\t\\t\\t\\t    &quot;)],[&quot;WebGL Renderer&quot;,&quot;RENDERER&quot;,n.getParameter(n.RENDERER)],[&quot;WebGL Vendor&quot;,&quot;VENDOR&quot;,n.getParameter(n.VENDOR)],[&quot;WebGL Version&quot;,&quot;VERSION&quot;,n.getParameter(n.VERSION)],[&quot;Shading Language Version&quot;,&quot;SHADING_LANGUAGE_VERSION&quot;,n.getParameter(n.SHADING_LANGUAGE_VERSION)],[&quot;Unmasked Renderer&quot;,&quot;UNMASKED_RENDERER&quot;,a&&n.getParameter(a.UNMASKED_RENDERER_WEBGL)],[&quot;Unmasked Vendor&quot;,&quot;UNMASKED_VENDOR&quot;,a&&n.getParameter(a.UNMASKED_VENDOR_WEBGL)],[&quot;WebGL Version&quot;,&quot;WEBGL_VERSION&quot;,t.webgl2?2:1]],c={};for(;l.length;){const[e,t,n]=l.pop();t&&(c[t]={label:e,value:n})}return t._glInformation=c,c},e.traverseAllPasses=()=>{if(t.renderPasses)for(let n=0;n<t.renderPasses.length;++n)t.renderPasses[n].traverse(e,null);e.copyParentContent(),t.notifyStartCaptureImage&&function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:t.imageFormat;const r=document.createElement(&quot;canvas&quot;),o=r.getContext(&quot;2d&quot;);r.width=t.canvas.width,r.height=t.canvas.height,o.drawImage(t.canvas,0,0);const a=t.canvas.getBoundingClientRect();t.renderable.getRenderers().forEach((e=>{e.getViewProps().forEach((e=>{if(e.getContainer){const t=e.getContainer().getElementsByTagName(&quot;canvas&quot;);for(let e=0;e<t.length;e++){const n=t[e],r=n.getBoundingClientRect(),i=r.x-a.x,s=r.y-a.y;o.drawImage(n,i,s)}}}))}));const i=r.toDataURL(n);r.remove(),e.invokeImageReady(i)}();const n=t.renderable.getChildRenderWindowsByReference();for(let t=0;t<n.length;++t)e.getViewNodeFor(n[t])?.traverseAllPasses()},e.copyParentContent=()=>{const e=t.rootOpenGLRenderWindow;if(!e||!t.context2D||t.children.some((e=>!!e.getSelector?.())))return;const n=e.getCanvas(),r=t.canvas;t.context2D.drawImage(n,0,n.height-r.height,r.width,r.height,0,0,r.width,r.height)},e.resizeFromChildRenderWindows=()=>{const n=t.renderable.getChildRenderWindowsByReference();if(n.length>0){const t=[0,0];for(let r=0;r<n.length;++r){const o=e.getViewNodeFor(n[r])?.getSize();o&&(t[0]=o[0]>t[0]?o[0]:t[0],t[1]=o[1]>t[1]?o[1]:t[1])}e.setSize(...t)}},e.disableCullFace=()=>{t.cullFaceEnabled&&(t.context.disable(t.context.CULL_FACE),t.cullFaceEnabled=!1)},e.enableCullFace=()=>{t.cullFaceEnabled||(t.context.enable(t.context.CULL_FACE),t.cullFaceEnabled=!0)},e.setViewStream=n=>t.viewStream!==n&&(t.subscription&&(t.subscription.unsubscribe(),t.subscription=null),t.viewStream=n,t.viewStream&&(t.renderable.getRenderers()[0].getBackgroundByReference()[3]=0,e.setUseBackgroundImage(!0),t.subscription=t.viewStream.onImageReady((t=>e.setBackgroundImage(t.image))),t.viewStream.setSize(t.size[0],t.size[1]),t.viewStream.invalidateCache(),t.viewStream.render(),e.modified()),!0),e.createSelector=()=>{const t=Gp.newInstance();return t.setOpenGLRenderWindow(e),t},e.delete=Wt.chain((()=>{t.context&&(Ov--,Pv.forEach((e=>e(Ov)))),e.setContainer(),e.setViewStream()}),(function(){t.canvas.removeEventListener(&quot;webglcontextlost&quot;,Rv),t.canvas.removeEventListener(&quot;webglcontextrestored&quot;,e.restoreContext)}),e.delete),e.setActiveFramebuffer=e=>{t.activeFramebuffer=e};const a=e.setSize;e.setSize=(t,n)=>{const r=a(t,n);return r&&e.invokeWindowResizeEvent({width:t,height:n}),r},e.registerGraphicsResourceUser=(n,r)=>{t._graphicsResources.has(n)||e.setGraphicsResourceForObject(n,null,null);const o=t._graphicsResources.get(n);o?.users.add(r)},e.unregisterGraphicsResourceUser=(n,r)=>{const o=t._graphicsResources.get(n);o&&(o.users.delete(r),o.users.size||(o.oglObject?.releaseGraphicsResources(e),t._graphicsResources.delete(n)))},e.getGraphicsResourceForObject=e=>t._graphicsResources.get(e),e.setGraphicsResourceForObject=(n,r,o)=>{if(!n)return;const a=t._graphicsResources.get(n);a?.oglObject?.releaseGraphicsResources(e),t._graphicsResources.set(n,{coreObject:n,oglObject:r,hash:o,users:a?.users??new Set})},e.getGraphicsMemoryInfo=()=>{let e=0;return t._graphicsResources.forEach((t=>{let{oglObject:n}=t;e+=n.getAllocatedGPUMemoryInBytes()})),e},e.releaseGraphicsResources=()=>{null!==t.shaderCache&&t.shaderCache.releaseGraphicsResources(e),t._graphicsResources.forEach((t=>{let{oglObject:n}=t;n.releaseGraphicsResources(e)})),t._graphicsResources.clear(),null!==t.textureUnitManager&&t.textureUnitManager.freeAll(),t.renderable.getRenderersByReference().forEach((t=>{const n=e.getViewNodeFor(t);n?.releaseGraphicsResources()}))};const i={...e};Iv.forEach((n=>{e[n]=function(){return t.rootOpenGLRenderWindow?t.rootOpenGLRenderWindow[n](...arguments):i[n](...arguments)}}))}const Ev={cullFaceEnabled:!1,shaderCache:null,initialized:!1,context:null,context2D:null,canvas:null,cursorVisibility:!0,cursor:&quot;pointer&quot;,textureUnitManager:null,textureResourceIds:null,containerSize:null,renderPasses:[],notifyStartCaptureImage:!1,webgl2:!1,defaultToWebgl2:!0,activeFramebuffer:null,imageFormat:&quot;image/png&quot;,useOffScreen:!1,useBackgroundImage:!1};const Vv=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ev,n),xv.extend(e,t,n),t.canvas||(t.canvas=document.createElement(&quot;canvas&quot;),t.canvas.style.width=&quot;100%&quot;),t.selector||(t.selector=Gp.newInstance(),t.selector.setOpenGLRenderWindow(e)),t.bgImage=new Image,t.bgImage.style.position=&quot;absolute&quot;,t.bgImage.style.left=&quot;0&quot;,t.bgImage.style.top=&quot;0&quot;,t.bgImage.style.width=&quot;100%&quot;,t.bgImage.style.height=&quot;100%&quot;,t.bgImage.style.zIndex=&quot;-1&quot;,t._textureResourceIds=new Map,t._graphicsResources=new Map,t._glInformation=null,t.myFactory=nn.newInstance(),t.shaderCache=gv.newInstance(),t.shaderCache.setOpenGLRenderWindow(e),t.renderPasses[0]=cv.newInstance(),Wt.get(e,t,[&quot;shaderCache&quot;,&quot;textureUnitManager&quot;,&quot;webgl2&quot;,&quot;useBackgroundImage&quot;,&quot;activeFramebuffer&quot;,&quot;rootOpenGLRenderWindow&quot;]),Wt.setGet(e,t,[&quot;initialized&quot;,&quot;context&quot;,&quot;context2D&quot;,&quot;canvas&quot;,&quot;renderPasses&quot;,&quot;notifyStartCaptureImage&quot;,&quot;defaultToWebgl2&quot;,&quot;cursor&quot;,&quot;useOffScreen&quot;]),Wt.setGetArray(e,t,[&quot;size&quot;],2),Wt.event(e,t,&quot;imageReady&quot;),Wt.event(e,t,&quot;windowResizeEvent&quot;),Mv(e,t)}),&quot;vtkOpenGLRenderWindow&quot;);ph(&quot;WebGL&quot;,Vv),Jt(&quot;vtkRenderWindow&quot;,Vv);const Dv={device:null,handle:null};function Lv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Dv,n),Wt.obj(e,t),Wt.get(e,t,[&quot;lastCameraMTime&quot;]),Wt.setGet(e,t,[&quot;device&quot;,&quot;handle&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUShaderModule&quot;),e.initialize=(e,n)=>{t.device=e,t.handle=t.device.getHandle().createShaderModule({code:n.getCode()})}}(e,t)}var Bv={newInstance:Wt.newInstance(Lv,&quot;vtkWebGPUShaderModule&quot;),extend:Lv};const Nv={shaderModules:null,device:null,window:null};function Fv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Nv,n),t._shaderModules=new Map,Wt.obj(e,t),Wt.setGet(e,t,[&quot;device&quot;,&quot;window&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUShaderCache&quot;),e.getShaderModule=e=>{const n=e.getType(),r=e.getHash(),o=t._shaderModules.keys();for(let e=0;e<o.length;e++){const a=o[e];if(a.getHash()===r&&a.getType()===n)return t._shaderModules.get(a)}const a=Bv.newInstance();return a.initialize(t.device,e),t._shaderModules.set(e,a),a}}(e,t)}var _v={newInstance:Wt.newInstance(Fv,&quot;vtkWebGPUShaderCache&quot;),extend:Fv,substitute:function(e,t,n){let r=!(arguments.length>3&&void 0!==arguments[3])||arguments[3];const o=Array.isArray(n)?n.join(&quot;\\n&quot;):n;let a=!1;-1!==e.search(t)&&(a=!0);let i=&quot;&quot;;r&&(i=&quot;g&quot;);const s=new RegExp(t,i);return{replace:a,result:e.replace(s,o)}}};const kv={device:null,handle:null,label:null};function Gv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,kv,n),Wt.obj(e,t),t.bindables=[],t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),Wt.get(e,t,[&quot;bindGroupTime&quot;,&quot;handle&quot;,&quot;sizeInBytes&quot;,&quot;usage&quot;]),Wt.setGet(e,t,[&quot;label&quot;,&quot;device&quot;,&quot;arrayInformation&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUBindGroup&quot;),e.setBindables=n=>{if(t.bindables.length===n.length){let e=!0;for(let r=0;r<t.bindables.length;r++)t.bindables[r]!==n[r]&&(e=!1);if(e)return}t.bindables=n,e.modified()},e.getBindGroupLayout=e=>{const n=[];for(let e=0;e<t.bindables.length;e++){const r=t.bindables[e].getBindGroupLayoutEntry();r.binding=e,n.push(r)}return e.getBindGroupLayout({entries:n})},e.getBindGroup=n=>{let r=e.getMTime();for(let e=0;e<t.bindables.length;e++){const n=t.bindables[e].getBindGroupTime().getMTime();r=n>r?n:r}if(r<t.bindGroupTime.getMTime())return t.bindGroup;const o=[];for(let e=0;e<t.bindables.length;e++){const n=t.bindables[e].getBindGroupEntry();n.binding=e,o.push(n)}return t.bindGroup=n.getHandle().createBindGroup({layout:e.getBindGroupLayout(n),entries:o,label:t.label}),t.bindGroupTime.modified(),t.bindGroup},e.getShaderCode=e=>{const n=[],r=e.getBindGroupLayoutCount(t.label);for(let e=0;e<t.bindables.length;e++)n.push(t.bindables[e].getShaderCode(e,r));return n.join(&quot;\\n&quot;)}}(e,t)}var Uv={newInstance:Wt.newInstance(Gv),extend:Gv};const zv={handle:null,layouts:null,renderEncoder:null,shaderDescriptions:null,vertexState:null,topology:null,pipelineDescription:null};function Wv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,zv,n),ht(e,t),t.layouts=[],t.shaderDescriptions=[],Tt(e,t,[&quot;handle&quot;,&quot;pipelineDescription&quot;]),Ct(e,t,[&quot;device&quot;,&quot;renderEncoder&quot;,&quot;topology&quot;,&quot;vertexState&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUPipeline&quot;),e.getShaderDescriptions=()=>t.shaderDescriptions,e.initialize=(e,n)=>{t.pipelineDescription=t.renderEncoder.getPipelineSettings(),t.pipelineDescription.primitive.topology=t.topology,t.pipelineDescription.vertex=t.vertexState,t.pipelineDescription.label=n;const r=[];for(let e=0;e<t.layouts.length;e++)r.push(t.layouts[e].layout);t.pipelineLayout=e.getHandle().createPipelineLayout({bindGroupLayouts:r}),t.pipelineDescription.layout=t.pipelineLayout;for(let n=0;n<t.shaderDescriptions.length;n++){const r=t.shaderDescriptions[n],o=e.getShaderModule(r);&quot;vertex&quot;===r.getType()&&(t.pipelineDescription.vertex.module=o.getHandle(),t.pipelineDescription.vertex.entryPoint=&quot;main&quot;),&quot;fragment&quot;===r.getType()&&(t.pipelineDescription.fragment.module=o.getHandle(),t.pipelineDescription.fragment.entryPoint=&quot;main&quot;)}t.handle=e.getHandle().createRenderPipeline(t.pipelineDescription)},e.getShaderDescription=e=>{for(let n=0;n<t.shaderDescriptions.length;n++)if(t.shaderDescriptions[n].getType()===e)return t.shaderDescriptions[n];return null},e.addBindGroupLayout=e=>{e&&t.layouts.push({layout:e.getBindGroupLayout(t.device),label:e.getLabel()})},e.getBindGroupLayout=e=>t.layouts[e].layout,e.getBindGroupLayoutCount=e=>{for(let n=0;n<t.layouts.length;n++)if(t.layouts[n].label===e)return n;return 0},e.bindVertexInput=(e,t)=>{t.bindBuffers(e)}}(e,t)}var Hv={newInstance:Mt(Wv,&quot;vtkWebGPUPipeline&quot;),extend:Wv};const jv={type:null,hash:null,code:null,outputNames:null,outputTypes:null};function Kv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,jv,n),t.outputNames=[],t.outputTypes=[],t.outputInterpolations=[],t.builtinOutputNames=[],t.builtinOutputTypes=[],t.builtinInputNames=[],t.builtinInputTypes=[],Wt.obj(e,t),Wt.setGet(e,t,[&quot;type&quot;,&quot;hash&quot;,&quot;code&quot;]),Wt.getArray(e,t,[&quot;outputTypes&quot;,&quot;outputNames&quot;,&quot;outputInterpolations&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUShaderDescription&quot;),e.hasOutput=e=>t.outputNames.includes(e),e.addOutput=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:void 0;t.outputTypes.push(e),t.outputNames.push(n),t.outputInterpolations.push(r)},e.addBuiltinOutput=(e,n)=>{t.builtinOutputTypes.push(e),t.builtinOutputNames.push(n)},e.addBuiltinInput=(e,n)=>{t.builtinInputTypes.push(e),t.builtinInputNames.push(n)},e.replaceShaderCode=(e,n)=>{const r=[];let o=[];if(n&&r.push(n.getShaderCode()),e||t.builtinInputNames.length){const n=[];if(n.push(`struct ${t.type}Input\\n{`),e){const t=e.getOutputNamesByReference(),r=e.getOutputTypesByReference(),o=e.getOutputInterpolationsByReference();for(let e=0;e<t.length;e++)void 0!==o[e]?n.push(`  @location(${e}) @interpolate(${o[e]}) ${t[e]} : ${r[e]},`):n.push(`  @location(${e}) ${t[e]} : ${r[e]},`)}for(let e=0;e<t.builtinInputNames.length;e++)n.push(`  ${t.builtinInputNames[e]} : ${t.builtinInputTypes[e]},`);n.length>1&&(n.push(&quot;};&quot;),o=n,r[r.length-1]+=&quot;,&quot;,r.push(`input: ${t.type}Input`))}if(r.length&&(t.code=_v.substitute(t.code,&quot;//VTK::IOStructs::Input&quot;,r).result),t.outputNames.length+t.builtinOutputNames.length){const e=[`struct ${t.type}Output\\n{`];for(let n=0;n<t.outputNames.length;n++)void 0!==t.outputInterpolations[n]?e.push(`  @location(${n}) @interpolate(${t.outputInterpolations[n]}) ${t.outputNames[n]} : ${t.outputTypes[n]},`):e.push(`  @location(${n}) ${t.outputNames[n]} : ${t.outputTypes[n]},`);for(let n=0;n<t.builtinOutputNames.length;n++)e.push(`  ${t.builtinOutputNames[n]} : ${t.builtinOutputTypes[n]},`);e.push(&quot;};&quot;),o=o.concat(e),t.code=_v.substitute(t.code,&quot;//VTK::IOStructs::Output&quot;,[`-> ${t.type}Output`]).result}t.code=_v.substitute(t.code,&quot;//VTK::IOStructs::Dec&quot;,o).result}}(e,t)}var $v={newInstance:Wt.newInstance(Kv,&quot;vtkWebGPUShaderDescription&quot;),extend:Kv};const qv={r8unorm:{numComponents:1,nativeType:Uint8Array,stride:1,elementSize:1,sampleType:&quot;float&quot;},r8snorm:{numComponents:1,nativeType:Int8Array,stride:1,elementSize:1,sampleType:&quot;float&quot;},r8uint:{numComponents:1,nativeType:Uint8Array,stride:1,elementSize:1,sampleType:&quot;uint&quot;},r8sint:{numComponents:1,nativeType:Int8Array,stride:1,elementSize:1,sampleType:&quot;sint&quot;},r16uint:{numComponents:1,nativeType:Uint16Array,stride:2,elementSize:2,sampleType:&quot;uint&quot;},r16sint:{numComponents:1,nativeType:Int16Array,stride:2,elementSize:2,sampleType:&quot;sint&quot;},r16float:{numComponents:1,nativeType:Float32Array,stride:2,elementSize:2,sampleType:&quot;float&quot;},rg8unorm:{numComponents:2,nativeType:Uint8Array,stride:2,elementSize:1,sampleType:&quot;float&quot;},rg8snorm:{numComponents:2,nativeType:Int8Array,stride:2,elementSize:1,sampleType:&quot;float&quot;},rg8uint:{numComponents:2,nativeType:Uint8Array,stride:2,elementSize:1,sampleType:&quot;uint&quot;},rg8sint:{numComponents:2,nativeType:Int8Array,stride:2,elementSize:1,sampleType:&quot;sint&quot;},r32uint:{numComponents:1,nativeType:Uint32Array,stride:4,elementSize:4,sampleType:&quot;uint&quot;},r32sint:{numComponents:1,nativeType:Int32Array,stride:4,elementSize:4,sampleType:&quot;sint&quot;},r32float:{numComponents:1,nativeType:Float32Array,stride:4,elementSize:4,sampleType:&quot;unfilterable-float&quot;},rg16uint:{numComponents:2,nativeType:Uint16Array,stride:4,elementSize:2,sampleType:&quot;uint&quot;},rg16sint:{numComponents:2,nativeType:Int16Array,stride:4,elementSize:2,sampleType:&quot;sint&quot;},rg16float:{numComponents:2,nativeType:Float32Array,stride:4,elementSize:2,sampleType:&quot;float&quot;},rgba8unorm:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},&quot;rgba8unorm-srgb&quot;:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},rgba8snorm:{numComponents:4,nativeType:Int8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},rgba8uint:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;uint&quot;},rgba8sint:{numComponents:4,nativeType:Int8Array,stride:4,elementSize:1,sampleType:&quot;sint&quot;},bgra8unorm:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},&quot;bgra8unorm-srgb&quot;:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},rgb9e5ufloat:{numComponents:4,nativeType:Uint32Array,stride:4,sampleType:&quot;float&quot;},rgb10a2unorm:{numComponents:4,nativeType:Uint32Array,stride:4,sampleType:&quot;float&quot;},rg11b10ufloat:{numComponents:4,nativeType:Float32Array,stride:4,sampleType:&quot;float&quot;},rg32uint:{numComponents:2,nativeType:Uint32Array,stride:8,elementSize:4,sampleType:&quot;uint&quot;},rg32sint:{numComponents:2,nativeType:Int32Array,stride:8,elementSize:4,sampleType:&quot;sint&quot;},rg32float:{numComponents:2,nativeType:Float32Array,stride:8,elementSize:4,sampleType:&quot;unfilterable-float&quot;},rgba16uint:{numComponents:4,nativeType:Uint16Array,stride:8,elementSize:2,sampleType:&quot;uint&quot;},rgba16sint:{numComponents:4,nativeType:Int16Array,stride:8,elementSize:2,sampleType:&quot;sint&quot;},rgba16float:{numComponents:4,nativeType:Float32Array,stride:8,elementSize:2,sampleType:&quot;float&quot;},rgba32uint:{numComponents:4,nativeType:Uint32Array,stride:16,elementSize:4,sampleType:&quot;uint&quot;},rgba32sint:{numComponents:4,nativeType:Int32Array,stride:16,elementSize:4,sampleType:&quot;sint&quot;},rgba32float:{numComponents:4,nativeType:Float32Array,stride:16,elementSize:4,sampleType:&quot;unfilterable-float&quot;},stencil8:{numComponents:1,nativeType:Uint8Array,stride:1,elementSize:1,sampleType:&quot;uint&quot;},depth16unorm:{numComponents:1,nativeType:Uint16Array,stride:2,elementSize:2,sampleType:&quot;depth&quot;},depth24plus:{numComponents:1,nativeType:Uint32Array,stride:4,elementSize:3,sampleType:&quot;depth&quot;},&quot;depth24plus-stencil8&quot;:{numComponents:2,nativeType:Uint32Array,stride:4,sampleType:&quot;mixed&quot;},depth32float:{numComponents:1,nativeType:Float32Array,stride:4,elementSize:4,sampleType:&quot;depth&quot;}};var Xv=function(e){return!e||e.length<6?0:e in qv==1?qv[e]:(et(`unknown format ${e}`),null)},Yv=function(e){if(!e||e.length<5)return 0;let t=1;&quot;x&quot;===e[e.length-2]&&(t=Number(e[e.length-1]));const n=1===t?e.length-1:e.length-3,r=Number(e[n]);return Number.isNaN(r)?(et(`unknown format ${e}`),0):t*(5-r/2)},Zv=function(e){if(!e||e.length<5)return 0;let t;if(&quot;f&quot;===e[0])t=&quot;Float&quot;;else if(&quot;s&quot;===e[0])t=&quot;Int&quot;;else{if(&quot;u&quot;!==e[0])return void et(`unknown format ${e}`);t=&quot;Uint&quot;}const n=e.split(&quot;x&quot;)[0],r=Number(n[n.length-1]);if(!Number.isNaN(r))return t+=8*(5-r/2),t+=&quot;Array&quot;,t;et(`unknown format ${e}`)},Qv=function(e){let t;if(&quot;f&quot;===e[0]||&quot;n&quot;===e[1])t=&quot;f32&quot;;else if(&quot;s&quot;===e[0]&&&quot;i&quot;===e[1])t=&quot;i32&quot;;else{if(&quot;u&quot;!==e[0]||&quot;i&quot;!==e[1])return void et(`unknown format ${e}`);t=&quot;u32&quot;}let n=1;return&quot;x&quot;===e[e.length-2]&&(n=Number(e[e.length-1])),4===n?`vec4<${t}>`:3===n?`vec3<${t}>`:2===n?`vec2<${t}>`:t},Jv=function(e){if(!e)return 0;let t=1;return&quot;vec&quot;===e.substring(0,3)?t=Number(e[3]):&quot;mat&quot;===e.substring(0,3)&&(t=e[3]*e[5]),4*t},eT=function(e){if(e)return e.includes(&quot;f32&quot;)?&quot;Float32Array&quot;:e.includes(&quot;i32&quot;)?&quot;Int32Array&quot;:e.includes(&quot;u32&quot;)?&quot;Uint32Array&quot;:void et(`unknown format ${e}`)};function tT(e,t){if(e===t)return!0;if(null==e||null==t)return!1;if(e.length!==t.length)return!1;for(let n=0;n<e.length;++n)if(!t.includes(e[n]))return!1;return!0}const nT={inputs:null,bindingDescriptions:!1,attributeDescriptions:null,indexBuffer:null};function rT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,nT,n),ht(e,t),t.bindingDescriptions=[],t.attributeDescriptions=[],t.inputs=[],Ct(e,t,[&quot;created&quot;,&quot;device&quot;,&quot;handle&quot;,&quot;indexBuffer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUVertexInput&quot;),e.addBuffer=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:&quot;vertex&quot;,o=n;Array.isArray(o)||(o=[o]);for(let n=0;n<t.inputs.length;n++)if(tT(t.inputs[n].names,o)){if(t.inputs[n].buffer===e)return;return void(t.inputs[n].buffer=e)}t.inputs.push({buffer:e,stepMode:r,names:o}),t.inputs=t.inputs.sort(((e,t)=>e.names[0]<t.names[0]?-1:e.names[0]>t.names[0]?1:0))},e.removeBufferIfPresent=e=>{for(let n=0;n<t.inputs.length;n++)t.inputs[n].names.includes(e)&&t.inputs.splice(n,1)},e.getBuffer=e=>{for(let n=0;n<t.inputs.length;n++)if(t.inputs[n].names.includes(e))return t.inputs[n].buffer;return null},e.hasAttribute=e=>{for(let n=0;n<t.inputs.length;n++)if(t.inputs[n].names.includes(e))return!0;return!1},e.getAttributeTime=e=>{for(let n=0;n<t.inputs.length;n++)if(t.inputs[n].names.includes(e))return t.inputs[n].buffer.getSourceTime();return 0},e.getShaderCode=()=>{let e=&quot;&quot;,n=0;for(let r=0;r<t.inputs.length;r++)for(let o=0;o<t.inputs[r].names.length;o++){const a=t.inputs[r].buffer.getArrayInformation()[o],i=Qv(a.format);n>0&&(e+=&quot;,\\n&quot;),e=`${e}  @location(${n}) ${t.inputs[r].names[o]} : ${i}`,n++}return e},e.getVertexInputInformation=()=>{const e={};if(t.inputs.length){const n=[];let r=0;for(let e=0;e<t.inputs.length;e++){const o=t.inputs[e].buffer,a={arrayStride:o.getStrideInBytes(),stepMode:t.inputs[e].stepMode,attributes:[]},i=o.getArrayInformation();for(let n=0;n<t.inputs[e].names.length;n++)a.attributes.push({shaderLocation:r,offset:i[n].offset,format:i[n].format}),r++;n.push(a)}e.buffers=n}return e},e.bindBuffers=e=>{for(let n=0;n<t.inputs.length;n++)e.setVertexBuffer(n,t.inputs[n].buffer.getHandle());t.indexBuffer&&e.setIndexBuffer(t.indexBuffer.getHandle(),t.indexBuffer.getArrayInformation()[0].format)},e.getReady=()=>{},e.releaseGraphicsResources=()=>{t.created&&(t.inputs=[],t.bindingDescriptions=[],t.attributeDescriptions=[])}}(e,t)}var oT={newInstance:Mt(rT,&quot;vtkWebGPUVertexInput&quot;),extend:rT};const aT={additionalBindables:void 0,bindGroup:null,device:null,fragmentShaderTemplate:null,numberOfInstances:1,numberOfVertices:0,pipelineHash:null,shaderReplacements:null,SSBO:null,textureViews:null,topology:&quot;triangle-list&quot;,UBO:null,vertexShaderTemplate:null,WebGPURenderer:null};function iT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,aT,n),qt.extend(e,t,n),t.textureViews=[],t.vertexInput=oT.newInstance(),t.bindGroup=Uv.newInstance({label:&quot;mapperBG&quot;}),t.additionalBindables=[],t.fragmentShaderTemplate=t.fragmentShaderTemplate||&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Color::Dec\\n\\n//VTK::Normal::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::Select::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output : fragmentOutput;\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::Light::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Select::Impl\\n\\n  // var computedColor:vec4<f32> = vec4<f32>(1.0,0.5,0.5,1.0);\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;,t.vertexShaderTemplate=t.vertexShaderTemplate||&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Color::Dec\\n\\n//VTK::Normal::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::Select::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@vertex\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output : vertexOutput;\\n\\n  // var vertex: vec4<f32> = vertexBC;\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Select::Impl\\n\\n  //VTK::Position::Impl\\n\\n  return output;\\n}\\n&quot;,t.shaderReplacements=new Map,Wt.get(e,t,[&quot;pipeline&quot;,&quot;vertexInput&quot;]),Wt.setGet(e,t,[&quot;additionalBindables&quot;,&quot;device&quot;,&quot;fragmentShaderTemplate&quot;,&quot;interpolate&quot;,&quot;numberOfInstances&quot;,&quot;numberOfVertices&quot;,&quot;pipelineHash&quot;,&quot;shaderReplacements&quot;,&quot;SSBO&quot;,&quot;textureViews&quot;,&quot;topology&quot;,&quot;UBO&quot;,&quot;vertexShaderTemplate&quot;,&quot;WebGPURenderer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUSimpleMapper&quot;),e.generateShaderDescriptions=(n,r,o)=>{const a=$v.newInstance({type:&quot;vertex&quot;,hash:n,code:t.vertexShaderTemplate}),i=$v.newInstance({type:&quot;fragment&quot;,hash:n,code:t.fragmentShaderTemplate}),s=r.getShaderDescriptions();s.push(a),s.push(i);const l=t.vertexShaderTemplate+t.fragmentShaderTemplate,c=new RegExp(&quot;//VTK::[^:]*::&quot;,&quot;g&quot;),u=l.match(c).filter(((e,t,n)=>n.indexOf(e)===t)),d=u.map((e=>`replaceShader${e.substring(7,e.length-2)}`));for(let e=0;e<d.length;e++){const a=d[e];&quot;replaceShaderIOStructs&quot;!==a&&t.shaderReplacements.has(a)&&t.shaderReplacements.get(a)(n,r,o)}e.replaceShaderIOStructs(n,r,o)},e.replaceShaderIOStructs=(e,t,n)=>{const r=t.getShaderDescription(&quot;vertex&quot;);r.replaceShaderCode(null,n),t.getShaderDescription(&quot;fragment&quot;).replaceShaderCode(r)},e.replaceShaderRenderEncoder=(e,n,r)=>{t.renderEncoder.replaceShaderCode(n)},t.shaderReplacements.set(&quot;replaceShaderRenderEncoder&quot;,e.replaceShaderRenderEncoder),e.replaceShaderRenderer=(e,n,r)=>{if(!t.WebGPURenderer)return;const o=t.WebGPURenderer.getBindGroup().getShaderCode(n),a=n.getShaderDescription(&quot;vertex&quot;);let i=a.getCode();i=_v.substitute(i,&quot;//VTK::Renderer::Dec&quot;,[o]).result,a.setCode(i);const s=n.getShaderDescription(&quot;fragment&quot;);i=s.getCode(),i=_v.substitute(i,&quot;//VTK::Renderer::Dec&quot;,[o]).result,s.setCode(i)},t.shaderReplacements.set(&quot;replaceShaderRenderer&quot;,e.replaceShaderRenderer),e.replaceShaderMapper=(e,n,r)=>{const o=t.bindGroup.getShaderCode(n),a=n.getShaderDescription(&quot;vertex&quot;);let i=a.getCode();i=_v.substitute(i,&quot;//VTK::Mapper::Dec&quot;,[o]).result,a.setCode(i);const s=n.getShaderDescription(&quot;fragment&quot;);s.addBuiltinInput(&quot;bool&quot;,&quot;@builtin(front_facing) frontFacing&quot;),i=s.getCode(),i=_v.substitute(i,&quot;//VTK::Mapper::Dec&quot;,[o]).result,s.setCode(i)},t.shaderReplacements.set(&quot;replaceShaderMapper&quot;,e.replaceShaderMapper),e.replaceShaderPosition=(e,t,n)=>{const r=t.getShaderDescription(&quot;vertex&quot;);r.addBuiltinOutput(&quot;vec4<f32>&quot;,&quot;@builtin(position) Position&quot;);let o=r.getCode();o=_v.substitute(o,&quot;//VTK::Position::Impl&quot;,[&quot;    output.Position = rendererUBO.SCPCMatrix*vertexBC;&quot;]).result,r.setCode(o)},t.shaderReplacements.set(&quot;replaceShaderPosition&quot;,e.replaceShaderPosition),e.replaceShaderTCoord=(e,t,n)=>{t.getShaderDescription(&quot;vertex&quot;).addOutput(&quot;vec2<f32>&quot;,&quot;tcoordVS&quot;)},t.shaderReplacements.set(&quot;replaceShaderTCoord&quot;,e.replaceShaderTCoord),e.addTextureView=e=>{t.textureViews.includes(e)||t.textureViews.push(e)},e.prepareToDraw=n=>{t.renderEncoder=n,e.updateInput(),e.updateBuffers(),e.updateBindings(),e.updatePipeline()},e.updateInput=()=>{},e.updateBuffers=()=>{},e.updateBindings=()=>{t.bindGroup.setBindables(e.getBindables())},e.computePipelineHash=()=>{},e.registerDrawCallback=n=>{n.registerDrawCallback(t.pipeline,e.draw)},e.prepareAndDraw=n=>{e.prepareToDraw(n),n.setPipeline(t.pipeline),e.draw(n)},e.draw=e=>{const n=e.getBoundPipeline();e.activateBindGroup(t.bindGroup),t.WebGPURenderer&&t.WebGPURenderer.bindUBO(e),n.bindVertexInput(e,t.vertexInput);const r=t.vertexInput.getIndexBuffer();r?e.drawIndexed(r.getIndexCount(),t.numberOfInstances,0,0,0):e.draw(t.numberOfVertices,t.numberOfInstances,0,0)},e.getBindables=()=>{const e=[...t.additionalBindables];t.UBO&&e.push(t.UBO),t.SSBO&&e.push(t.SSBO);for(let n=0;n<t.textureViews.length;n++){e.push(t.textureViews[n]);const r=t.textureViews[n].getSampler();r&&e.push(r)}return e},e.updatePipeline=()=>{e.computePipelineHash(),t.pipeline=t.device.getPipeline(t.pipelineHash),t.pipeline||(t.pipeline=Hv.newInstance(),t.pipeline.setDevice(t.device),t.WebGPURenderer&&t.pipeline.addBindGroupLayout(t.WebGPURenderer.getBindGroup()),t.pipeline.addBindGroupLayout(t.bindGroup),e.generateShaderDescriptions(t.pipelineHash,t.pipeline,t.vertexInput),t.pipeline.setTopology(t.topology),t.pipeline.setRenderEncoder(t.renderEncoder),t.pipeline.setVertexState(t.vertexInput.getVertexInputInformation()),t.device.createPipeline(t.pipelineHash,t.pipeline))}}(e,t)}var sT={newInstance:Wt.newInstance(iT,&quot;vtkWebGPUSimpleMapper&quot;),extend:iT};const lT={};function cT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,lT,n),sT.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUFullScreenQuad&quot;),e.replaceShaderPosition=(e,t,n)=>{const r=t.getShaderDescription(&quot;vertex&quot;);r.addBuiltinOutput(&quot;vec4<f32>&quot;,&quot;@builtin(position) Position&quot;),r.addOutput(&quot;vec4<f32>&quot;,&quot;vertexVC&quot;);let o=r.getCode();o=_v.substitute(o,&quot;//VTK::Position::Impl&quot;,[&quot;output.tcoordVS = vec2<f32>(vertexBC.x * 0.5 + 0.5, 1.0 - vertexBC.y * 0.5 - 0.5);&quot;,&quot;output.Position = vec4<f32>(vertexBC, 1.0);&quot;,&quot;output.vertexVC = vec4<f32>(vertexBC, 1);&quot;]).result,r.setCode(o)},t.shaderReplacements.set(&quot;replaceShaderPosition&quot;,e.replaceShaderPosition),e.updateBuffers=()=>{const e=t.device.getBufferManager().getFullScreenQuadBuffer();t.vertexInput.addBuffer(e,[&quot;vertexBC&quot;]),t.numberOfVertices=6}}(e,t)}var uT={newInstance:Wt.newInstance(cT,&quot;vtkWebGPUFullScreenQuad&quot;),extend:cT};const dT=[&quot;setBindGroup&quot;,&quot;setIndexBuffer&quot;,&quot;setVertexBuffer&quot;,&quot;draw&quot;,&quot;drawIndexed&quot;],pT={description:null,handle:null,boundPipeline:null,pipelineHash:null,pipelineSettings:null,replaceShaderCodeFunction:null,depthTextureView:null,label:null};function fT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,pT,n),ht(e,t),t.description={colorAttachments:[{view:void 0,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}],depthStencilAttachment:{view:void 0,depthLoadOp:&quot;clear&quot;,depthClearValue:0,depthStoreOp:&quot;store&quot;}},t.replaceShaderCodeFunction=e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor = computedColor;&quot;]).result,t.setCode(n)},t.pipelineSettings={primitive:{cullMode:&quot;none&quot;},depthStencil:{depthWriteEnabled:!0,depthCompare:&quot;greater-equal&quot;,format:&quot;depth32float&quot;},fragment:{targets:[{format:&quot;rgba16float&quot;,blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}},t.colorTextureViews=[],Tt(e,t,[&quot;boundPipeline&quot;,&quot;colorTextureViews&quot;]),Ct(e,t,[&quot;depthTextureView&quot;,&quot;description&quot;,&quot;handle&quot;,&quot;label&quot;,&quot;pipelineHash&quot;,&quot;pipelineSettings&quot;,&quot;replaceShaderCodeFunction&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPURenderEncoder&quot;),e.begin=e=>{t.drawCallbacks=[],t.handle=e.beginRenderPass(t.description),t.label&&t.handle.pushDebugGroup(t.label)},e.end=()=>{for(let n=0;n<t.drawCallbacks.length;n++){const r=t.drawCallbacks[n],o=r.pipeline;e.setPipeline(o);for(let t=0;t<r.callbacks.length;t++)r.callbacks[t](e)}t.label&&t.handle.popDebugGroup(),t.handle.end(),t.boundPipeline=null},e.setPipeline=e=>{if(t.boundPipeline===e)return;t.handle.setPipeline(e.getHandle());const n=e.getPipelineDescription();if(t.colorTextureViews.length!==n.fragment.targets.length)console.log(`mismatched attachment counts on pipeline ${n.fragment.targets.length} while encoder has ${t.colorTextureViews.length}`),console.trace();else for(let e=0;e<t.colorTextureViews.length;e++){const r=t.colorTextureViews[e].getTexture()?.getFormat();r&&r!==n.fragment.targets[e].format&&(console.log(`mismatched attachments for attachment ${e} on pipeline ${n.fragment.targets[e].format} while encoder has ${r}`),console.trace())}if(!t.depthTextureView!=!(&quot;depthStencil&quot;in n))console.log(&quot;mismatched depth attachments&quot;),console.trace();else if(t.depthTextureView){const e=t.depthTextureView.getTexture()?.getFormat();e&&e!==n.depthStencil.format&&(console.log(`mismatched depth attachments on pipeline ${n.depthStencil.format} while encoder has ${e}`),console.trace())}t.boundPipeline=e},e.replaceShaderCode=e=>{t.replaceShaderCodeFunction(e)},e.setColorTextureView=(e,n)=>{t.colorTextureViews[e]!==n&&(t.colorTextureViews[e]=n)},e.activateBindGroup=e=>{const n=t.boundPipeline.getDevice(),r=t.boundPipeline.getBindGroupLayoutCount(e.getLabel());t.handle.setBindGroup(r,e.getBindGroup(n));const o=n.getBindGroupLayoutDescription(e.getBindGroupLayout(n)),a=n.getBindGroupLayoutDescription(t.boundPipeline.getBindGroupLayout(r));o!==a&&(console.log(`renderEncoder ${t.pipelineHash} mismatched bind group layouts bind group has\\n${o}\\n versus pipeline\\n${a}\\n`),console.trace())},e.attachTextureViews=()=>{for(let e=0;e<t.colorTextureViews.length;e++)t.description.colorAttachments[e]?t.description.colorAttachments[e].view=t.colorTextureViews[e].getHandle():t.description.colorAttachments[e]={view:t.colorTextureViews[e].getHandle()};t.depthTextureView&&(t.description.depthStencilAttachment.view=t.depthTextureView.getHandle())},e.registerDrawCallback=(e,n)=>{for(let r=0;r<t.drawCallbacks.length;r++)if(t.drawCallbacks[r].pipeline===e)return void t.drawCallbacks[r].callbacks.push(n);t.drawCallbacks.push({pipeline:e,callbacks:[n]})};for(let n=0;n<dT.length;n++)e[dT[n]]=function(){return t.handle[dT[n]](...arguments)}}(e,t)}var gT={newInstance:Mt(fT,&quot;vtkWebGPURenderEncoder&quot;),extend:fT};const mT={device:null,handle:null,label:null,options:null};function hT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,mT,n),Wt.obj(e,t),t.options={},t.bindGroupLayoutEntry={visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,sampler:{}},t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),Wt.get(e,t,[&quot;bindGroupTime&quot;,&quot;handle&quot;,&quot;options&quot;]),Wt.setGet(e,t,[&quot;bindGroupLayoutEntry&quot;,&quot;device&quot;,&quot;label&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUSampler&quot;),e.create=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};t.device=e,t.options.addressModeU=n.addressModeU?n.addressModeU:&quot;clamp-to-edge&quot;,t.options.addressModeV=n.addressModeV?n.addressModeV:&quot;clamp-to-edge&quot;,t.options.addressModeW=n.addressModeW?n.addressModeW:&quot;clamp-to-edge&quot;,t.options.magFilter=n.magFilter?n.magFilter:&quot;nearest&quot;,t.options.minFilter=n.minFilter?n.minFilter:&quot;nearest&quot;,t.options.mipmapFilter=n.mipmapFilter?n.mipmapFilter:&quot;nearest&quot;,t.options.label=t.label,t.handle=t.device.getHandle().createSampler(t.options),t.bindGroupTime.modified()},e.getShaderCode=(e,n)=>`@binding(${e}) @group(${n}) var ${t.label}: sampler;`,e.getBindGroupEntry=()=>({resource:t.handle})}(e,t)}var vT={newInstance:Wt.newInstance(hT),extend:hT};const TT={texture:null,handle:null,sampler:null,label:null};function yT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,TT,n),Wt.obj(e,t),t.bindGroupLayoutEntry={visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,texture:{sampleType:&quot;float&quot;,viewDimension:&quot;2d&quot;}},t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),Wt.get(e,t,[&quot;bindGroupTime&quot;,&quot;texture&quot;]),Wt.setGet(e,t,[&quot;bindGroupLayoutEntry&quot;,&quot;label&quot;,&quot;sampler&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUTextureView&quot;),e.create=(e,n)=>{t.texture=e,t.options=n,t.options.dimension=t.options.dimension||&quot;2d&quot;,t.options.label=t.label,t.textureHandle=e.getHandle(),t.handle=t.textureHandle.createView(t.options),t.bindGroupLayoutEntry.texture.viewDimension=t.options.dimension;const r=Xv(t.texture.getFormat());t.bindGroupLayoutEntry.texture.sampleType=r.sampleType},e.createFromTextureHandle=(e,n)=>{t.texture=null,t.options=n,t.options.dimension=t.options.dimension||&quot;2d&quot;,t.options.label=t.label,t.textureHandle=e,t.handle=t.textureHandle.createView(t.options),t.bindGroupLayoutEntry.texture.viewDimension=t.options.dimension;const r=Xv(n.format);t.bindGroupLayoutEntry.texture.sampleType=r.sampleType,t.bindGroupTime.modified()},e.getBindGroupEntry=()=>({resource:e.getHandle()}),e.getShaderCode=(e,n)=>{let r=&quot;f32&quot;;&quot;sint&quot;===t.bindGroupLayoutEntry.texture.sampleType?r=&quot;i32&quot;:&quot;uint&quot;===t.bindGroupLayoutEntry.texture.sampleType&&(r=&quot;u32&quot;);let o=`@binding(${e}) @group(${n}) var ${t.label}: texture_${t.options.dimension}<${r}>;`;return&quot;depth&quot;===t.bindGroupLayoutEntry.texture.sampleType&&(o=`@binding(${e}) @group(${n}) var ${t.label}: texture_depth_${t.options.dimension};`),o},e.addSampler=(n,r)=>{const o=vT.newInstance({label:`${t.label}Sampler`});o.create(n,r),e.setSampler(o)},e.getBindGroupTime=()=>(t.texture&&t.texture.getHandle()!==t.textureHandle&&(t.textureHandle=t.texture.getHandle(),t.handle=t.textureHandle.createView(t.options),t.bindGroupTime.modified()),t.bindGroupTime),e.getHandle=()=>(t.texture&&t.texture.getHandle()!==t.textureHandle&&(t.textureHandle=t.texture.getHandle(),t.handle=t.textureHandle.createView(t.options),t.bindGroupTime.modified()),t.handle)}(e,t)}var bT={newInstance:Wt.newInstance(yT),extend:yT};const xT={device:null,handle:null,buffer:null,ready:!1,label:null};function CT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,xT,n),Wt.obj(e,t),Wt.get(e,t,[&quot;handle&quot;,&quot;ready&quot;,&quot;width&quot;,&quot;height&quot;,&quot;depth&quot;,&quot;format&quot;,&quot;usage&quot;]),Wt.setGet(e,t,[&quot;device&quot;,&quot;label&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUTexture&quot;),e.create=(e,n)=>{t.device=e,t.width=n.width,t.height=n.height,t.depth=n.depth?n.depth:1;const r=1===t.depth?&quot;2d&quot;:&quot;3d&quot;;t.format=n.format?n.format:&quot;rgba8unorm&quot;,t.mipLevel=n.mipLevel?n.mipLevel:0,t.usage=n.usage?n.usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST,t.handle=t.device.getHandle().createTexture({size:[t.width,t.height,t.depth],format:t.format,usage:t.usage,label:t.label,dimension:r,mipLevelCount:t.mipLevel+1})},e.assignFromHandle=(e,n,r)=>{t.device=e,t.handle=n,t.width=r.width,t.height=r.height,t.depth=r.depth?r.depth:1,t.format=r.format?r.format:&quot;rgba8unorm&quot;,t.usage=r.usage?r.usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST},e.writeImageData=n=>{let r=[];const o=r=>{t.device.getHandle().queue.copyExternalImageToTexture({source:r,flipY:n.flip},{texture:t.handle,premultipliedAlpha:!0,mipLevel:0,origin:{x:0,y:0,z:0}},[r.width,r.height,t.depth]),3!==e.getDimensionality()&&t.mipLevel>0&&vu.generateMipmaps(t.device.getHandle(),t.handle,t.mipLevel+1),t.ready=!0};if(n.canvas)return void o(n.canvas);if(n.imageBitmap)return n.width=n.imageBitmap.width,n.height=n.imageBitmap.height,n.depth=1,n.format=&quot;rgba8unorm&quot;,n.flip=!0,void o(n.imageBitmap);if(n.jsImageData)return n.width=n.jsImageData.width,n.height=n.jsImageData.height,n.depth=1,n.format=&quot;rgba8unorm&quot;,n.flip=!0,void o(n.jsImageData);if(n.image)return n.width=n.image.width,n.height=n.image.height,n.depth=1,n.format=&quot;rgba8unorm&quot;,n.flip=!0,void o(n.image);const a=Xv(t.format);let i=t.width*a.stride;n.nativeArray&&(r=n.nativeArray);const s=3===e.getDimensionality(),l=((e,t,n)=>{const r=2===a.elementSize&&&quot;float&quot;===a.sampleType,o=e.BYTES_PER_ELEMENT,i=e.length/(t*n)*o;if(!r&&i%256==0)return[e,i];const s=i/o,l=a.elementSize,c=256*Math.floor((s*l+255)/256),u=c/l,d=Wt.newTypedArray(r?&quot;Uint16Array&quot;:e.constructor.name,u*t*n),p=t*n;if(r)for(let t=0;t<p;t++){const n=t*s,r=t*u;for(let t=0;t<s;t++)d[r+t]=gd.toHalf(e[n+t])}else if(u===s)d.set(e);else for(let t=0;t<p;t++)d.set(e.subarray(t*s,(t+1)*s),t*u);return[d,c]})(r,t.height,s?t.depth:1);i=l[1];const c=l[0];t.device.getHandle().queue.writeTexture({texture:t.handle,mipLevel:0,origin:{x:0,y:0,z:0}},c,{offset:0,bytesPerRow:i,rowsPerImage:t.height},{width:t.width,height:t.height,depthOrArrayLayers:s?t.depth:1}),!s&&t.mipLevel>0&&vu.generateMipmaps(t.device.getHandle(),t.handle,t.mipLevel+1),t.ready=!0},e.getScale=()=>{const e=Xv(t.format);return 2===e.elementSize&&&quot;float&quot;===e.sampleType?1:255},e.getNumberOfComponents=()=>Xv(t.format).numComponents,e.getDimensionality=()=>{let e=0;return t.width>1&&e++,t.height>1&&e++,t.depth>1&&e++,e},e.resizeToMatch=e=>{e.getWidth()===t.width&&e.getHeight()===t.height&&e.getDepth()===t.depth||(t.width=e.getWidth(),t.height=e.getHeight(),t.depth=e.getDepth(),t.handle=t.device.getHandle().createTexture({size:[t.width,t.height,t.depth],format:t.format,usage:t.usage,label:t.label}))},e.resize=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1;e===t.width&&n===t.height&&r===t.depth||(t.width=e,t.height=n,t.depth=r,t.handle=t.device.getHandle().createTexture({size:[t.width,t.height,t.depth],format:t.format,usage:t.usage,label:t.label}))},e.createView=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};r.dimension||(r.dimension=1===t.depth?&quot;2d&quot;:&quot;3d&quot;);const o=bT.newInstance({label:n});return o.create(e,r),o}}(e,t)}var ST={newInstance:Wt.newInstance(CT),extend:CT};const AT={renderEncoder:null,colorTexture:null,depthTexture:null};function IT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,AT,n),ev.extend(e,t,n),Wt.get(e,t,[&quot;colorTexture&quot;,&quot;depthTexture&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUOpaquePass&quot;),e.traverse=(n,r)=>{if(t.deleted)return;t._currentParent=r;const o=r.getDevice();if(t.renderEncoder)t.colorTexture.resize(r.getCanvas().width,r.getCanvas().height),t.depthTexture.resize(r.getCanvas().width,r.getCanvas().height);else{e.createRenderEncoder(),t.colorTexture=ST.newInstance({label:&quot;opaquePassColor&quot;}),t.colorTexture.create(o,{width:r.getCanvas().width,height:r.getCanvas().height,format:&quot;rgba16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC});const n=t.colorTexture.createView(&quot;opaquePassColorTexture&quot;);t.renderEncoder.setColorTextureView(0,n),t.depthFormat=&quot;depth32float&quot;,t.depthTexture=ST.newInstance({label:&quot;opaquePassDepth&quot;}),t.depthTexture.create(o,{width:r.getCanvas().width,height:r.getCanvas().height,format:t.depthFormat,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC});const a=t.depthTexture.createView(&quot;opaquePassDepthTexture&quot;);t.renderEncoder.setDepthTextureView(a)}t.renderEncoder.attachTextureViews(),e.setCurrentOperation(&quot;opaquePass&quot;),n.setRenderEncoder(t.renderEncoder),n.traverse(e)},e.getColorTextureView=()=>t.renderEncoder.getColorTextureViews()[0],e.getDepthTextureView=()=>t.renderEncoder.getDepthTextureView(),e.createRenderEncoder=()=>{t.renderEncoder=gT.newInstance({label:&quot;OpaquePass&quot;}),t.renderEncoder.setPipelineHash(&quot;op&quot;)}}(e,t)}var wT={newInstance:Wt.newInstance(IT,&quot;vtkWebGPUOpaquePass&quot;),extend:IT};const OT={colorTextureView:null,depthTextureView:null};function PT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,OT,n),ev.extend(e,t,n),Wt.setGet(e,t,[&quot;colorTextureView&quot;,&quot;depthTextureView&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUOrderIndependentTranslucentPass&quot;),e.traverse=(n,r)=>{if(t.deleted)return;t._currentParent=r;const o=r.getDevice();if(t.translucentRenderEncoder)t.translucentColorTexture.resizeToMatch(t.colorTextureView.getTexture()),t.translucentAccumulateTexture.resizeToMatch(t.colorTextureView.getTexture());else{e.createRenderEncoder(),e.createFinalEncoder(),t.translucentColorTexture=ST.newInstance({label:&quot;translucentPassColor&quot;}),t.translucentColorTexture.create(o,{width:r.getCanvas().width,height:r.getCanvas().height,format:&quot;rgba16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING});const n=t.translucentColorTexture.createView(&quot;oitpColorTexture&quot;);t.translucentRenderEncoder.setColorTextureView(0,n),t.translucentAccumulateTexture=ST.newInstance({label:&quot;translucentPassAccumulate&quot;}),t.translucentAccumulateTexture.create(o,{width:r.getCanvas().width,height:r.getCanvas().height,format:&quot;r16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING});const a=t.translucentAccumulateTexture.createView(&quot;oitpAccumTexture&quot;);t.translucentRenderEncoder.setColorTextureView(1,a),t.fullScreenQuad=uT.newInstance(),t.fullScreenQuad.setDevice(r.getDevice()),t.fullScreenQuad.setPipelineHash(&quot;oitpfsq&quot;),t.fullScreenQuad.setTextureViews(t.translucentRenderEncoder.getColorTextureViews()),t.fullScreenQuad.setFragmentShaderTemplate(&quot;\\n//VTK::Mapper::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output: fragmentOutput;\\n\\n  var tcoord: vec2<i32> = vec2<i32>(i32(input.fragPos.x), i32(input.fragPos.y));\\n  var reveal: f32 = textureLoad(oitpAccumTexture, tcoord, 0).r;\\n  if (reveal == 1.0) { discard; }\\n  var tcolor: vec4<f32> = textureLoad(oitpColorTexture, tcoord, 0);\\n  var total: f32 = max(tcolor.a, 0.01);\\n  var computedColor: vec4<f32> = vec4<f32>(tcolor.r/total, tcolor.g/total, tcolor.b/total, 1.0 - reveal);\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;)}t.translucentRenderEncoder.setDepthTextureView(t.depthTextureView),t.translucentRenderEncoder.attachTextureViews(),e.setCurrentOperation(&quot;translucentPass&quot;),n.setRenderEncoder(t.translucentRenderEncoder),n.traverse(e),e.finalPass(r,n)},e.finalPass=(e,n)=>{t.translucentFinalEncoder.setColorTextureView(0,t.colorTextureView),t.translucentFinalEncoder.attachTextureViews(),t.translucentFinalEncoder.begin(e.getCommandEncoder()),n.scissorAndViewport(t.translucentFinalEncoder),t.fullScreenQuad.prepareAndDraw(t.translucentFinalEncoder),t.translucentFinalEncoder.end()},e.getTextures=()=>[t.translucentColorTexture,t.translucentAccumulateTexture],e.createRenderEncoder=()=>{t.translucentRenderEncoder=gT.newInstance({label:&quot;translucentRender&quot;});const e=t.translucentRenderEncoder.getDescription();e.colorAttachments=[{view:void 0,clearValue:[0,0,0,0],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;},{view:void 0,clearValue:[1,0,0,0],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;}],e.depthStencilAttachment={view:void 0,depthLoadOp:&quot;load&quot;,depthStoreOp:&quot;store&quot;},t.translucentRenderEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor&quot;),t.addOutput(&quot;f32&quot;,&quot;outAccum&quot;),t.addBuiltinInput(&quot;vec4<f32>&quot;,&quot;@builtin(position) fragPos&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;var w: f32 = computedColor.a * pow(0.1 + input.fragPos.z, 2.0);&quot;,&quot;output.outColor = vec4<f32>(computedColor.rgb*w, w);&quot;,&quot;output.outAccum = computedColor.a;&quot;]).result,t.setCode(n)})),t.translucentRenderEncoder.setPipelineHash(&quot;oitpr&quot;),t.translucentRenderEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},depthStencil:{depthWriteEnabled:!1,depthCompare:&quot;greater&quot;,format:&quot;depth32float&quot;},fragment:{targets:[{format:&quot;rgba16float&quot;,blend:{color:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;}}},{format:&quot;r16float&quot;,blend:{color:{srcFactor:&quot;zero&quot;,dstFactor:&quot;one-minus-src&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})},e.createFinalEncoder=()=>{t.translucentFinalEncoder=gT.newInstance({label:&quot;translucentFinal&quot;}),t.translucentFinalEncoder.setDescription({colorAttachments:[{view:null,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}]}),t.translucentFinalEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor&quot;),t.addBuiltinInput(&quot;vec4<f32>&quot;,&quot;@builtin(position) fragPos&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor = vec4<f32>(computedColor.rgb, computedColor.a);&quot;]).result,t.setCode(n)})),t.translucentFinalEncoder.setPipelineHash(&quot;oitpf&quot;),t.translucentFinalEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;rgba16float&quot;,blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})}}(e,t)}var RT={newInstance:Wt.newInstance(PT,&quot;vtkWebGPUOrderIndependentTranslucentPass&quot;),extend:PT},MT={BufferUsage:{Verts:0,Lines:1,Triangles:2,Strips:3,LinesFromStrips:4,LinesFromTriangles:5,Points:6,UniformArray:7,PointArray:8,NormalsFromPoints:9,Texture:10,RawVertex:11,Storage:12,Index:13},PrimitiveTypes:{Start:0,Points:0,Lines:1,Triangles:2,TriangleStrips:3,TriangleEdges:4,TriangleStripEdges:5,End:6}};const ET=[&quot;getMappedRange&quot;,&quot;mapAsync&quot;,&quot;unmap&quot;];const VT={device:null,handle:null,sizeInBytes:0,strideInBytes:0,arrayInformation:null,usage:null,label:null,sourceTime:null};function DT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,VT,n),Wt.obj(e,t),Wt.get(e,t,[&quot;handle&quot;,&quot;sizeInBytes&quot;,&quot;usage&quot;]),Wt.setGet(e,t,[&quot;strideInBytes&quot;,&quot;device&quot;,&quot;arrayInformation&quot;,&quot;label&quot;,&quot;sourceTime&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUBuffer&quot;),e.create=(e,n)=>{t.handle=t.device.getHandle().createBuffer({size:e,usage:n,label:t.label}),t.sizeInBytes=e,t.usage=n},e.write=e=>{!function(e,t,n,r){const o=r.byteLength,a=e.createBuffer({size:o,usage:GPUBufferUsage.COPY_SRC,mappedAtCreation:!0}),i=a.getMappedRange(0,o);new Uint8Array(i).set(new Uint8Array(r)),a.unmap();const s=e.createCommandEncoder();s.copyBufferToBuffer(a,0,t,0,o);const l=s.finish();e.queue.submit([l]),a.destroy()}(t.device.getHandle(),t.handle,0,e.buffer)},e.createAndWrite=(e,n)=>{const r=4*Math.ceil(e.byteLength/4);t.handle=t.device.getHandle().createBuffer({size:r,usage:n,mappedAtCreation:!0,label:t.label}),t.sizeInBytes=r,t.usage=n,new Uint8Array(t.handle.getMappedRange()).set(new Uint8Array(e.buffer)),t.handle.unmap()};for(let n=0;n<ET.length;n++)e[ET[n]]=function(){return t.handle[ET[n]](...arguments)}}(e,t)}var LT={newInstance:Wt.newInstance(DT),extend:DT,...MT};const{Representation:BT}=os,{PrimitiveTypes:NT}=MT;class FT{constructor(){this.keys=new Uint32Array(10),this.values=new Uint32Array(10),this.count=0}clear(){this.count=0}has(e){for(let t=0;t<this.count;t++)if(this.keys[t]===e)return!0}get(e){for(let t=0;t<this.count;t++)if(this.keys[t]===e)return this.values[t]}set(e,t){this.count<9&&(this.keys[this.count]=e,this.values[this.count++]=t)}}function _T(e,t,n){let r=e.pointIdToFlatId[t];return r<0&&(r=e.flatId,e.pointIdToFlatId[t]=r,e.flatIdToPointId[e.flatId]=t,e.flatIdToCellId[e.flatId]=n,e.flatId++),r}function kT(e,t,n){const r=e.length;for(let o=0;o<r;o++){let a=e[o];if(n.cellProvokedMap.has(a)){n.ibo[n.iboId++]=n.cellProvokedMap.get(a);for(let i=o+1;i<o+r;i++){a=e[i%r];const o=_T(n,a,t);n.ibo[n.iboId++]=o}return}}for(let o=0;o<r;o++){let a=e[o];if(!n.provokedPointIds[a]){let i=_T(n,a,t);n.provokedPointIds[a]=1,n.cellProvokedMap.set(a,i),n.flatIdToCellId[i]=t,n.ibo[n.iboId++]=i;for(let s=o+1;s<o+r;s++)a=e[s%r],i=_T(n,a,t),n.ibo[n.iboId++]=i;return}}let o=e[0],a=n.flatId;n.cellProvokedMap.set(o,a),n.flatIdToPointId[n.flatId]=o,n.flatIdToCellId[n.flatId]=t,n.flatId++,n.ibo[n.iboId++]=a;for(let i=1;i<r;i++)o=e[i],a=_T(n,o,t),n.ibo[n.iboId++]=a}function GT(e,t,n){const r=e.length;n.iboSize+=r;for(let t=0;t<r;t++){const r=e[t];if(n.cellProvokedMap.has(r))return}for(let t=0;t<r;t++){const r=e[t];if(!n.provokedPointIds[r])return n.provokedPointIds[r]=1,void n.cellProvokedMap.set(r,1)}n.cellProvokedMap.set(e[0],1),n.extraPoints++}let UT;const zT=new Uint32Array(1),WT=new Uint32Array(2),HT=new Uint32Array(3),jT={anythingToPoints(e,t,n,r,o){for(let a=0;a<e;++a)zT[0]=t[n+a],UT(zT,r,o)},linesToWireframe(e,t,n,r,o){for(let a=0;a<e-1;++a)WT[0]=t[n+a],WT[1]=t[n+a+1],UT(WT,r,o)},polysToWireframe(e,t,n,r,o){if(e>2)for(let a=0;a<e;++a)WT[0]=t[n+a],WT[1]=t[n+(a+1)%e],UT(WT,r,o)},stripsToWireframe(e,t,n,r,o){if(e>2){for(let a=0;a<e-1;++a)WT[0]=t[n+a],WT[1]=t[n+a+1],UT(WT,r,o);for(let a=0;a<e-2;a++)WT[0]=t[n+a],WT[1]=t[n+a+2],UT(WT,r,o)}},polysToSurface(e,t,n,r,o){for(let a=0;a<e-2;a++)HT[0]=t[n],HT[1]=t[n+a+1],HT[2]=t[n+a+2],UT(HT,r,o)},stripsToSurface(e,t,n,r,o){for(let a=0;a<e-2;a++)HT[0]=t[n+a],HT[1]=t[n+a+1+a%2],HT[2]=t[n+a+1+(a+1)%2],UT(HT,r,o)}};const KT={flatIdToPointId:null,flatIdToCellId:null,flatSize:0,indexCount:0};function $T(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,KT,n),LT.extend(e,t,n),Wt.setGet(e,t,[&quot;flatIdToPointId&quot;,&quot;flatIdToCellId&quot;,&quot;flatSize&quot;,&quot;indexCount&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUIndexBuffer&quot;),e.buildIndexBuffer=e=>{const n=e.cells,r=e.primitiveType,o=e.representation,a=e.cellOffset,i=n.getData(),s=i.length,l=function(e){switch(e){case NT.Points:return&quot;points&quot;;case NT.Lines:return&quot;lines&quot;;case NT.Triangles:case NT.TriangleEdges:return&quot;polys&quot;;case NT.TriangleStripEdges:case NT.TriangleStrips:return&quot;strips&quot;;default:return&quot;&quot;}}(r),c=e.numberOfPoints,u={provokedPointIds:new Uint8Array(c),extraPoints:0,iboSize:0,flatId:0,iboId:0,cellProvokedMap:new FT};let d=null;d=o===BT.POINTS||r===NT.Points?jT.anythingToPoints:o===BT.WIREFRAME||r===NT.Lines?jT[`${l}ToWireframe`]:jT[`${l}ToSurface`],UT=GT;let p=a||0;for(let e=0;e<s;)u.cellProvokedMap.clear(),d(i[e],i,e+1,p,u),e+=i[e]+1,p++;u.flatIdToPointId=c<=65535?new Uint16Array(c+u.extraPoints):new Uint32Array(c+u.extraPoints),c+u.extraPoints<36863?u.pointIdToFlatId=new Int16Array(c):u.pointIdToFlatId=new Int32Array(c),c+u.extraPoints<=65535?(u.ibo=new Uint16Array(u.iboSize),e.format=&quot;uint16&quot;):(u.ibo=new Uint32Array(u.iboSize),e.format=&quot;uint32&quot;),u.flatIdToCellId=p<=65535?new Uint16Array(c+u.extraPoints):new Uint32Array(c+u.extraPoints),u.pointIdToFlatId.fill(-1),u.provokedPointIds.fill(0),UT=kT,p=a||0;for(let e=0;e<s;)u.cellProvokedMap.clear(),d(i[e],i,e+1,p,u),e+=i[e]+1,p++;delete u.provokedPointIds,delete u.pointIdToFlatId,e.nativeArray=u.ibo,t.flatIdToPointId=u.flatIdToPointId,t.flatIdToCellId=u.flatIdToCellId,t.flatSize=u.flatId,t.indexCount=u.iboId}}(e,t)}var qT={newInstance:Wt.newInstance($T),extend:$T,...MT};const{BufferUsage:XT}=MT,{vtkErrorMacro:YT}=Ht,{VtkDataTypes:ZT}=xs;function QT(e,t,n,r,o){const a={},i=e.getFlatSize();if(!i)return a;let s=[0,0,0,0];o.shift&&(o.shift.length?s=o.shift:s.fill(o.shift));let l=[1,1,1,1];o.scale&&(o.scale.length?l=o.scale:l.fill(o.scale));const c=!!Object.prototype.hasOwnProperty.call(o,&quot;packExtra&quot;)&&o.packExtra;let u,d=0;const p=at(r,i*(n+(c?1:0)));let f=e.getFlatIdToPointId();o.cellData&&(f=e.getFlatIdToCellId()),1===n?u=function(e){p[d++]=l[0]*t[e]+s[0]}:2===n?u=function(e){p[d++]=l[0]*t[e]+s[0],p[d++]=l[1]*t[e+1]+s[1]}:3!==n||c?3===n&&c?u=function(e){p[d++]=l[0]*t[e]+s[0],p[d++]=l[1]*t[e+1]+s[1],p[d++]=l[2]*t[e+2]+s[2],p[d++]=1*l[3]+s[3]}:4===n&&(u=function(e){p[d++]=l[0]*t[e]+s[0],p[d++]=l[1]*t[e+1]+s[1],p[d++]=l[2]*t[e+2]+s[2],p[d++]=l[3]*t[e+3]+s[3]}):u=function(e){p[d++]=l[0]*t[e]+s[0],p[d++]=l[1]*t[e+1]+s[1],p[d++]=l[2]*t[e+2]+s[2]};for(let e=0;e<i;e++)u(n*f[e]);return a.nativeArray=p,a}function JT(e,t,n,r){const o=[];return Bo([e[3*r]-e[3*n],e[3*r+1]-e[3*n+1],e[3*r+2]-e[3*n+2]],[e[3*t]-e[3*n],e[3*t+1]-e[3*n+1],e[3*t+2]-e[3*n+2]],o),Fo(o),o}const ey={device:null,fullScreenQuadBuffer:null};function ty(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ey,n),ht(e,t),Ct(e,t,[&quot;device&quot;]),function(e,t){function n(e){let n,r;if(e.dataArray&&!e.nativeArray&&(e.nativeArray=e.dataArray.getData()),e.usage===XT.Index&&(n=qT.newInstance({label:e.label}),n.setDevice(t.device),r=GPUBufferUsage.INDEX|GPUBufferUsage.COPY_DST,n.buildIndexBuffer(e),n.createAndWrite(e.nativeArray,r),n.setArrayInformation([{format:e.format}])),n||(n=LT.newInstance({label:e.label}),n.setDevice(t.device)),e.usage===XT.UniformArray&&(r=GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST,n.createAndWrite(e.nativeArray,r)),e.usage===XT.Storage&&(r=GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST,n.createAndWrite(e.nativeArray,r)),e.usage===XT.Texture&&(r=GPUBufferUsage.COPY_SRC,n.createAndWrite(e.nativeArray,r)),e.usage===XT.PointArray){r=GPUBufferUsage.VERTEX;const t=Zv(e.format),o=QT(e.indexBuffer,e.dataArray.getData(),e.dataArray.getNumberOfComponents(),t,{packExtra:e.packExtra,shift:e.shift,scale:e.scale,cellData:e.cellData,cellOffset:e.cellOffset});n.createAndWrite(o.nativeArray,r),n.setStrideInBytes(Yv(e.format)),n.setArrayInformation([{offset:0,format:e.format,interpolation:e.cellData?&quot;flat&quot;:&quot;perspective&quot;}])}if(e.usage===XT.NormalsFromPoints){r=GPUBufferUsage.VERTEX;const t=Zv(e.format),o=function(e,t){const n=t.getData(),r=e.getData();if(!r||!n)return null;const o=new Int8Array(4*e.getNumberOfCells()),a=r.length;let i=0;for(let e=0;e<a;){const t=JT(n,r[e+1],r[e+2],r[e+3]);o[i++]=127*t[0],o[i++]=127*t[1],o[i++]=127*t[2],o[i++]=127,e+=r[e]+1}return o}(e.cells,e.dataArray),a=QT(e.indexBuffer,o,4,t,{cellData:!0});n.createAndWrite(a.nativeArray,r),n.setStrideInBytes(Yv(e.format)),n.setArrayInformation([{offset:0,format:e.format,interpolation:&quot;flat&quot;}])}return e.usage===XT.RawVertex&&(r=GPUBufferUsage.VERTEX,n.createAndWrite(e.nativeArray,r),n.setStrideInBytes(Yv(e.format)),n.setArrayInformation([{offset:0,format:e.format}])),n.setSourceTime(e.time),n}t.classHierarchy.push(&quot;vtkWebGPUBufferManager&quot;),e.hasBuffer=e=>t.device.hasCachedObject(e),e.getBuffer=e=>e.hash?t.device.getCachedObject(e.hash,n,e):n(e),e.getBufferForPointArray=(t,n)=>{const r=function(e){let t;switch(e.getDataType()){case ZT.UNSIGNED_CHAR:t=&quot;uint8&quot;;break;case ZT.FLOAT:t=&quot;float32&quot;;break;case ZT.UNSIGNED_INT:t=&quot;uint32&quot;;break;case ZT.INT:t=&quot;sint32&quot;;break;case ZT.DOUBLE:t=&quot;float32&quot;;break;case ZT.UNSIGNED_SHORT:t=&quot;uint16&quot;;break;case ZT.SHORT:t=&quot;sin16&quot;;break;default:t=&quot;float32&quot;}switch(e.getNumberOfComponents()){case 2:t+=&quot;x2&quot;;break;case 3:t.includes(&quot;32&quot;)||YT(`unsupported x3 type for ${t}`),t+=&quot;x3&quot;;break;case 4:t+=&quot;x4&quot;}return t}(t),o={hash:`${t.getMTime()}I${n.getMTime()}${r}`,usage:XT.PointArray,format:r,dataArray:t,indexBuffer:n};return e.getBuffer(o)},e.getFullScreenQuadBuffer=()=>{if(t.fullScreenQuadBuffer)return t.fullScreenQuadBuffer;t.fullScreenQuadBuffer=LT.newInstance(),t.fullScreenQuadBuffer.setDevice(t.device);const e=new Float32Array([-1,-1,0,1,-1,0,1,1,0,-1,-1,0,1,1,0,-1,1,0]);return t.fullScreenQuadBuffer.createAndWrite(e,GPUBufferUsage.VERTEX),t.fullScreenQuadBuffer.setStrideInBytes(12),t.fullScreenQuadBuffer.setArrayInformation([{offset:0,format:&quot;float32x3&quot;}]),t.fullScreenQuadBuffer}}(e,t)}var ny={newInstance:Mt(ty),extend:ty,...MT};const{BufferUsage:ry}=ny,{vtkErrorMacro:oy}=Wt,ay={bufferEntries:null,bufferEntryNames:null,sizeInBytes:0,label:null,bindGroupLayoutEntry:null,bindGroupEntry:null};function iy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ay,n),Wt.obj(e,t),t._bufferEntryNames=new Map,t.bufferEntries=[],t.bindGroupLayoutEntry=t.bindGroupLayoutEntry||{buffer:{type:&quot;uniform&quot;}},t.sendTime={},Wt.obj(t.sendTime,{mtime:0}),t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),t.sendDirty=!0,t.sortDirty=!0,Wt.get(e,t,[&quot;binding&quot;,&quot;bindGroupTime&quot;]),Wt.setGet(e,t,[&quot;bindGroupLayoutEntry&quot;,&quot;device&quot;,&quot;label&quot;,&quot;sizeInBytes&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUUniformBuffer&quot;),e.addEntry=(e,n)=>{t._bufferEntryNames.has(e)?oy(`entry named ${e} already exists`):(t.sortDirty=!0,t._bufferEntryNames.set(e,t.bufferEntries.length),t.bufferEntries.push({name:e,type:n,sizeInBytes:Jv(n),offset:-1,nativeType:eT(n),packed:!1}))},e.sortBufferEntries=()=>{if(!t.sortDirty)return;let e=0;const n=[];let r=4;for(let e=0;e<t.bufferEntries.length;e++){const n=t.bufferEntries[e];n.sizeInBytes%16==0&&(r=Math.max(16,r)),n.sizeInBytes%8==0&&(r=Math.max(8,r))}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];!1===o.packed&&o.sizeInBytes%16==0&&(o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes)}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];if(!1===o.packed&&12===o.sizeInBytes)for(let r=0;r<t.bufferEntries.length;r++){const a=t.bufferEntries[r];if(!1===a.packed&&4===a.sizeInBytes){o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes,a.packed=!0,a.offset=e,n.push(a),e+=a.sizeInBytes;break}}}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];if(!o.packed&&o.sizeInBytes%8==0)for(let a=r+1;a<t.bufferEntries.length;a++){const r=t.bufferEntries[a];if(!r.packed&&r.sizeInBytes%8==0){o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes,r.packed=!0,r.offset=e,n.push(r),e+=r.sizeInBytes;break}}}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];if(!o.packed&&o.sizeInBytes%8==0){let r=!1;for(let a=0;!r&&a<t.bufferEntries.length;a++){const i=t.bufferEntries[a];if(!i.packed&&4===i.sizeInBytes)for(let s=a+1;s<t.bufferEntries.length;s++){const a=t.bufferEntries[s];if(!a.packed&&4===a.sizeInBytes){o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes,i.packed=!0,i.offset=e,n.push(i),e+=i.sizeInBytes,a.packed=!0,a.offset=e,n.push(a),e+=a.sizeInBytes,r=!0;break}}}}}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];!o.packed&&o.sizeInBytes>4&&(o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes)}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];o.packed||(o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes)}t.bufferEntries=n,t._bufferEntryNames.clear();for(let e=0;e<t.bufferEntries.length;e++)t._bufferEntryNames.set(t.bufferEntries[e].name,e);t.sizeInBytes=e,t.sizeInBytes=r*Math.ceil(t.sizeInBytes/r),t.sortDirty=!1},e.sendIfNeeded=e=>{if(!t.UBO){const n={nativeArray:t.Float32Array,usage:ry.UniformArray,label:t.label};t.UBO=e.getBufferManager().getBuffer(n),t.bindGroupTime.modified(),t.sendDirty=!1}t.sendDirty&&(e.getHandle().queue.writeBuffer(t.UBO.getHandle(),0,t.arrayBuffer,0,t.sizeInBytes),t.sendDirty=!1),t.sendTime.modified()},e.createView=e=>{e in t==0&&(t.arrayBuffer||(t.arrayBuffer=new ArrayBuffer(t.sizeInBytes)),t[e]=Wt.newTypedArray(e,t.arrayBuffer))},e.setValue=(n,r)=>{e.sortBufferEntries();const o=t._bufferEntryNames.get(n);if(void 0===o)return void oy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType];a.lastValue!==r&&(i[a.offset/i.BYTES_PER_ELEMENT]=r,t.sendDirty=!0),a.lastValue=r},e.setArray=(n,r)=>{e.sortBufferEntries();const o=t._bufferEntryNames.get(n);if(void 0===o)return void oy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType];let s=!1;for(let e=0;e<r.length;e++)a.lastValue&&a.lastValue[e]===r[e]||(i[a.offset/i.BYTES_PER_ELEMENT+e]=r[e],s=!0);s&&(t.sendDirty=!0,a.lastValue=[...r])},e.getBindGroupEntry=()=>({resource:{buffer:t.UBO.getHandle()}}),e.getSendTime=()=>t.sendTime.getMTime(),e.getShaderCode=(n,r)=>{e.sortBufferEntries();const o=[`struct ${t.label}Struct\\n{`];for(let e=0;e<t.bufferEntries.length;e++){const n=t.bufferEntries[e];o.push(`  ${n.name}: ${n.type},`)}return o.push(`};\\n@binding(${n}) @group(${r}) var<uniform> ${t.label}: ${t.label}Struct;`),o.join(&quot;\\n&quot;)}}(e,t)}var sy={newInstance:Wt.newInstance(iy,&quot;vtkWebGPUUniformBuffer&quot;),extend:iy};const{BufferUsage:ly}=ny,{vtkErrorMacro:cy}=Wt,uy={bufferEntries:null,bufferEntryNames:null,sizeInBytes:0,label:null,numberOfInstances:1};function dy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,uy,n),Wt.obj(e,t),t._bufferEntryNames=new Map,t.bufferEntries=[],t._sendTime={},Wt.obj(t._sendTime,{mtime:0}),t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),t.bindGroupLayoutEntry=t.bindGroupLayoutEntry||{buffer:{type:&quot;read-only-storage&quot;}},Wt.get(e,t,[&quot;bindGroupTime&quot;]),Wt.setGet(e,t,[&quot;device&quot;,&quot;bindGroupLayoutEntry&quot;,&quot;label&quot;,&quot;numberOfInstances&quot;,&quot;sizeInBytes&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUStorageBuffer&quot;),e.addEntry=(e,n)=>{if(t._bufferEntryNames.has(e))return void cy(`entry named ${e} already exists`);t._bufferEntryNames.set(e,t.bufferEntries.length);const r=Jv(n);t.bufferEntries.push({name:e,type:n,sizeInBytes:r,offset:t.sizeInBytes,nativeType:eT(n)}),t.sizeInBytes+=r},e.send=e=>{if(!t._buffer){const n={nativeArray:t.Float32Array,usage:ly.Storage,label:t.label};return t._buffer=e.getBufferManager().getBuffer(n),t.bindGroupTime.modified(),void t._sendTime.modified()}e.getHandle().queue.writeBuffer(t._buffer.getHandle(),0,t.arrayBuffer,0,t.sizeInBytes*t.numberOfInstances),t._sendTime.modified()},e.createView=e=>{e in t==0&&(t.arrayBuffer||(t.arrayBuffer=new ArrayBuffer(t.sizeInBytes*t.numberOfInstances)),t[e]=Wt.newTypedArray(e,t.arrayBuffer))},e.setValue=(n,r,o)=>{const a=t._bufferEntryNames.get(n);if(void 0===a)return void cy(`entry named ${n} not found in UBO`);const i=t.bufferEntries[a];e.createView(i.nativeType);const s=t[i.nativeType];s[(i.offset+r*t.sizeInBytes)/s.BYTES_PER_ELEMENT]=o},e.setArray=(n,r,o)=>{const a=t._bufferEntryNames.get(n);if(void 0===a)return void cy(`entry named ${n} not found in UBO`);const i=t.bufferEntries[a];e.createView(i.nativeType);const s=t[i.nativeType],l=(i.offset+r*t.sizeInBytes)/s.BYTES_PER_ELEMENT;for(let e=0;e<o.length;e++)s[l+e]=o[e]},e.setAllInstancesFromArray=(n,r)=>{const o=t._bufferEntryNames.get(n);if(void 0===o)return void cy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType],s=r.length/t.numberOfInstances;for(let e=0;e<t.numberOfInstances;e++){const n=(a.offset+e*t.sizeInBytes)/i.BYTES_PER_ELEMENT;for(let t=0;t<s;t++)i[n+t]=r[e*s+t]}},e.setAllInstancesFromArrayColorToFloat=(n,r)=>{const o=t._bufferEntryNames.get(n);if(void 0===o)return void cy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType],s=r.length/t.numberOfInstances;for(let e=0;e<t.numberOfInstances;e++){const n=(a.offset+e*t.sizeInBytes)/i.BYTES_PER_ELEMENT;for(let t=0;t<s;t++)i[n+t]=r[e*s+t]/255}},e.setAllInstancesFromArray3x3To4x4=(n,r)=>{const o=t._bufferEntryNames.get(n);if(void 0===o)return void cy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType];for(let e=0;e<t.numberOfInstances;e++){const n=(a.offset+e*t.sizeInBytes)/i.BYTES_PER_ELEMENT;for(let t=0;t<3;t++)for(let o=0;o<3;o++)i[n+4*t+o]=r[9*e+3*t+o]}},e.getSendTime=()=>t._sendTime.getMTime(),e.getShaderCode=(e,n)=>{const r=[`struct ${t.label}StructEntry\\n{`];for(let e=0;e<t.bufferEntries.length;e++){const n=t.bufferEntries[e];r.push(`  ${n.name}: ${n.type},`)}return r.push(`\\n};\\nstruct ${t.label}Struct\\n{\\n  values: array<${t.label}StructEntry>,\\n};\\n@binding(${e}) @group(${n}) var<storage, read> ${t.label}: ${t.label}Struct;\\n`),r.join(&quot;\\n&quot;)},e.getBindGroupEntry=()=>({resource:{buffer:t._buffer.getHandle()}}),e.clearData=()=>{t.numberOfInstances=0,t.sizeInBytes=0,t.bufferEntries=[],t._bufferEntryNames=new Map,t._buffer=null,delete t.arrayBuffer,delete t.Float32Array}}(e,t)}var py={newInstance:Wt.newInstance(dy,&quot;vtkWebGPUStorageBuffer&quot;),extend:dy};const fy=new Float64Array(16),gy=new Float64Array(16),my={volumes:null,rowLength:1024,lastVolumeLength:0};function hy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,my,n),uT.extend(e,t,n),t.fragmentShaderTemplate=&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::Volume::TraverseDec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::IOStructs::Dec\\n\\nfn getTextureValue(vTex: texture_3d<f32>, tpos: vec4<f32>) -> f32\\n{\\n  // todo multicomponent support\\n  return textureSampleLevel(vTex, clampSampler, tpos.xyz, 0.0).r;\\n}\\n\\nfn getGradient(vTex: texture_3d<f32>, tpos: vec4<f32>, vNum: i32, scalar: f32) -> vec4<f32>\\n{\\n  var result: vec4<f32>;\\n\\n  var tstep: vec4<f32> = volumeSSBO.values[vNum].tstep;\\n  result.x = getTextureValue(vTex, tpos + vec4<f32>(tstep.x, 0.0, 0.0, 1.0)) - scalar;\\n  result.y = getTextureValue(vTex, tpos + vec4<f32>(0.0, tstep.y, 0.0, 1.0)) - scalar;\\n  result.z = getTextureValue(vTex, tpos + vec4<f32>(0.0, 0.0, tstep.z, 1.0)) - scalar;\\n  result.w = 0.0;\\n\\n  // divide by spacing as that is our delta\\n  result = result / volumeSSBO.values[vNum].spacing;\\n  // now we have a gradient in unit tcoords\\n\\n  var grad: f32 = length(result.xyz);\\n  if (grad > 0.0)\\n  {\\n    // rotate to View Coords, needed for lighting and shading\\n    var nMat: mat4x4<f32> = rendererUBO.SCVCMatrix * volumeSSBO.values[vNum].planeNormals;\\n    result = nMat * result;\\n    result = result / length(result);\\n  }\\n\\n  // store gradient magnitude in .w\\n  result.w = grad;\\n\\n  return result;\\n}\\n\\nfn processVolume(vTex: texture_3d<f32>, vNum: i32, cNum: i32, posSC: vec4<f32>, tfunRows: f32) -> vec4<f32>\\n{\\n  var outColor: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);\\n\\n  // convert to tcoords and reject if outside the volume\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*posSC;\\n  if (tpos.x < 0.0 || tpos.y < 0.0 || tpos.z < 0.0 ||\\n      tpos.x > 1.0 || tpos.y > 1.0 || tpos.z > 1.0) { return outColor; }\\n\\n  var scalar: f32 = getTextureValue(vTex, tpos);\\n\\n  var coord: vec2<f32> =\\n    vec2<f32>(scalar * componentSSBO.values[cNum].cScale + componentSSBO.values[cNum].cShift,\\n      (0.5 + 2.0 * f32(vNum)) / tfunRows);\\n  var color: vec4<f32> = textureSampleLevel(tfunTexture, clampSampler, coord, 0.0);\\n\\n  var gofactor: f32 = 1.0;\\n  var normal: vec4<f32> = vec4<f32>(0.0,0.0,0.0,0.0);\\n  if (componentSSBO.values[cNum].gomin <  1.0 || volumeSSBO.values[vNum].shade[0] > 0.0)\\n  {\\n    normal = getGradient(vTex, tpos, vNum, scalar);\\n    if (componentSSBO.values[cNum].gomin <  1.0)\\n    {\\n      gofactor = clamp(normal.a*componentSSBO.values[cNum].goScale + componentSSBO.values[cNum].goShift,\\n      componentSSBO.values[cNum].gomin, componentSSBO.values[cNum].gomax);\\n    }\\n  }\\n\\n  coord.x = (scalar * componentSSBO.values[cNum].oScale + componentSSBO.values[cNum].oShift);\\n  var opacity: f32 = textureSampleLevel(ofunTexture, clampSampler, coord, 0.0).r;\\n\\n  if (volumeSSBO.values[vNum].shade[0] > 0.0)\\n  {\\n    color = color*abs(normal.z);\\n  }\\n\\n  outColor = vec4<f32>(color.rgb, gofactor * opacity);\\n\\n  return outColor;\\n}\\n\\n// adjust the start and end point of a raycast such that it intersects the unit cube.\\n// This function is used to take a raycast starting point and step vector\\n// and numSteps and return the startijng and ending steps for intersecting the\\n// unit cube. Recall for a 3D texture, the unit cube is the range of texture coordsinates\\n// that have valid values. So this funtion can be used to take a ray in texture coordinates\\n// and bound it to intersecting the texture.\\n//\\nfn adjustBounds(tpos: vec4<f32>, tstep: vec4<f32>, numSteps: f32) -> vec2<f32>\\n{\\n  var result: vec2<f32> = vec2<f32>(0.0, numSteps);\\n  var tpos2: vec4<f32> = tpos + tstep*numSteps;\\n\\n  // move tpos to the start of the volume\\n  var adjust: f32 =\\n    min(\\n      max(tpos.x/tstep.x, (tpos.x - 1.0)/tstep.x),\\n      min(\\n        max((tpos.y - 1.0)/tstep.y, tpos.y/tstep.y),\\n        max((tpos.z - 1.0)/tstep.z, tpos.z/tstep.z)));\\n  if (adjust < 0.0)\\n  {\\n    result.x = result.x - adjust;\\n  }\\n\\n  // adjust length to the end\\n  adjust =\\n    max(\\n      min(tpos2.x/tstep.x, (tpos2.x - 1.0)/tstep.x),\\n      max(\\n        min((tpos2.y - 1.0)/tstep.y, tpos2.y/tstep.y),\\n        min((tpos2.z - 1.0)/tstep.z, tpos2.z/tstep.z)));\\n  if (adjust > 0.0)\\n  {\\n    result.y = result.y - adjust;\\n  }\\n\\n  return result;\\n}\\n\\nfn getSimpleColor(scalar: f32, vNum: i32, cNum: i32) -> vec4<f32>\\n{\\n  // how many rows (tfuns) do we have in our tfunTexture\\n  var tfunRows: f32 = f32(textureDimensions(tfunTexture).y);\\n\\n  var coord: vec2<f32> =\\n    vec2<f32>(scalar * componentSSBO.values[cNum].cScale + componentSSBO.values[cNum].cShift,\\n      (0.5 + 2.0 * f32(vNum)) / tfunRows);\\n  var color: vec4<f32> = textureSampleLevel(tfunTexture, clampSampler, coord, 0.0);\\n  coord.x = (scalar * componentSSBO.values[cNum].oScale + componentSSBO.values[cNum].oShift);\\n  var opacity: f32 = textureSampleLevel(ofunTexture, clampSampler, coord, 0.0).r;\\n  return vec4<f32>(color.rgb, opacity);\\n}\\n\\nfn traverseMax(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\\n{\\n  // convert to tcoords and reject if outside the volume\\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\\n  var tstep: vec4<f32> = tpos2 - tpos;\\n\\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\\n\\n  // did we hit anything\\n  if (rayBounds.x >= rayBounds.y)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n    return;\\n  }\\n\\n  tpos = tpos + tstep*rayBounds.x;\\n  var curDist: f32 = rayBounds.x;\\n  var maxVal: f32 = -1.0e37;\\n  loop\\n  {\\n    var scalar: f32 = getTextureValue(vTex, tpos);\\n    if (scalar > maxVal)\\n    {\\n      maxVal = scalar;\\n    }\\n\\n    // increment position\\n    curDist = curDist + 1.0;\\n    tpos = tpos + tstep;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayBounds.y) { break; }\\n  }\\n\\n  // process to get the color and opacity\\n  traverseVals[vNum] = getSimpleColor(maxVal, vNum, cNum);\\n}\\n\\nfn traverseMin(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\\n{\\n  // convert to tcoords and reject if outside the volume\\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\\n  var tstep: vec4<f32> = tpos2 - tpos;\\n\\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\\n\\n  // did we hit anything\\n  if (rayBounds.x >= rayBounds.y)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n    return;\\n  }\\n\\n  tpos = tpos + tstep*rayBounds.x;\\n  var curDist: f32 = rayBounds.x;\\n  var minVal: f32 = 1.0e37;\\n  loop\\n  {\\n    var scalar: f32 = getTextureValue(vTex, tpos);\\n    if (scalar < minVal)\\n    {\\n      minVal = scalar;\\n    }\\n\\n    // increment position\\n    curDist = curDist + 1.0;\\n    tpos = tpos + tstep;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayBounds.y) { break; }\\n  }\\n\\n  // process to get the color and opacity\\n  traverseVals[vNum] = getSimpleColor(minVal, vNum, cNum);\\n}\\n\\nfn traverseAverage(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\\n{\\n  // convert to tcoords and reject if outside the volume\\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\\n  var tstep: vec4<f32> = tpos2 - tpos;\\n\\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\\n\\n  // did we hit anything\\n  if (rayBounds.x >= rayBounds.y)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n    return;\\n  }\\n\\n  let ipRange: vec4<f32> = volumeSSBO.values[vNum].ipScalarRange;\\n  tpos = tpos + tstep*rayBounds.x;\\n  var curDist: f32 = rayBounds.x;\\n  var avgVal: f32 = 0.0;\\n  var sampleCount: f32 = 0.0;\\n  loop\\n  {\\n    var sample: f32 = getTextureValue(vTex, tpos);\\n    // right now leave filtering off until WebGL changes get merged\\n    // if (ipRange.z == 0.0 || sample >= ipRange.x && sample <= ipRange.y)\\n    // {\\n      avgVal = avgVal + sample;\\n      sampleCount = sampleCount + 1.0;\\n    // }\\n\\n    // increment position\\n    curDist = curDist + 1.0;\\n    tpos = tpos + tstep;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayBounds.y) { break; }\\n  }\\n\\n  if (sampleCount <= 0.0)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n  }\\n\\n  // process to get the color and opacity\\n  traverseVals[vNum] = getSimpleColor(avgVal/sampleCount, vNum, cNum);\\n}\\n\\nfn traverseAdditive(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\\n{\\n  // convert to tcoords and reject if outside the volume\\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\\n  var tstep: vec4<f32> = tpos2 - tpos;\\n\\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\\n\\n  // did we hit anything\\n  if (rayBounds.x >= rayBounds.y)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n    return;\\n  }\\n\\n  let ipRange: vec4<f32> = volumeSSBO.values[vNum].ipScalarRange;\\n  tpos = tpos + tstep*rayBounds.x;\\n  var curDist: f32 = rayBounds.x;\\n  var sumVal: f32 = 0.0;\\n  loop\\n  {\\n    var sample: f32 = getTextureValue(vTex, tpos);\\n    // right now leave filtering off until WebGL changes get merged\\n    // if (ipRange.z == 0.0 || sample >= ipRange.x && sample <= ipRange.y)\\n    // {\\n      sumVal = sumVal + sample;\\n    // }\\n\\n    // increment position\\n    curDist = curDist + 1.0;\\n    tpos = tpos + tstep;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayBounds.y) { break; }\\n  }\\n\\n  // process to get the color and opacity\\n  traverseVals[vNum] = getSimpleColor(sumVal, vNum, cNum);\\n}\\n\\nfn composite(rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>) -> vec4<f32>\\n{\\n  // initial ray position is at the beginning\\n  var rayPosSC: vec4<f32> = minPosSC;\\n\\n  // how many rows (tfuns) do we have in our tfunTexture\\n  var tfunRows: f32 = f32(textureDimensions(tfunTexture).y);\\n\\n  var curDist: f32 = 0.0;\\n  var computedColor: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);\\n  var sampleColor: vec4<f32>;\\n//VTK::Volume::TraverseCalls\\n\\n  loop\\n  {\\n    // for each volume, sample and accumulate color\\n//VTK::Volume::CompositeCalls\\n\\n    // increment position\\n    curDist = curDist + mapperUBO.SampleDistance;\\n    rayPosSC = rayPosSC + rayStepSC;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayLengthSC) { break; }\\n    if (computedColor.a > 0.98) { break; }\\n  }\\n  return computedColor;\\n}\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output: fragmentOutput;\\n\\n  var rayMax: f32 = textureSampleLevel(maxTexture, clampSampler, input.tcoordVS, 0.0).r;\\n  var rayMin: f32 = textureSampleLevel(minTexture, clampSampler, input.tcoordVS, 0.0).r;\\n\\n  // discard empty rays\\n  if (rayMax <= rayMin) { discard; }\\n  else\\n  {\\n    // compute start and end ray positions in view coordinates\\n    var minPosSC: vec4<f32> = rendererUBO.PCSCMatrix*vec4<f32>(2.0 * input.tcoordVS.x - 1.0, 1.0 - 2.0 * input.tcoordVS.y, rayMax, 1.0);\\n    minPosSC = minPosSC * (1.0 / minPosSC.w);\\n    var maxPosSC: vec4<f32> = rendererUBO.PCSCMatrix*vec4<f32>(2.0 * input.tcoordVS.x - 1.0, 1.0 - 2.0 * input.tcoordVS.y, rayMin, 1.0);\\n    maxPosSC = maxPosSC * (1.0 / maxPosSC.w);\\n\\n    var rayLengthSC: f32 = distance(minPosSC.xyz, maxPosSC.xyz);\\n    var rayStepSC: vec4<f32> = (maxPosSC - minPosSC)*(mapperUBO.SampleDistance/rayLengthSC);\\n    rayStepSC.w = 0.0;\\n\\n    var computedColor: vec4<f32>;\\n\\n//VTK::Volume::Loop\\n\\n//VTK::RenderEncoder::Impl\\n  }\\n\\n  return output;\\n}\\n&quot;,t.UBO=sy.newInstance({label:&quot;mapperUBO&quot;}),t.UBO.addEntry(&quot;SampleDistance&quot;,&quot;f32&quot;),t.SSBO=py.newInstance({label:&quot;volumeSSBO&quot;}),t.componentSSBO=py.newInstance({label:&quot;componentSSBO&quot;}),t.lutBuildTime={},Wt.obj(t.lutBuildTime,{mtime:0}),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUVolumePassFSQ&quot;),e.replaceShaderPosition=(e,t,n)=>{const r=t.getShaderDescription(&quot;vertex&quot;);r.addBuiltinOutput(&quot;vec4<f32>&quot;,&quot;@builtin(position) Position&quot;);let o=r.getCode();o=_v.substitute(o,&quot;//VTK::Position::Impl&quot;,[&quot;output.tcoordVS = vec2<f32>(vertexBC.x * 0.5 + 0.5, 1.0 - vertexBC.y * 0.5 - 0.5);&quot;,&quot;output.Position = vec4<f32>(vertexBC, 1.0);&quot;]).result,r.setCode(o),t.getShaderDescription(&quot;fragment&quot;).addBuiltinInput(&quot;vec4<f32>&quot;,&quot;@builtin(position) fragPos&quot;)},t.shaderReplacements.set(&quot;replaceShaderPosition&quot;,e.replaceShaderPosition),e.replaceShaderVolume=(e,n,r)=>{const o=n.getShaderDescription(&quot;fragment&quot;);let a=o.getCode();const i=[],s=[];for(let e=0;e<t.volumes.length;e++)t.volumes[e].getRenderable().getMapper().getBlendMode()===eg.COMPOSITE_BLEND?(i.push(`    sampleColor = processVolume(volTexture${e}, ${e}, ${t.rowStarts[e]}, rayPosSC, tfunRows);`),i.push(&quot;    computedColor = vec4<f32>(\\n          sampleColor.a * sampleColor.rgb * (1.0 - computedColor.a) + computedColor.rgb,\\n          (1.0 - computedColor.a)*sampleColor.a + computedColor.a);&quot;)):(s.push(`  sampleColor = traverseVals[${e}];`),s.push(&quot;  computedColor = vec4<f32>(\\n          sampleColor.a * sampleColor.rgb * (1.0 - computedColor.a) + computedColor.rgb,\\n          (1.0 - computedColor.a)*sampleColor.a + computedColor.a);&quot;));a=_v.substitute(a,&quot;//VTK::Volume::CompositeCalls&quot;,i).result,a=_v.substitute(a,&quot;//VTK::Volume::TraverseCalls&quot;,s).result,a=_v.substitute(a,&quot;//VTK::Volume::TraverseDec&quot;,[`var<private> traverseVals: array<vec4<f32>,${t.volumes.length}>;`]).result;let l=!1;for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getMapper().getBlendMode();n===eg.COMPOSITE_BLEND?l=!0:n===eg.MAXIMUM_INTENSITY_BLEND?a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[`    traverseMax(volTexture${e}, ${e}, ${e}, rayLengthSC, minPosSC, rayStepSC);`,`    computedColor = traverseVals[${e}];`,&quot;//VTK::Volume::Loop&quot;]).result:n===eg.MINIMUM_INTENSITY_BLEND?a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[`    traverseMin(volTexture${e}, ${e}, ${e}, rayLengthSC, minPosSC, rayStepSC);`,`    computedColor = traverseVals[${e}];`,&quot;//VTK::Volume::Loop&quot;]).result:n===eg.AVERAGE_INTENSITY_BLEND?a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[`    traverseAverage(volTexture${e}, ${e}, ${e}, rayLengthSC, minPosSC, rayStepSC);`,`    computedColor = traverseVals[${e}];`,&quot;//VTK::Volume::Loop&quot;]).result:n===eg.ADDITIVE_INTENSITY_BLEND&&(a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[`    traverseAdditive(volTexture${e}, ${e}, ${e}, rayLengthSC, minPosSC, rayStepSC);`,`    computedColor = traverseVals[${e}];`,&quot;//VTK::Volume::Loop&quot;]).result)}l&&(a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[&quot;    computedColor = composite(rayLengthSC, minPosSC, rayStepSC);&quot;]).result),o.setCode(a)},t.shaderReplacements.set(&quot;replaceShaderVolume&quot;,e.replaceShaderVolume),e.updateLUTImage=n=>{let r=e.getMTime();for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),o=n.getMapper().getInputData();r=Math.max(r,n.getMTime(),o.getMTime())}if(r<t.lutBuildTime.getMTime())return;t.numRows=0,t.rowStarts=[];for(let e=0;e<t.volumes.length;e++){t.rowStarts.push(t.numRows);const n=t.volumes[e].getRenderable(),r=n.getMapper(),o=n.getProperty(),a=r.getInputData(),i=(a.getPointData()&&a.getPointData().getScalars()).getNumberOfComponents(),s=o.getIndependentComponents()?i:1;t.numRows+=s}const o=new Uint8ClampedArray(2*t.numRows*t.rowLength*4),a=new Float32Array(2*t.numRows*t.rowLength);let i=0;const s=new Float32Array(3*t.rowLength),l=t.rowLength;for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),r=n.getMapper(),c=n.getProperty(),u=r.getInputData(),d=(u.getPointData()&&u.getPointData().getScalars()).getNumberOfComponents(),p=c.getIndependentComponents()?d:1;for(let e=0;e<p;++e){const n=c.getRGBTransferFunction(e),r=n.getRange();n.getTable(r[0],r[1],l,s,1);let u=i*l*4;for(let e=0;e<l;++e){o[u+4*e]=255*s[3*e],o[u+4*e+1]=255*s[3*e+1],o[u+4*e+2]=255*s[3*e+2],o[u+4*e+3]=255;for(let t=0;t<4;t++)o[u+4*(l+e)+t]=o[u+4*e+t]}const d=c.getScalarOpacity(e),p=t.sampleDist/c.getScalarOpacityUnitDistance(e),f=d.getRange();d.getTable(f[0],f[1],l,s,1),u=i*l;for(let e=0;e<l;++e)a[u+e]=1-(1-s[e])**p,a[u+e+l]=a[u+e];i+=2}}{const e={nativeArray:o,width:t.rowLength,height:2*t.numRows,depth:1,format:&quot;rgba8unorm&quot;},r=n.getTextureManager().getTexture(e).createView(&quot;tfunTexture&quot;);t.textureViews[2]=r}{const e={nativeArray:a,width:t.rowLength,height:2*t.numRows,depth:1,format:&quot;r16float&quot;},r=n.getTextureManager().getTexture(e).createView(&quot;ofunTexture&quot;);t.textureViews[3]=r}t.lutBuildTime.modified()},e.updateSSBO=n=>{let r=Math.max(e.getMTime(),t.WebGPURenderer.getStabilizedTime());for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),o=n.getMapper(),a=o.getInputData();r=Math.max(r,n.getMTime(),a.getMTime(),o.getMTime())}if(r<t.SSBO.getSendTime())return;const o=t.WebGPURenderer.getStabilizedCenterByReference();t.SSBO.clearData(),t.SSBO.setNumberOfInstances(t.volumes.length);const a=new Float64Array(16*t.volumes.length),i=new Float64Array(16*t.volumes.length),s=new Float64Array(4*t.volumes.length),l=new Float64Array(4*t.volumes.length),c=new Float64Array(4*t.volumes.length),u=new Float64Array(4*t.volumes.length);for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),r=n.getMapper().getInputData();m(fy),x(fy,fy,o);const d=n.getMatrix();h(gy,d),v(gy,gy),b(fy,gy,fy);const p=r.getWorldToIndex();b(fy,p,fy);const f=r.getDimensions();m(gy),C(gy,gy,[1/f[0],1/f[1],1/f[2]]),b(fy,gy,fy);for(let t=0;t<16;t++)a[16*e+t]=fy[t];v(fy,fy);for(let t=0;t<4;t++)i[16*e+4*t]=fy[4*t],i[16*e+4*t+1]=fy[4*t+1],i[16*e+4*t+2]=fy[4*t+2],i[16*e+4*t+3]=0;s[4*e]=1/f[0],s[4*e+1]=1/f[1],s[4*e+2]=1/f[2],s[4*e+3]=1,l[4*e]=n.getProperty().getShade()?1:0;const g=r.getSpacing();c[4*e]=g[0],c[4*e+1]=g[1],c[4*e+2]=g[2],c[4*e+3]=1;const T=t.textureViews[e+4].getTexture().getScale(),y=n.getProperty().getIpScalarRange();u[4*e]=y[0]/T,u[4*e+1]=y[1]/T,u[4*e+2]=n.getProperty().getFilterMode()}t.SSBO.addEntry(&quot;SCTCMatrix&quot;,&quot;mat4x4<f32>&quot;),t.SSBO.addEntry(&quot;planeNormals&quot;,&quot;mat4x4<f32>&quot;),t.SSBO.addEntry(&quot;shade&quot;,&quot;vec4<f32>&quot;),t.SSBO.addEntry(&quot;tstep&quot;,&quot;vec4<f32>&quot;),t.SSBO.addEntry(&quot;spacing&quot;,&quot;vec4<f32>&quot;),t.SSBO.addEntry(&quot;ipScalarRange&quot;,&quot;vec4<f32>&quot;),t.SSBO.setAllInstancesFromArray(&quot;SCTCMatrix&quot;,a),t.SSBO.setAllInstancesFromArray(&quot;planeNormals&quot;,i),t.SSBO.setAllInstancesFromArray(&quot;shade&quot;,l),t.SSBO.setAllInstancesFromArray(&quot;tstep&quot;,s),t.SSBO.setAllInstancesFromArray(&quot;spacing&quot;,c),t.SSBO.setAllInstancesFromArray(&quot;ipScalarRange&quot;,u),t.SSBO.send(n),t.componentSSBO.clearData(),t.componentSSBO.setNumberOfInstances(t.numRows);const d=new Float64Array(t.numRows),p=new Float64Array(t.numRows),f=new Float64Array(t.numRows),g=new Float64Array(t.numRows),T=new Float64Array(t.numRows),y=new Float64Array(t.numRows),S=new Float64Array(t.numRows),A=new Float64Array(t.numRows);let I=0;for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),r=n.getMapper(),o=n.getProperty(),a=r.getInputData(),i=(a.getPointData()&&a.getPointData().getScalars()).getNumberOfComponents(),s=o.getIndependentComponents(),l=t.textureViews[e+4].getTexture().getFormat(),c=Xv(l),u={scale:[255],offset:[0]};2===c.elementSize&&&quot;float&quot;===c.sampleType&&(u.scale[0]=1);for(let e=0;e<i;e++){const t=s?e:0,n=u.scale[e],r=o.getScalarOpacity(t).getRange(),a=n/(r[1]-r[0]),i=(u.offset[e]-r[0])/(r[1]-r[0]);g[I]=i,f[I]=a;const l=o.getRGBTransferFunction(t).getRange();if(p[I]=(u.offset[e]-l[0])/(l[1]-l[0]),d[I]=n/(l[1]-l[0]),o.getUseGradientOpacity(t)){const e=o.getGradientOpacityMinimumOpacity(t),r=o.getGradientOpacityMaximumOpacity(t);T[I]=e,y[I]=r;const a=[o.getGradientOpacityMinimumValue(t),o.getGradientOpacityMaximumValue(t)];A[I]=n*(r-e)/(a[1]-a[0]),S[I]=-a[0]*(r-e)/(a[1]-a[0])+e}else T[I]=1,y[I]=1,A[I]=0,S[I]=1;I++}}t.componentSSBO.addEntry(&quot;cScale&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;cShift&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;oScale&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;oShift&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;goShift&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;goScale&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;gomin&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;gomax&quot;,&quot;f32&quot;),t.componentSSBO.setAllInstancesFromArray(&quot;cScale&quot;,d),t.componentSSBO.setAllInstancesFromArray(&quot;cShift&quot;,p),t.componentSSBO.setAllInstancesFromArray(&quot;oScale&quot;,f),t.componentSSBO.setAllInstancesFromArray(&quot;oShift&quot;,g),t.componentSSBO.setAllInstancesFromArray(&quot;goScale&quot;,A),t.componentSSBO.setAllInstancesFromArray(&quot;goShift&quot;,S),t.componentSSBO.setAllInstancesFromArray(&quot;gomin&quot;,T),t.componentSSBO.setAllInstancesFromArray(&quot;gomax&quot;,y),t.componentSSBO.send(n)};const n=e.updateBuffers;e.updateBuffers=()=>{n();let r=t.volumes[0].getRenderable().getMapper().getSampleDistance();for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getMapper().getSampleDistance();n<r&&(r=n)}t.sampleDist!==r&&(t.sampleDist=r,t.UBO.setValue(&quot;SampleDistance&quot;,r),t.UBO.sendIfNeeded(t.device));for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getMapper().getInputData(),r=t.device.getTextureManager().getTextureForImageData(n);if(!t.textureViews[e+4]||t.textureViews[e+4].getTexture()!==r){const n=r.createView(`volTexture${e}`);t.textureViews[e+4]=n}}if(t.volumes.length<t.lastVolumeLength)for(let e=t.volumes.length;e<t.lastVolumeLength;e++)t.textureViews.pop();t.lastVolumeLength=t.volumes.length,e.updateLUTImage(t.device),e.updateSSBO(t.device),t.clampSampler||(t.clampSampler=vT.newInstance({label:&quot;clampSampler&quot;}),t.clampSampler.create(t.device,{minFilter:&quot;linear&quot;,magFilter:&quot;linear&quot;}))},e.computePipelineHash=()=>{t.pipelineHash=&quot;volfsq&quot;;for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getMapper().getBlendMode();t.pipelineHash+=`${n}`}},e.setVolumes=n=>{if(!t.volumes||t.volumes.length!==n.length)return t.volumes=[...n],void e.modified();for(let r=0;r<n.length;r++)if(n[r]!==t.volumes[r])return t.volumes=[...n],void e.modified()};const r=e.getBindables;e.getBindables=()=>{const e=r();return e.push(t.componentSSBO),e.push(t.clampSampler),e}}(e,t)}var vy={newInstance:Wt.newInstance(hy,&quot;vtkWebGPUVolumePassFSQ&quot;),extend:hy};const{Representation:Ty}=os,{BufferUsage:yy,PrimitiveTypes:by}=ny,xy=[[0,4,6],[0,6,2],[1,3,7],[1,7,5],[0,5,4],[0,1,5],[2,6,7],[2,7,3],[0,3,1],[0,2,3],[4,5,7],[4,7,6]],Cy={colorTextureView:null,depthTextureView:null,volumes:null};function Sy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Cy,n),ev.extend(e,t,n),t._mapper=sT.newInstance(),t._mapper.setFragmentShaderTemplate(&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Select::Dec\\n\\n//VTK::VolumePass::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output : fragmentOutput;\\n\\n  //VTK::Select::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::VolumePass::Impl\\n\\n  // use the maximum (closest) of the current value and the zbuffer\\n  // the blend func will then take the min to find the farthest stop value\\n  var stopval: f32 = max(input.fragPos.z, textureLoad(opaquePassDepthTexture, vec2<i32>(i32(input.fragPos.x), i32(input.fragPos.y)), 0));\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;),t._mapper.getShaderReplacements().set(&quot;replaceShaderVolumePass&quot;,((e,t,n)=>{t.getShaderDescription(&quot;fragment&quot;).addBuiltinInput(&quot;vec4<f32>&quot;,&quot;@builtin(position) fragPos&quot;)})),t._boundsPoly=gu.newInstance(),t._lastMTimes=[],Wt.setGet(e,t,[&quot;colorTextureView&quot;,&quot;depthTextureView&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUVolumePass&quot;),e.initialize=n=>{t._clearEncoder||e.createClearEncoder(n),t._mergeEncoder||e.createMergeEncoder(n),t._copyEncoder||e.createCopyEncoder(n),t._depthRangeEncoder||e.createDepthRangeEncoder(n),t.fullScreenQuad||(t.fullScreenQuad=vy.newInstance(),t.fullScreenQuad.setDevice(n.getDevice()),t.fullScreenQuad.setTextureViews([...t._depthRangeEncoder.getColorTextureViews()])),t._volumeCopyQuad||(t._volumeCopyQuad=uT.newInstance(),t._volumeCopyQuad.setPipelineHash(&quot;volpassfsq&quot;),t._volumeCopyQuad.setDevice(n.getDevice()),t._volumeCopyQuad.setFragmentShaderTemplate(&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output: fragmentOutput;\\n\\n  var computedColor: vec4<f32> = textureSample(volumePassColorTexture,\\n    volumePassColorTextureSampler, mapperUBO.tscale*input.tcoordVS);\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;),t._copyUBO=sy.newInstance({label:&quot;mapperUBO&quot;}),t._copyUBO.addEntry(&quot;tscale&quot;,&quot;vec2<f32>&quot;),t._volumeCopyQuad.setUBO(t._copyUBO),t._volumeCopyQuad.setTextureViews([t._colorTextureView]))},e.traverse=(n,r)=>{if(t.deleted)return;t._currentParent=r,e.initialize(r),e.computeTiming(r),e.renderDepthBounds(n,r),t._firstGroup=!0;const o=r.getDevice(),a=o.getHandle().limits.maxSampledTexturesPerShaderStage-4;if(t.volumes.length>a){const o=n.getRenderable().getActiveCamera().getPosition(),i=[];for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getBounds(),r=[.5*(n[1]+n[0]),.5*(n[3]+n[2]),.5*(n[5]+n[4])];i[e]=Go(r,o)}const s=[...Array(t.volumes.length).keys()];s.sort(((e,t)=>i[t]-i[e]));let l=[],c=s.length%a;for(let o=0;o<s.length;o++)l.push(t.volumes[s[o]]),l.length>=c&&(e.rayCastPass(r,n,l),l=[],c=a,t._firstGroup=!1)}else e.rayCastPass(r,n,t.volumes);if(t._volumeCopyQuad.setWebGPURenderer(n),t._useSmallViewport){const e=t._colorTextureView.getTexture().getWidth(),n=t._colorTextureView.getTexture().getHeight();t._copyUBO.setArray(&quot;tscale&quot;,[t._smallViewportWidth/e,t._smallViewportHeight/n])}else t._copyUBO.setArray(&quot;tscale&quot;,[1,1]);t._copyUBO.sendIfNeeded(o),t._copyEncoder.setColorTextureView(0,t.colorTextureView),t._copyEncoder.attachTextureViews(),t._copyEncoder.begin(r.getCommandEncoder()),n.scissorAndViewport(t._copyEncoder),t._volumeCopyQuad.prepareAndDraw(t._copyEncoder),t._copyEncoder.end()},e.delete=Wt.chain((()=>{t._animationRateSubscription&&(t._animationRateSubscription.unsubscribe(),t._animationRateSubscription=null)}),e.delete),e.computeTiming=e=>{const n=e.getRenderable().getInteractor();if(null==t._lastScale){const e=t.volumes[0].getRenderable().getMapper();t._lastScale=e.getInitialInteractionScale()||1}t._useSmallViewport=!1,n.isAnimating()&&t._lastScale>1.5&&(t._useSmallViewport=!0),t._colorTexture.resize(e.getCanvas().width,e.getCanvas().height),t._animationRateSubscription||(t._animationRateSubscription=n.onAnimationFrameRateUpdate((()=>{const e=t.volumes[0].getRenderable().getMapper();if(e.getAutoAdjustSampleDistances()){const e=n.getRecentAnimationFrameRate(),r=t._lastScale*n.getDesiredUpdateRate()/e;t._lastScale=r,t._lastScale>400&&(t._lastScale=400)}else t._lastScale=e.getImageSampleDistance()*e.getImageSampleDistance();t._lastScale<1.5&&(t._lastScale=1.5)})))},e.rayCastPass=(e,n,r)=>{const o=t._firstGroup?t._clearEncoder:t._mergeEncoder;o.attachTextureViews(),o.begin(e.getCommandEncoder());let a=t._colorTextureView.getTexture().getWidth(),i=t._colorTextureView.getTexture().getHeight();if(t._useSmallViewport){const n=e.getCanvas(),r=1/Math.sqrt(t._lastScale);t._smallViewportWidth=Math.ceil(r*n.width),t._smallViewportHeight=Math.ceil(r*n.height),a=t._smallViewportWidth,i=t._smallViewportHeight}o.getHandle().setViewport(0,0,a,i,0,1),o.getHandle().setScissorRect(0,0,a,i),t.fullScreenQuad.setWebGPURenderer(n),t.fullScreenQuad.setVolumes(r),t.fullScreenQuad.prepareAndDraw(o),o.end()},e.renderDepthBounds=(n,r)=>{e.updateDepthPolyData(n);const o=t._boundsPoly,a=o.getPoints(),i=o.getPolys();let s={hash:`vp${i.getMTime()}`,usage:yy.Index,cells:i,numberOfPoints:a.getNumberOfPoints(),primitiveType:by.Triangles,representation:Ty.SURFACE};const l=r.getDevice().getBufferManager().getBuffer(s);t._mapper.getVertexInput().setIndexBuffer(l),s={usage:yy.PointArray,format:&quot;float32x4&quot;,hash:`vp${a.getMTime()}${i.getMTime()}`,dataArray:a,indexBuffer:l,packExtra:!0};const c=r.getDevice().getBufferManager().getBuffer(s);t._mapper.getVertexInput().addBuffer(c,[&quot;vertexBC&quot;]),t._mapper.setNumberOfVertices(c.getSizeInBytes()/c.getStrideInBytes()),e.drawDepthRange(n,r)},e.updateDepthPolyData=e=>{let n=!1;for(let e=0;e<t.volumes.length;e++){const r=t.volumes[e].getMTime();t._lastMTimes[e]&&r===t._lastMTimes[e]||(n=!0,t._lastMTimes[e]=r)}const r=e.getStabilizedTime();if((t._lastMTimes.length<=t.volumes.length||r!==t._lastMTimes[t.volumes.length])&&(n=!0,t._lastMTimes[t.volumes.length]=r),!n)return;const o=e.getStabilizedCenterByReference(),a=8*t.volumes.length,i=new Float64Array(3*a),s=12*t.volumes.length,l=new Uint16Array(4*s);for(let e=0;e<t.volumes.length;e++){t.volumes[e].getBoundingCubePoints(i,24*e);let n=12*e*4;const r=8*e;for(let e=0;e<12;e++)l[n++]=3,l[n++]=r+xy[e][0],l[n++]=r+xy[e][1],l[n++]=r+xy[e][2]}for(let e=0;e<i.length;e+=3)i[e]-=o[0],i[e+1]-=o[1],i[e+2]-=o[2];t._boundsPoly.getPoints().setData(i,3),t._boundsPoly.getPoints().modified(),t._boundsPoly.getPolys().setData(l,1),t._boundsPoly.getPolys().modified(),t._boundsPoly.modified()},e.drawDepthRange=(n,r)=>{t._depthRangeTexture.resizeToMatch(t.colorTextureView.getTexture()),t._depthRangeTexture2.resizeToMatch(t.colorTextureView.getTexture()),t._depthRangeEncoder.attachTextureViews(),e.setCurrentOperation(&quot;volumeDepthRangePass&quot;),n.setRenderEncoder(t._depthRangeEncoder),n.volumeDepthRangePass(!0),t._mapper.setWebGPURenderer(n),t._mapper.prepareToDraw(t._depthRangeEncoder),t._mapper.registerDrawCallback(t._depthRangeEncoder),n.volumeDepthRangePass(!1)},e.createDepthRangeEncoder=e=>{const n=e.getDevice();t._depthRangeEncoder=gT.newInstance({label:&quot;VolumePass DepthRange&quot;}),t._depthRangeEncoder.setPipelineHash(&quot;volr&quot;),t._depthRangeEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor1&quot;),t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor2&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor1 = vec4<f32>(input.fragPos.z, 0.0, 0.0, 0.0);&quot;,&quot;output.outColor2 = vec4<f32>(stopval, 0.0, 0.0, 0.0);&quot;]).result,t.setCode(n)})),t._depthRangeEncoder.setDescription({colorAttachments:[{view:null,clearValue:[0,0,0,0],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;},{view:null,clearValue:[1,1,1,1],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;}]}),t._depthRangeEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;r16float&quot;,blend:{color:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;,operation:&quot;max&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;,operation:&quot;max&quot;}}},{format:&quot;r16float&quot;,blend:{color:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;,operation:&quot;min&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;,operation:&quot;min&quot;}}}]}}),t._depthRangeTexture=ST.newInstance({label:&quot;volumePassMaxDepth&quot;}),t._depthRangeTexture.create(n,{width:e.getCanvas().width,height:e.getCanvas().height,format:&quot;r16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING});const r=t._depthRangeTexture.createView(&quot;maxTexture&quot;);t._depthRangeEncoder.setColorTextureView(0,r),t._depthRangeTexture2=ST.newInstance({label:&quot;volumePassDepthMin&quot;}),t._depthRangeTexture2.create(n,{width:e.getCanvas().width,height:e.getCanvas().height,format:&quot;r16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING});const o=t._depthRangeTexture2.createView(&quot;minTexture&quot;);t._depthRangeEncoder.setColorTextureView(1,o),t._mapper.setDevice(e.getDevice()),t._mapper.setTextureViews([t.depthTextureView])},e.createClearEncoder=e=>{t._colorTexture=ST.newInstance({label:&quot;volumePassColor&quot;}),t._colorTexture.create(e.getDevice(),{width:e.getCanvas().width,height:e.getCanvas().height,format:&quot;bgra8unorm&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC}),t._colorTextureView=t._colorTexture.createView(&quot;volumePassColorTexture&quot;),t._colorTextureView.addSampler(e.getDevice(),{minFilter:&quot;linear&quot;,magFilter:&quot;linear&quot;}),t._clearEncoder=gT.newInstance({label:&quot;VolumePass Clear&quot;}),t._clearEncoder.setColorTextureView(0,t._colorTextureView),t._clearEncoder.setDescription({colorAttachments:[{view:null,clearValue:[0,0,0,0],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;}]}),t._clearEncoder.setPipelineHash(&quot;volpf&quot;),t._clearEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;bgra8unorm&quot;,blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})},e.createCopyEncoder=e=>{t._copyEncoder=gT.newInstance({label:&quot;volumePassCopy&quot;}),t._copyEncoder.setDescription({colorAttachments:[{view:null,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}]}),t._copyEncoder.setPipelineHash(&quot;volcopypf&quot;),t._copyEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;rgba16float&quot;,blend:{color:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})},e.createMergeEncoder=e=>{t._mergeEncoder=gT.newInstance({label:&quot;volumePassMerge&quot;}),t._mergeEncoder.setColorTextureView(0,t._colorTextureView),t._mergeEncoder.setDescription({colorAttachments:[{view:null,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}]}),t._mergeEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor = vec4<f32>(computedColor.rgb, computedColor.a);&quot;]).result,t.setCode(n)})),t._mergeEncoder.setPipelineHash(&quot;volpf&quot;),t._mergeEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;bgra8unorm&quot;,blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})},e.setVolumes=n=>{if(!t.volumes||t.volumes.length!==n.length)return t.volumes=[...n],void e.modified();for(let r=0;r<n.length;r++)if(n[r]!==t.volumes[r])return t.volumes=[...n],void e.modified()}}(e,t)}var Ay={newInstance:Wt.newInstance(Sy,&quot;vtkWebGPUVolumePass&quot;),extend:Sy};const Iy={opaqueActorCount:0,translucentActorCount:0,volumes:null,opaqueRenderEncoder:null,translucentPass:null,volumePass:null};function wy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Iy,n),ev.extend(e,t,n),Wt.setGet(e,t,[&quot;opaquePass&quot;,&quot;translucentPass&quot;,&quot;volumePass&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkForwardPass&quot;),e.traverse=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(t.deleted)return;t._currentParent=r,e.setCurrentOperation(&quot;buildPass&quot;),n.traverse(e),t.opaquePass||(t.opaquePass=wT.newInstance());const o=n.getRenderable().getNumberOfLayers(),a=n.getChildren();for(let r=0;r<o;r++)for(let o=0;o<a.length;o++){const i=a[o],s=n.getRenderable().getRenderers()[o];s.getDraw()&&s.getLayer()===r&&(t.opaqueActorCount=0,t.translucentActorCount=0,t.volumes=[],e.setCurrentOperation(&quot;queryPass&quot;),i.traverse(e),e.setCurrentOperation(&quot;cameraPass&quot;),i.traverse(e),t.opaquePass.traverse(i,n),t.translucentActorCount>0&&(t.translucentPass||(t.translucentPass=RT.newInstance()),t.translucentPass.setColorTextureView(t.opaquePass.getColorTextureView()),t.translucentPass.setDepthTextureView(t.opaquePass.getDepthTextureView()),t.translucentPass.traverse(i,n)),t.volumes.length>0&&(t.volumePass||(t.volumePass=Ay.newInstance()),t.volumePass.setColorTextureView(t.opaquePass.getColorTextureView()),t.volumePass.setDepthTextureView(t.opaquePass.getDepthTextureView()),t.volumePass.setVolumes(t.volumes),t.volumePass.traverse(i,n)),e.finalPass(n,i))}},e.finalPass=(n,r)=>{t._finalBlitEncoder||e.createFinalBlitEncoder(n),t._finalBlitOutputTextureView.createFromTextureHandle(n.getCurrentTexture(),{depth:1,format:n.getPresentationFormat()}),t._finalBlitEncoder.attachTextureViews(),t._finalBlitEncoder.begin(n.getCommandEncoder()),r.scissorAndViewport(t._finalBlitEncoder),t._fullScreenQuad.prepareAndDraw(t._finalBlitEncoder),t._finalBlitEncoder.end()},e.createFinalBlitEncoder=e=>{t._finalBlitEncoder=gT.newInstance({label:&quot;forwardPassBlit&quot;}),t._finalBlitEncoder.setDescription({colorAttachments:[{view:null,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}]}),t._finalBlitEncoder.setPipelineHash(&quot;fpf&quot;),t._finalBlitEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:e.getPresentationFormat(),blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}}),t._fsqSampler=vT.newInstance({label:&quot;finalPassSampler&quot;}),t._fsqSampler.create(e.getDevice(),{minFilter:&quot;linear&quot;,magFilter:&quot;linear&quot;}),t._fullScreenQuad=uT.newInstance(),t._fullScreenQuad.setDevice(e.getDevice()),t._fullScreenQuad.setPipelineHash(&quot;fpfsq&quot;),t._fullScreenQuad.setTextureViews([t.opaquePass.getColorTextureView()]),t._fullScreenQuad.setAdditionalBindables([t._fsqSampler]),t._fullScreenQuad.setFragmentShaderTemplate(&quot;\\n//VTK::Mapper::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output: fragmentOutput;\\n\\n  var computedColor: vec4<f32> = clamp(textureSampleLevel(opaquePassColorTexture, finalPassSampler, input.tcoordVS, 0.0),vec4<f32>(0.0),vec4<f32>(1.0));\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;),t._finalBlitOutputTextureView=bT.newInstance(),t._finalBlitEncoder.setColorTextureView(0,t._finalBlitOutputTextureView)},e.incrementOpaqueActorCount=()=>t.opaqueActorCount++,e.incrementTranslucentActorCount=()=>t.translucentActorCount++,e.addVolume=e=>{t.volumes.push(e)}}(e,t)}var Oy={newInstance:Wt.newInstance(wy,&quot;vtkForwardPass&quot;),extend:wy};const{VtkDataTypes:Py}=xs,Ry={handle:null,device:null};function My(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ry,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;device&quot;]),function(e,t){function n(e){if(e.imageData){e.dataArray=e.imageData.getPointData().getScalars(),e.time=e.dataArray.getMTime(),e.nativeArray=e.dataArray.getData();const t=e.imageData.getDimensions();switch(e.width=t[0],e.height=t[1],e.depth=t[2],e.dataArray.getNumberOfComponents()){case 1:e.format=&quot;r&quot;;break;case 2:e.format=&quot;rg&quot;;break;default:e.format=&quot;rgba&quot;}switch(e.dataArray.getDataType()){case Py.UNSIGNED_CHAR:e.format+=&quot;8unorm&quot;;break;case Py.FLOAT:case Py.UNSIGNED_INT:case Py.INT:case Py.DOUBLE:case Py.UNSIGNED_SHORT:case Py.SHORT:default:e.format+=&quot;16float&quot;}}e.image&&(e.width=e.image.width,e.height=e.image.height,e.depth=1,e.format=&quot;rgba8unorm&quot;,e.flip=!0,e.usage=GPUTextureUsage.STORAGE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.RENDER_ATTACHMENT),e.jsImageData&&(e.width=e.jsImageData.width,e.height=e.jsImageData.height,e.depth=1,e.format=&quot;rgba8unorm&quot;,e.flip=!0,e.nativeArray=e.jsImageData.data,e.usage=GPUTextureUsage.STORAGE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.RENDER_ATTACHMENT),e.imageBitmap&&(e.width=e.imageBitmap.width,e.height=e.imageBitmap.height,e.depth=1,e.format=&quot;rgba8unorm&quot;,e.flip=!0,e.usage=GPUTextureUsage.STORAGE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.RENDER_ATTACHMENT),e.canvas&&(e.width=e.canvas.width,e.height=e.canvas.height,e.depth=1,e.format=&quot;rgba8unorm&quot;,e.flip=!0,e.usage=GPUTextureUsage.STORAGE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.RENDER_ATTACHMENT)}function r(e){const n=ST.newInstance({label:e.label});return n.create(t.device,{width:e.width,height:e.height,depth:e.depth,format:e.format,usage:e.usage,mipLevel:e.mipLevel}),(e.nativeArray||e.image||e.canvas||e.imageBitmap)&&n.writeImageData(e),n}t.classHierarchy.push(&quot;vtkWebGPUTextureManager&quot;),e.getTexture=e=>e.hash?t.device.getCachedObject(e.hash,r,e):r(e),e.getTextureForImageData=e=>{const r={time:e.getMTime()};return r.imageData=e,n(r),r.hash=r.time+r.format+r.mipLevel,t.device.getTextureManager().getTexture(r)},e.getTextureForVTKTexture=function(e){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:void 0;const o={time:e.getMTime(),label:r};return e.getInputData()?o.imageData=e.getInputData():e.getImage()?o.image=e.getImage():e.getJsImageData()?o.jsImageData=e.getJsImageData():e.getImageBitmap()?o.imageBitmap=e.getImageBitmap():e.getCanvas()&&(o.canvas=e.getCanvas()),n(o),o.mipLevel=e.getMipLevel(),o.hash=o.time+o.format+o.mipLevel,t.device.getTextureManager().getTexture(o)}}(e,t)}var Ey={newInstance:Wt.newInstance(My),extend:My};class Vy extends Map{constructor(){super(),this.registry=new FinalizationRegistry((e=>{const t=super.get(e);t&&t.deref&&void 0===t.deref()&&super.delete(e)}))}getValue(e){const t=super.get(e);if(t){const n=t.deref();if(void 0!==n)return n;super.delete(e)}}setValue(e,t){let n;return t&&&quot;object&quot;==typeof t&&(n=new WeakRef(t),this.registry.register(t,e),super.set(e,n)),n}}const Dy={handle:null,pipelines:null,shaderCache:null,bindGroupLayouts:null,bufferManager:null,textureManager:null};function Ly(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Dy,n),ht(e,t),Ct(e,t,[&quot;handle&quot;]),Tt(e,t,[&quot;bufferManager&quot;,&quot;shaderCache&quot;,&quot;textureManager&quot;]),t.objectCache=new Vy,t.shaderCache=_v.newInstance(),t.shaderCache.setDevice(e),t.bindGroupLayouts=[],t.bufferManager=ny.newInstance(),t.bufferManager.setDevice(e),t.textureManager=Ey.newInstance(),t.textureManager.setDevice(e),t.pipelines={},function(e,t){t.classHierarchy.push(&quot;vtkWebGPUDevice&quot;),e.initialize=e=>{t.handle=e},e.createCommandEncoder=()=>t.handle.createCommandEncoder(),e.submitCommandEncoder=e=>{t.handle.queue.submit([e.finish()])},e.getShaderModule=e=>t.shaderCache.getShaderModule(e),e.getBindGroupLayout=e=>{if(!e.entries)return null;for(let t=0;t<e.entries.length;t++){const n=e.entries[t];n.binding=n.binding||0,n.visibility=n.visibility||GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT}const n=JSON.stringify(e);for(let e=0;e<t.bindGroupLayouts.length;e++)if(t.bindGroupLayouts[e].sval===n)return t.bindGroupLayouts[e].layout;const r=t.handle.createBindGroupLayout(e);return t.bindGroupLayouts.push({sval:n,layout:r}),r},e.getBindGroupLayoutDescription=e=>{for(let n=0;n<t.bindGroupLayouts.length;n++)if(t.bindGroupLayouts[n].layout===e)return t.bindGroupLayouts[n].sval;return vtkErrorMacro(&quot;layout not found&quot;),console.trace(),null},e.getPipeline=e=>e in t.pipelines?t.pipelines[e]:null,e.createPipeline=(n,r)=>{r.initialize(e,n),t.pipelines[n]=r},e.onSubmittedWorkDone=()=>t.handle.queue.onSubmittedWorkDone(),e.hasCachedObject=e=>t.objectCache.getValue(e),e.getCachedObject=function(e,n){if(!e)return vtkErrorMacro(&quot;attempt to cache an object without a hash&quot;),null;const r=t.objectCache.getValue(e);if(r)return r;for(var o=arguments.length,a=new Array(o>2?o-2:0),i=2;i<o;i++)a[i-2]=arguments[i];const s=n(...a);return t.objectCache.setValue(e,s),s}}(e,t)}var By={newInstance:Mt(Ly,&quot;vtkWebGPUDevice&quot;),extend:Ly};const Ny={selectionRenderEncoder:null,colorTexture:null,depthTexture:null};function Fy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ny,n),ev.extend(e,t,n),Wt.get(e,t,[&quot;colorTexture&quot;,&quot;depthTexture&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUHardwareSelectionPass&quot;),e.traverse=(n,r)=>{if(t.deleted)return;t._currentParent=null,e.setCurrentOperation(&quot;buildPass&quot;),n.traverse(e);const o=n.getDevice();if(t.selectionRenderEncoder)t.colorTexture.resize(n.getCanvas().width,n.getCanvas().height),t.depthTexture.resizeToMatch(t.colorTexture);else{e.createRenderEncoder(),t.colorTexture=ST.newInstance({label:&quot;hardwareSelectorColor&quot;}),t.colorTexture.create(o,{width:n.getCanvas().width,height:n.getCanvas().height,format:&quot;rgba32uint&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.COPY_SRC});const r=t.colorTexture.createView(&quot;hardwareSelectColorTexture&quot;);t.selectionRenderEncoder.setColorTextureView(0,r),t.depthTexture=ST.newInstance({label:&quot;hardwareSelectorDepth&quot;}),t.depthTexture.create(o,{width:n.getCanvas().width,height:n.getCanvas().height,format:&quot;depth32float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.COPY_SRC});const a=t.depthTexture.createView(&quot;hardwareSelectDepthTexture&quot;);t.selectionRenderEncoder.setDepthTextureView(a)}t.selectionRenderEncoder.attachTextureViews(),r.setRenderEncoder(t.selectionRenderEncoder),e.setCurrentOperation(&quot;cameraPass&quot;),r.traverse(e),e.setCurrentOperation(&quot;opaquePass&quot;),r.traverse(e)},e.createRenderEncoder=()=>{t.selectionRenderEncoder=gT.newInstance({label:&quot;HardwareSelectionPass&quot;}),t.selectionRenderEncoder.setPipelineHash(&quot;sel&quot;),t.selectionRenderEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<u32>&quot;,&quot;outColor&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor = vec4<u32>(mapperUBO.PropID, compositeID, 0u, 0u);&quot;]).result,t.setCode(n)})),t.selectionRenderEncoder.getDescription().colorAttachments[0].clearValue=[0,0,0,0],t.selectionRenderEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},depthStencil:{depthWriteEnabled:!0,depthCompare:&quot;greater&quot;,format:&quot;depth32float&quot;},fragment:{targets:[{format:&quot;rgba32uint&quot;,blend:void 0}]}})}}(e,t)}var _y={newInstance:Wt.newInstance(Fy,&quot;vtkWebGPUHardwareSelectionPass&quot;),extend:Fy};const{SelectionContent:ky,SelectionField:Gy}=wp,{FieldAssociations:Uy}=Us,{vtkErrorMacro:zy}=Wt;function Wy(e){return`${e.propID} ${e.compositeID}`}function Hy(e,t,n,r){const o=4*((n.height-t-1)*n.colorBufferWidth+e)+r;return n.colorValues[o]}function jy(e,t,n,r){const o=n<0?0:n;if(0===o){if(r[0]=t[0],r[1]=t[1],t[0]<0||t[0]>=e.width||t[1]<0||t[1]>=e.height)return null;const n=Hy(t[0],t[1],e,0);if(n<=0)return null;const o={};o.propID=n;let a=Hy(t[0],t[1],e,1);if((a<0||a>16777215)&&(a=0),o.compositeID=a,e.captureZValues){const n=(e.height-t[1]-1)*e.zbufferBufferWidth+t[0];o.zValue=e.depthValues[n],o.zValue=e.webGPURenderer.convertToOpenGLDepth(o.zValue),o.displayPosition=t}return o}const a=[t[0],t[1]],i=[0,0];let s=jy(e,t,0,r);if(s)return s;for(let t=1;t<o;++t){for(let n=a[1]>t?a[1]-t:0;n<=a[1]+t;++n){if(i[1]=n,a[0]>=t&&(i[0]=a[0]-t,s=jy(e,i,0,r),s))return s;if(i[0]=a[0]+t,s=jy(e,i,0,r),s)return s}for(let n=a[0]>=t?a[0]-(t-1):0;n<=a[0]+(t-1);++n){if(i[0]=n,a[1]>=t&&(i[1]=a[1]-t,s=jy(e,i,0,r),s))return s;if(i[1]=a[1]+t,s=jy(e,i,0,r),s)return s}}return r[0]=t[0],r[1]=t[1],null}const Ky={};function $y(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ky,n),bp.extend(e,t,n),t._selectionPass=_y.newInstance(),Wt.setGet(e,t,[&quot;_WebGPURenderWindow&quot;]),Wt.moveToProtected(e,t,[&quot;WebGPURenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUHardwareSelector&quot;),e.endSelection=()=>{t.WebGPURenderer.setSelector(null)},e.getSourceDataAsync=async e=>{if(!e||!t._WebGPURenderWindow)return zy(&quot;Renderer and view must be set before calling Select.&quot;),!1;t._WebGPURenderWindow.getRenderable().preRender(),t._WebGPURenderWindow.getInitialized()||(t._WebGPURenderWindow.initialize(),await new Promise((e=>{t._WebGPURenderWindow.onInitialized(e)})));const n=t._WebGPURenderWindow.getViewNodeFor(e);if(!n)return!1;const r=n.getSuppressClear();n.setSuppressClear(!0),t._selectionPass.traverse(t._WebGPURenderWindow,n),n.setSuppressClear(r);const o=t._WebGPURenderWindow.getDevice(),a=t._selectionPass.getColorTexture(),i=t._selectionPass.getDepthTexture(),s={area:[0,0,a.getWidth()-1,a.getHeight()-1],captureZValues:t.captureZValues,fieldAssociation:t.fieldAssociation,renderer:e,webGPURenderer:n,webGPURenderWindow:t._WebGPURenderWindow,width:a.getWidth(),height:a.getHeight()};s.colorBufferWidth=16*Math.floor((s.width+15)/16),s.colorBufferSizeInBytes=s.colorBufferWidth*s.height*4*4;const l=LT.newInstance({label:&quot;hardwareSelectColorBuffer&quot;});l.setDevice(o),l.create(s.colorBufferSizeInBytes,GPUBufferUsage.MAP_READ|GPUBufferUsage.COPY_DST);const c=t._WebGPURenderWindow.getCommandEncoder();let u;c.copyTextureToBuffer({texture:a.getHandle()},{buffer:l.getHandle(),bytesPerRow:16*s.colorBufferWidth,rowsPerImage:s.height},{width:s.width,height:s.height,depthOrArrayLayers:1}),t.captureZValues&&(s.zbufferBufferWidth=64*Math.floor((s.width+63)/64),u=LT.newInstance({label:&quot;hardwareSelectDepthBuffer&quot;}),u.setDevice(o),s.zbufferSizeInBytes=s.height*s.zbufferBufferWidth*4,u.create(s.zbufferSizeInBytes,GPUBufferUsage.MAP_READ|GPUBufferUsage.COPY_DST),c.copyTextureToBuffer({texture:i.getHandle(),aspect:&quot;depth-only&quot;},{buffer:u.getHandle(),bytesPerRow:4*s.zbufferBufferWidth,rowsPerImage:s.height},{width:s.width,height:s.height,depthOrArrayLayers:1})),o.submitCommandEncoder(c);const d=l.mapAsync(GPUMapMode.READ);if(t.captureZValues){const e=u.mapAsync(GPUMapMode.READ);await Promise.all([d,e]),s.depthValues=new Float32Array(u.getMappedRange().slice()),u.unmap()}else await d;return s.colorValues=new Uint32Array(l.getMappedRange().slice()),l.unmap(),s.generateSelection=(e,t,n,r)=>function(e,t,n,r,o){const a=Math.floor(t),i=Math.floor(n),s=Math.floor(r),l=Math.floor(o),c=new Map,u=[0,0];for(let t=i;t<=l;t++)for(let n=a;n<=s;n++){const r=jy(e,[n,t],0,u);if(r){const t=Wy(r);if(c.has(t)){const n=c.get(t);n.pixelCount++,e.captureZValues&&r.zValue<n.info.zValue&&(n.info=r),-1===n.attributeIDs.indexOf(r.attributeID)&&n.attributeIDs.push(r.attributeID)}else c.set(t,{info:r,pixelCount:1,attributeIDs:[r.attributeID]})}}return function(e,t,n){const r=[];let o=0;return t.forEach(((t,a)=>{const i=wp.newInstance();switch(i.setContentType(ky.INDICES),e){case Uy.FIELD_ASSOCIATION_CELLS:i.setFieldType(Gy.CELL);break;case Uy.FIELD_ASSOCIATION_POINTS:i.setFieldType(Gy.POINT);break;default:zy(&quot;Unknown field association&quot;)}i.getProperties().propID=t.info.propID;const s=n.webGPURenderer.getPropFromID(t.info.propID);i.getProperties().prop=s.getRenderable(),i.getProperties().compositeID=t.info.compositeID,i.getProperties().pixelCount=t.pixelCount,n.captureZValues&&(i.getProperties().displayPosition=[t.info.displayPosition[0],t.info.displayPosition[1],t.info.zValue],i.getProperties().worldPosition=n.webGPURenderWindow.displayToWorld(t.info.displayPosition[0],t.info.displayPosition[1],t.info.zValue,n.renderer)),i.setSelectionList(t.attributeIDs),r[o]=i,o++})),r}(e.fieldAssociation,c,e)}(s,e,t,n,r),s}}(e,t)}var qy={newInstance:Wt.newInstance($y,&quot;vtkWebGPUHardwareSelector&quot;),extend:$y};const Xy=Object.create(null),Yy={};function Zy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Yy,n),t.overrides=Xy,Zt.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUViewNodeFactory&quot;)}(0,t)}var Qy={newInstance:Wt.newInstance(Zy,&quot;vtkWebGPUViewNodeFactory&quot;),extend:Zy};const{vtkErrorMacro:Jy}=Wt,eb={position:&quot;absolute&quot;,top:0,left:0,width:&quot;100%&quot;,height:&quot;100%&quot;};const tb={initialized:!1,context:null,adapter:null,device:null,canvas:null,cursorVisibility:!0,cursor:&quot;pointer&quot;,containerSize:null,renderPasses:[],notifyStartCaptureImage:!1,imageFormat:&quot;image/png&quot;,useOffScreen:!1,useBackgroundImage:!1,nextPropID:1,xrSupported:!1,presentationFormat:null};const nb=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,tb,n),t.canvas=document.createElement(&quot;canvas&quot;),t.canvas.style.width=&quot;100%&quot;,t.bgImage=new Image,t.bgImage.style.position=&quot;absolute&quot;,t.bgImage.style.left=&quot;0&quot;,t.bgImage.style.top=&quot;0&quot;,t.bgImage.style.width=&quot;100%&quot;,t.bgImage.style.height=&quot;100%&quot;,t.bgImage.style.zIndex=&quot;-1&quot;,xv.extend(e,t,n),t.myFactory=Qy.newInstance(),t.renderPasses[0]=Oy.newInstance(),t.selector||(t.selector=qy.newInstance(),t.selector.setWebGPURenderWindow(e)),Wt.event(e,t,&quot;imageReady&quot;),Wt.event(e,t,&quot;initialized&quot;),Wt.get(e,t,[&quot;commandEncoder&quot;,&quot;device&quot;,&quot;presentationFormat&quot;,&quot;useBackgroundImage&quot;,&quot;xrSupported&quot;]),Wt.setGet(e,t,[&quot;initialized&quot;,&quot;context&quot;,&quot;canvas&quot;,&quot;device&quot;,&quot;renderPasses&quot;,&quot;notifyStartCaptureImage&quot;,&quot;cursor&quot;,&quot;useOffScreen&quot;]),Wt.setGetArray(e,t,[&quot;size&quot;],2),Wt.event(e,t,&quot;windowResizeEvent&quot;),function(e,t){t.classHierarchy.push(&quot;vtkWebGPURenderWindow&quot;),e.getViewNodeFactory=()=>t.myFactory;const n=[0,0];e.onModified((function(){t.renderable&&(t.size[0]===n[0]&&t.size[1]===n[1]||(n[0]=t.size[0],n[1]=t.size[1],t.canvas.setAttribute(&quot;width&quot;,t.size[0]),t.canvas.setAttribute(&quot;height&quot;,t.size[1]),e.recreateSwapChain())),t.viewStream&&t.viewStream.setSize(t.size[0],t.size[1]),t.canvas.style.display=t.useOffScreen?&quot;none&quot;:&quot;block&quot;,t.el&&(t.el.style.cursor=t.cursorVisibility?t.cursor:&quot;none&quot;),t.containerSize=null})),e.recreateSwapChain=()=>{t.context&&(t.context.unconfigure(),t.presentationFormat=navigator.gpu.getPreferredCanvasFormat(t.adapter),t.context.configure({device:t.device.getHandle(),format:t.presentationFormat,alphaMode:&quot;premultiplied&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.COPY_DST,width:t.size[0],height:t.size[1]}),t._configured=!0)},e.getCurrentTexture=()=>t.context.getCurrentTexture(),e.buildPass=n=>{if(n){if(!t.renderable)return;e.prepareNodes(),e.addMissingNodes(t.renderable.getRenderersByReference()),e.removeUnusedNodes(),e.initialize()}else t.initialized&&(t._configured||e.recreateSwapChain(),t.commandEncoder=t.device.createCommandEncoder())},e.initialize=()=>{if(!t.initializing){if(t.initializing=!0,!navigator.gpu)return void Jy(&quot;WebGPU is not enabled.&quot;);e.create3DContextAsync().then((()=>{t.initialized=!0,t.deleted||e.invokeInitialized()}))}},e.setContainer=n=>{t.el&&t.el!==n&&(t.canvas.parentNode!==t.el&&Jy(&quot;Error: canvas parent node does not match container&quot;),t.el.removeChild(t.canvas),t.el.contains(t.bgImage)&&t.el.removeChild(t.bgImage)),t.el!==n&&(t.el=n,t.el&&(t.el.appendChild(t.canvas),t.useBackgroundImage&&t.el.appendChild(t.bgImage)),e.modified())},e.getContainer=()=>t.el,e.getContainerSize=()=>{if(!t.containerSize&&t.el){const{width:e,height:n}=t.el.getBoundingClientRect();t.containerSize=[e,n]}return t.containerSize||t.size},e.getFramebufferSize=()=>t.size,e.create3DContextAsync=async()=>{t.adapter=await navigator.gpu.requestAdapter({powerPreference:&quot;high-performance&quot;}),t.deleted||(t.device=By.newInstance(),t.device.initialize(await t.adapter.requestDevice()),t.deleted?t.device=null:t.context=t.canvas.getContext(&quot;webgpu&quot;))},e.releaseGraphicsResources=()=>{const n=ev.newInstance();n.setCurrentOperation(&quot;Release&quot;),n.traverse(e,null),t.adapter=null,t.device=null,t.context=null,t.initialized=!1,t.initializing=!1},e.setBackgroundImage=e=>{t.bgImage.src=e.src},e.setUseBackgroundImage=e=>{t.useBackgroundImage=e,t.useBackgroundImage&&!t.el.contains(t.bgImage)?t.el.appendChild(t.bgImage):!t.useBackgroundImage&&t.el.contains(t.bgImage)&&t.el.removeChild(t.bgImage)},e.captureNextImage=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;image/png&quot;,{resetCamera:r=!1,size:o=null,scale:a=1}=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(t.deleted)return null;t.imageFormat=n;const i=t.notifyStartCaptureImage;return t.notifyStartCaptureImage=!0,t._screenshot={size:o||1!==a?o||t.size.map((e=>e*a)):null},new Promise(((n,o)=>{const a=e.onImageReady((o=>{if(null===t._screenshot.size)t.notifyStartCaptureImage=i,a.unsubscribe(),t._screenshot.placeHolder&&(t.size=t._screenshot.originalSize,e.modified(),t._screenshot.cameras&&t._screenshot.cameras.forEach((e=>{let{restoreParamsFn:t,arg:n}=e;return t(n)})),e.traverseAllPasses(),t.el.removeChild(t._screenshot.placeHolder),t._screenshot.placeHolder.remove(),t._screenshot=null),n(o);else{const n=document.createElement(&quot;img&quot;);if(n.style=eb,n.src=o,t._screenshot.placeHolder=t.el.appendChild(n),t.canvas.style.display=&quot;none&quot;,t._screenshot.originalSize=t.size,t.size=t._screenshot.size,t._screenshot.size=null,e.modified(),r){const e=!0!==r;t._screenshot.cameras=t.renderable.getRenderers().map((t=>{const n=t.getActiveCamera(),o=n.get(&quot;focalPoint&quot;,&quot;position&quot;,&quot;parallelScale&quot;);return{resetCameraArgs:e?{renderer:t}:void 0,resetCameraFn:e?r:t.resetCamera,restoreParamsFn:n.set,arg:JSON.parse(JSON.stringify(o))}})),t._screenshot.cameras.forEach((e=>{let{resetCameraFn:t,resetCameraArgs:n}=e;return t(n)}))}e.traverseAllPasses()}}))}))},e.traverseAllPasses=()=>{if(!t.deleted)if(t.initialized){if(t.renderPasses)for(let n=0;n<t.renderPasses.length;++n)t.renderPasses[n].traverse(e,null);t.commandEncoder&&(t.device.submitCommandEncoder(t.commandEncoder),t.commandEncoder=null,t.notifyStartCaptureImage&&t.device.onSubmittedWorkDone().then((()=>{!async function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:t.imageFormat;const r=document.createElement(&quot;canvas&quot;),o=r.getContext(&quot;2d&quot;);r.width=t.canvas.width,r.height=t.canvas.height;const a=await e.getPixelsAsync(),i=new ImageData(a.colorValues,a.width,a.height);o.putImageData(i,0,0);const s=t.canvas.getBoundingClientRect();t.renderable.getRenderers().forEach((e=>{e.getViewProps().forEach((e=>{if(e.getContainer){const t=e.getContainer().getElementsByTagName(&quot;canvas&quot;);for(let e=0;e<t.length;e++){const n=t[e],r=n.getBoundingClientRect(),a=r.x-s.x,i=r.y-s.y;o.drawImage(n,a,i)}}}))}));const l=r.toDataURL(n);r.remove(),e.invokeImageReady(l)}()})))}else{e.initialize();const t=e.onInitialized((()=>{t.unsubscribe(),e.traverseAllPasses()}))}},e.setViewStream=n=>t.viewStream!==n&&(t.subscription&&(t.subscription.unsubscribe(),t.subscription=null),t.viewStream=n,t.viewStream&&(t.renderable.getRenderers()[0].getBackgroundByReference()[3]=0,e.setUseBackgroundImage(!0),t.subscription=t.viewStream.onImageReady((t=>e.setBackgroundImage(t.image))),t.viewStream.setSize(t.size[0],t.size[1]),t.viewStream.invalidateCache(),t.viewStream.render(),e.modified()),!0),e.getUniquePropID=()=>t.nextPropID++,e.getPropFromID=e=>{for(let n=0;n<t.children.length;n++){const r=t.children[n].getPropFromID(e);if(null!==r)return r}return null},e.getPixelsAsync=async()=>{const e=t.device,n=t.renderPasses[0].getOpaquePass().getColorTexture(),r={width:n.getWidth(),height:n.getHeight()};r.colorBufferWidth=32*Math.floor((r.width+31)/32),r.colorBufferSizeInBytes=r.colorBufferWidth*r.height*8;const o=LT.newInstance();o.setDevice(e),o.create(r.colorBufferSizeInBytes,GPUBufferUsage.MAP_READ|GPUBufferUsage.COPY_DST);const a=t.device.createCommandEncoder();a.copyTextureToBuffer({texture:n.getHandle()},{buffer:o.getHandle(),bytesPerRow:8*r.colorBufferWidth,rowsPerImage:r.height},{width:r.width,height:r.height,depthOrArrayLayers:1}),e.submitCommandEncoder(a);const i=o.mapAsync(GPUMapMode.READ);await i,r.colorValues=new Uint16Array(o.getMappedRange().slice()),o.unmap();const s=new Uint8ClampedArray(r.height*r.width*4);for(let e=0;e<r.height;e++)for(let t=0;t<r.width;t++){const n=4*(e*r.width+t),o=4*(e*r.colorBufferWidth+t);s[n]=255*gd.fromHalf(r.colorValues[o]),s[n+1]=255*gd.fromHalf(r.colorValues[o+1]),s[n+2]=255*gd.fromHalf(r.colorValues[o+2]),s[n+3]=255*gd.fromHalf(r.colorValues[o+3])}return r.colorValues=s,r},e.createSelector=()=>{const t=qy.newInstance();return t.setWebGPURenderWindow(e),t};const r=e.setSize;e.setSize=(t,n)=>{const o=r(t,n);return o&&e.invokeWindowResizeEvent({width:t,height:n}),o},e.delete=Wt.chain(e.delete,e.setViewStream)}(e,t)}),&quot;vtkWebGPURenderWindow&quot;);var rb;ph(&quot;WebGPU&quot;,nb),rb=nb,Xy.vtkRenderWindow=rb;const ob=Zh(),ab={margin:&quot;0&quot;,padding:&quot;0&quot;,position:&quot;absolute&quot;,top:&quot;0&quot;,left:&quot;0&quot;,width:&quot;100%&quot;,height:&quot;100%&quot;,overflow:&quot;hidden&quot;},ib={position:&quot;absolute&quot;,left:&quot;25px&quot;,top:&quot;25px&quot;,backgroundColor:&quot;white&quot;,borderRadius:&quot;5px&quot;,listStyle:&quot;none&quot;,padding:&quot;5px 10px&quot;,margin:&quot;0&quot;,display:&quot;block&quot;,border:&quot;solid 1px black&quot;,maxWidth:&quot;calc(100% - 70px)&quot;,maxHeight:&quot;calc(100% - 60px)&quot;,overflow:&quot;auto&quot;};function sb(e,t){Object.keys(t).forEach((n=>{e.style[n]=t[n]}))}const lb={background:[.32,.34,.43],containerStyle:null,controlPanelStyle:null,listenWindowResize:!0,resizeCallback:null,controllerVisibility:!0};function cb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,lb,n),Wt.obj(e,t),Wt.get(e,t,[&quot;renderWindow&quot;,&quot;renderer&quot;,&quot;apiSpecificRenderWindow&quot;,&quot;interactor&quot;,&quot;rootContainer&quot;,&quot;container&quot;,&quot;controlContainer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkFullScreenRenderWindow&quot;);const n=document.querySelector(&quot;body&quot;);function r(t){&quot;c&quot;===String.fromCharCode(t.charCode)&&e.toggleControllerVisibility()}t.rootContainer||(t.rootContainer=n),t.container||(t.container=document.createElement(&quot;div&quot;),sb(t.container,t.containerStyle||ab),t.rootContainer.appendChild(t.container)),t.rootContainer===n&&(document.documentElement.style.height=&quot;100%&quot;,n.style.height=&quot;100%&quot;,n.style.padding=&quot;0&quot;,n.style.margin=&quot;0&quot;),t.renderWindow=hh.newInstance(),t.renderer=uh.newInstance(),t.renderWindow.addRenderer(t.renderer),t.apiSpecificRenderWindow=t.renderWindow.newAPISpecificView(ob.viewAPI??t.defaultViewAPI),t.apiSpecificRenderWindow.setContainer(t.container),t.renderWindow.addView(t.apiSpecificRenderWindow),t.interactor=Dh.newInstance(),t.interactor.setInteractorStyle(qh.newInstance()),t.interactor.setView(t.apiSpecificRenderWindow),t.interactor.initialize(),t.interactor.bindEvents(t.container),e.setBackground=t.renderer.setBackground,e.removeController=()=>{const e=t.controlContainer;e&&e.parentNode.removeChild(e)},e.setControllerVisibility=e=>{t.controllerVisibility=e,t.controlContainer&&(t.controlContainer.style.display=e?&quot;block&quot;:&quot;none&quot;)},e.toggleControllerVisibility=()=>{e.setControllerVisibility(!t.controllerVisibility)},e.addController=n=>{t.controlContainer=document.createElement(&quot;div&quot;),sb(t.controlContainer,t.controlPanelStyle||ib),t.rootContainer.appendChild(t.controlContainer),t.controlContainer.innerHTML=n,e.setControllerVisibility(t.controllerVisibility),t.rootContainer.addEventListener(&quot;keypress&quot;,r)},e.setBackground(...t.background),e.addRepresentation=e=>{e.getActors().forEach((e=>{t.renderer.addActor(e)}))},e.removeRepresentation=e=>{e.getActors().forEach((e=>t.renderer.removeActor(e)))},e.delete=Wt.chain(e.setContainer,t.apiSpecificRenderWindow.delete,(()=>{t.rootContainer?.removeEventListener(&quot;keypress&quot;,r),window.removeEventListener(&quot;resize&quot;,e.resize)}),e.delete),e.resize=()=>{const e=t.container.getBoundingClientRect(),n=window.devicePixelRatio||1;t.apiSpecificRenderWindow.setSize(Math.floor(e.width*n),Math.floor(e.height*n)),t.resizeCallback&&t.resizeCallback(e),t.renderWindow.render()},e.setResizeCallback=n=>{t.resizeCallback=n,e.resize()},t.listenWindowResize&&window.addEventListener(&quot;resize&quot;,e.resize),e.resize()}(e,t)}var ub={newInstance:Wt.newInstance(cb),extend:cb},db={ColorSpace:{RGB:0,HSV:1,LAB:2,DIVERGING:3},Scale:{LINEAR:0,LOG10:1}};const{ColorSpace:pb,Scale:fb}=db,{ScalarMappingTarget:gb}=cl,{vtkDebugMacro:mb,vtkErrorMacro:hb,vtkWarningMacro:vb}=Wt;function Tb(e,t){const n=e[0],r=e[1],o=e[2],a=Math.sqrt(n*n+r*r+o*o),i=a>.001?Math.acos(n/a):0,s=i>.001?Math.atan2(o,r):0;t[0]=a,t[1]=i,t[2]=s}function yb(e,t){if(e[0]>=t-.1)return e[2];const n=e[1]*Math.sqrt(t*t-e[0]*e[0])/(e[0]*Math.sin(e[1]));return e[2]>-.3*Math.PI?e[2]+n:e[2]-n}function bb(e,t,n,r){const o=[],a=[];ha(t,o),ha(n,a);const i=[],s=[];Tb(o,i),Tb(a,s);let l=e;if(i[1]>.05&&s[1]>.05&&function(e,t){let n=e-t;for(n<0&&(n=-n);n>=2*Math.PI;)n-=2*Math.PI;return n>Math.PI&&(n=2*Math.PI-n),n}(i[2],s[2])>.33*Math.PI){let t=Math.max(i[0],s[0]);t=Math.max(88,t),e<.5?(s[0]=t,s[1]=0,s[2]=0,l*=2):(i[0]=t,i[1]=0,i[2]=0,l=2*l-1)}i[1]<.05&&s[1]>.05?i[2]=yb(s,i[0]):s[1]<.05&&i[1]>.05&&(s[2]=yb(i,s[0]));const c=[];c[0]=(1-l)*i[0]+l*s[0],c[1]=(1-l)*i[1]+l*s[1],c[2]=(1-l)*i[2]+l*s[2];const u=[];!function(e,t){const n=e[0],r=e[1],o=e[2];t[0]=n*Math.cos(r),t[1]=n*Math.sin(r)*Math.cos(o),t[2]=n*Math.sin(r)*Math.sin(o)}(c,u),va(u,r)}const xb={clamping:!0,colorSpace:pb.RGB,hSVWrap:!0,scale:fb.LINEAR,nanColor:null,belowRangeColor:null,aboveRangeColor:null,useAboveRangeColor:!1,useBelowRangeColor:!1,allowDuplicateScalars:!1,table:null,tableSize:0,buildTime:null,nodes:null,discretize:!1,numberOfValues:256};function Cb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,xb,n),cl.extend(e,t,n),t.table=[],t.nodes=[],t.nanColor=[.5,0,0,1],t.belowRangeColor=[0,0,0,1],t.aboveRangeColor=[1,1,1,1],t.buildTime={},Wt.obj(t.buildTime),Wt.get(e,t,[&quot;buildTime&quot;,&quot;mappingRange&quot;]),Wt.setGet(e,t,[&quot;useAboveRangeColor&quot;,&quot;useBelowRangeColor&quot;,&quot;discretize&quot;,&quot;numberOfValues&quot;,{type:&quot;enum&quot;,name:&quot;colorSpace&quot;,enum:pb},{type:&quot;enum&quot;,name:&quot;scale&quot;,enum:fb}]),Wt.setArray(e,t,[&quot;nanColor&quot;,&quot;belowRangeColor&quot;,&quot;aboveRangeColor&quot;],4),Wt.getArray(e,t,[&quot;nanColor&quot;,&quot;belowRangeColor&quot;,&quot;aboveRangeColor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkColorTransferFunction&quot;),e.getSize=()=>t.nodes.length,e.addRGBPoint=(t,n,r,o)=>e.addRGBPointLong(t,n,r,o,.5,0),e.addRGBPointLong=function(n,r,o,a){let i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:.5,s=arguments.length>5&&void 0!==arguments[5]?arguments[5]:0;if(i<0||i>1)return hb(&quot;Midpoint outside range [0.0, 1.0]&quot;),-1;if(s<0||s>1)return hb(&quot;Sharpness outside range [0.0, 1.0]&quot;),-1;t.allowDuplicateScalars||e.removePoint(n);const l={x:n,r:r,g:o,b:a,midpoint:i,sharpness:s};t.nodes.push(l),e.sortAndUpdateRange();let c=0;for(;c<t.nodes.length&&t.nodes[c].x!==n;c++);return c<t.nodes.length?c:-1},e.addHSVPoint=(t,n,r,o)=>e.addHSVPointLong(t,n,r,o,.5,0),e.addHSVPointLong=function(t,n,r,o){let a=arguments.length>4&&void 0!==arguments[4]?arguments[4]:.5,i=arguments.length>5&&void 0!==arguments[5]?arguments[5]:0;const s=[];return da([n,r,o],s),e.addRGBPoint(t,s[0],s[1],s[2],a,i)},e.setNodes=n=>{if(t.nodes!==n){const r=JSON.stringify(t.nodes);t.nodes=n;const o=JSON.stringify(t.nodes);if(e.sortAndUpdateRange()||r!==o)return e.modified(),!0}return!1},e.sortAndUpdateRange=()=>{const n=JSON.stringify(t.nodes);t.nodes.sort(((e,t)=>e.x-t.x));const r=JSON.stringify(t.nodes),o=e.updateRange();return o||n===r?o:(e.modified(),!0)},e.updateRange=()=>{const n=[2];n[0]=t.mappingRange[0],n[1]=t.mappingRange[1];const r=t.nodes.length;return r?(t.mappingRange[0]=t.nodes[0].x,t.mappingRange[1]=t.nodes[r-1].x):(t.mappingRange[0]=0,t.mappingRange[1]=0),(n[0]!==t.mappingRange[0]||n[1]!==t.mappingRange[1])&&(e.modified(),!0)},e.removePoint=n=>{let r=0;for(;r<t.nodes.length&&t.nodes[r].x!==n;r++);const o=r;if(r>=t.nodes.length)return-1;let a=!1;return t.nodes.splice(r,1),0!==r&&r!==t.nodes.length||(a=e.updateRange()),a||e.modified(),o},e.movePoint=(n,r)=>{if(n!==r){e.removePoint(r);for(let o=0;o<t.nodes.length;o++)if(t.nodes[o].x===n){t.nodes[o].x=r,e.sortAndUpdateRange();break}}},e.removeAllPoints=()=>{t.nodes=[],e.sortAndUpdateRange()},e.addRGBSegment=(n,r,o,a,i,s,l,c)=>{e.sortAndUpdateRange();for(let e=0;e<t.nodes.length;)t.nodes[e].x>=n&&t.nodes[e].x<=i?t.nodes.splice(e,1):e++;e.addRGBPointLong(n,r,o,a,.5,0),e.addRGBPointLong(i,s,l,c,.5,0),e.modified()},e.addHSVSegment=(t,n,r,o,a,i,s,l)=>{const c=[i,s,l],u=[],d=[];da([n,r,o],u),da(c,d),e.addRGBSegment(t,u[0],u[1],u[2],a,d[0],d[1],d[2])},e.mapValue=t=>{const n=[];return e.getColor(t,n),[Math.floor(255*n[0]+.5),Math.floor(255*n[1]+.5),Math.floor(255*n[2]+.5),255]},e.getColor=(n,r)=>{if(t.indexedLookup){const t=e.getSize(),o=e.getAnnotatedValueIndexInternal(n);if(o<0||0===t){const t=e.getNanColorByReference();r[0]=t[0],r[1]=t[1],r[2]=t[2]}else{const n=[];e.getNodeValue(o%t,n),r[0]=n[1],r[1]=n[2],r[2]=n[3]}}else e.getTable(n,n,1,r)},e.getRedValue=t=>{const n=[];return e.getColor(t,n),n[0]},e.getGreenValue=t=>{const n=[];return e.getColor(t,n),n[1]},e.getBlueValue=t=>{const n=[];return e.getColor(t,n),n[2]},e.logScaleEnabled=()=>t.scale===fb.LOG10,e.usingLogScale=()=>e.logScaleEnabled()&&t.mappingRange[0]>0,e.getTable=(n,r,o,a)=>{const i=e.usingLogScale(),s=i?Math.log10(Number(n)):Number(n),l=i?Math.log10(Number(r)):Number(r);if(Oa(s)||Oa(l)){for(let e=0;e<o;e++)a[3*e+0]=t.nanColor[0],a[3*e+1]=t.nanColor[1],a[3*e+2]=t.nanColor[2];return}let c=0;const u=t.nodes.length;let d=0,p=0,f=0;0!==u&&(d=t.nodes[u-1].r,p=t.nodes[u-1].g,f=t.nodes[u-1].b);let g=0,m=0,h=0;const v=[0,0,0],T=[0,0,0];let y=0,b=0;const x=[];let C=t.mappingRange;i&&(C=[Math.log10(t.mappingRange[0]),Math.log10(t.mappingRange[1])]);for(let n=0;n<o;n++){const r=3*n;if(g=o>1?s+n/(o-1)*(l-s):.5*(s+l),t.discretize){const e=C;if(g>=e[0]&&g<=e[1]){const n=t.numberOfValues,r=e[1]-e[0];if(n<=1)g=e[0]+r/2;else{const t=(g-e[0])/r,o=bo(n*t);g=e[0]+o/(n-1)*r}}}for(;c<u&&g>t.nodes[c].x;)c++,c<u&&(m=t.nodes[c-1].x,h=t.nodes[c].x,v[0]=t.nodes[c-1].r,T[0]=t.nodes[c].r,v[1]=t.nodes[c-1].g,T[1]=t.nodes[c].g,v[2]=t.nodes[c-1].b,T[2]=t.nodes[c].b,y=t.nodes[c-1].midpoint,b=t.nodes[c-1].sharpness,y<1e-5&&(y=1e-5),y>.99999&&(y=.99999));if(g>C[1])a[r]=0,a[r+1]=0,a[r+2]=0,t.clamping&&(e.getUseAboveRangeColor()?(a[r]=t.aboveRangeColor[0],a[r+1]=t.aboveRangeColor[1],a[r+2]=t.aboveRangeColor[2]):(a[r]=d,a[r+1]=p,a[r+2]=f));else if(g<C[0]||Aa(g)&&g<0)a[r]=0,a[r+1]=0,a[r+2]=0,t.clamping&&(e.getUseBelowRangeColor()?(a[r]=t.belowRangeColor[0],a[r+1]=t.belowRangeColor[1],a[r+2]=t.belowRangeColor[2]):u>0&&(a[r]=t.nodes[0].r,a[r+1]=t.nodes[0].g,a[r+2]=t.nodes[0].b));else if(0===c&&(Math.abs(g-s)<1e-6||t.discretize))u>0?(a[r]=t.nodes[0].r,a[r+1]=t.nodes[0].g,a[r+2]=t.nodes[0].b):(a[r]=0,a[r+1]=0,a[r+2]=0);else{let e=0;if(e=(g-m)/(h-m),e=e<y?.5*e/y:.5+.5*(e-y)/(1-y),b>.99){if(e<.5){a[r]=v[0],a[r+1]=v[1],a[r+2]=v[2];continue}a[r]=T[0],a[r+1]=T[1],a[r+2]=T[2];continue}if(b<.01){if(t.colorSpace===pb.RGB)a[r]=(1-e)*v[0]+e*T[0],a[r+1]=(1-e)*v[1]+e*T[1],a[r+2]=(1-e)*v[2]+e*T[2];else if(t.colorSpace===pb.HSV){const n=[],o=[];ua(v,n),ua(T,o),t.hSVWrap&&(n[0]-o[0]>.5||o[0]-n[0]>.5)&&(n[0]>o[0]?n[0]-=1:o[0]-=1);const i=[];i[0]=(1-e)*n[0]+e*o[0],i[0]<0&&(i[0]+=1),i[1]=(1-e)*n[1]+e*o[1],i[2]=(1-e)*n[2]+e*o[2],da(i,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]}else if(t.colorSpace===pb.LAB){const t=[],n=[];ha(v,t),ha(T,n);const o=[];o[0]=(1-e)*t[0]+e*n[0],o[1]=(1-e)*t[1]+e*n[1],o[2]=(1-e)*t[2]+e*n[2],va(o,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]}else t.colorSpace===pb.DIVERGING?(bb(e,v,T,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]):hb(&quot;ColorSpace set to invalid value.&quot;,t.colorSpace);continue}e<.5?e=.5*(2*e)**(1+10*b):e>.5&&(e=1-.5*(2*(1-e))**(1+10*b));const n=e*e,o=n*e,i=2*o-3*n+1,s=-2*o+3*n,l=o-2*n+e,c=o-n;let u,d;if(t.colorSpace===pb.RGB)for(let e=0;e<3;e++)u=T[e]-v[e],d=(1-b)*u,a[r+e]=i*v[e]+s*T[e]+l*d+c*d;else if(t.colorSpace===pb.HSV){const e=[],n=[];ua(v,e),ua(T,n),t.hSVWrap&&(e[0]-n[0]>.5||n[0]-e[0]>.5)&&(e[0]>n[0]?e[0]-=1:n[0]-=1);const o=[];for(let t=0;t<3;t++)u=n[t]-e[t],d=(1-b)*u,o[t]=i*e[t]+s*n[t]+l*d+c*d,0===t&&o[t]<0&&(o[t]+=1);da(o,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]}else if(t.colorSpace===pb.LAB){const e=[],t=[];ha(v,e),ha(T,t);const n=[];for(let r=0;r<3;r++)u=t[r]-e[r],d=(1-b)*u,n[r]=i*e[r]+s*t[r]+l*d+c*d;va(n,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]}else t.colorSpace===pb.DIVERGING?(bb(e,v,T,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]):hb(&quot;ColorSpace set to invalid value.&quot;);for(let e=0;e<3;e++)a[r+e]=a[r+e]<0?0:a[r+e],a[r+e]=a[r+e]>1?1:a[r+e]}}},e.getUint8Table=function(n,r,o){let a=arguments.length>3&&void 0!==arguments[3]&&arguments[3];if(e.getMTime()<=t.buildTime&&t.tableSize===o&&t.tableWithAlpha!==a)return t.table;if(0===t.nodes.length)return hb(&quot;Attempting to lookup a value with no points in the function&quot;),t.table;const i=a?4:3;t.tableSize===o&&t.tableWithAlpha===a||(t.table=new Uint8Array(o*i),t.tableSize=o,t.tableWithAlpha=a);const s=[];e.getTable(n,r,o,s);for(let e=0;e<o;e++)t.table[e*i+0]=Math.floor(255*s[3*e+0]+.5),t.table[e*i+1]=Math.floor(255*s[3*e+1]+.5),t.table[e*i+2]=Math.floor(255*s[3*e+2]+.5),a&&(t.table[e*i+3]=255);return t.buildTime.modified(),t.table},e.buildFunctionFromArray=n=>{e.removeAllPoints();const r=n.getNumberOfComponents();for(let e=0;e<n.getNumberOfTuples();e++)switch(r){case 3:t.nodes.push({x:e,r:n.getComponent(e,0),g:n.getComponent(e,1),b:n.getComponent(e,2),midpoint:.5,sharpness:0});break;case 4:t.nodes.push({x:n.getComponent(e,0),r:n.getComponent(e,1),g:n.getComponent(e,2),b:n.getComponent(e,3),midpoint:.5,sharpness:0});break;case 5:t.nodes.push({x:e,r:n.getComponent(e,0),g:n.getComponent(e,1),b:n.getComponent(e,2),midpoint:n.getComponent(e,4),sharpness:n.getComponent(e,5)});break;case 6:t.nodes.push({x:n.getComponent(e,0),r:n.getComponent(e,1),g:n.getComponent(e,2),b:n.getComponent(e,3),midpoint:n.getComponent(e,4),sharpness:n.getComponent(e,5)})}e.sortAndUpdateRange()},e.buildFunctionFromTable=(n,r,o,a)=>{let i=0;e.removeAllPoints(),o>1&&(i=(r-n)/(o-1));for(let e=0;e<o;e++){const r={x:n+i*e,r:a[3*e],g:a[3*e+1],b:a[3*e+2],sharpness:0,midpoint:.5};t.nodes.push(r)}e.sortAndUpdateRange()},e.getNodeValue=(e,n)=>e<0||e>=t.nodes.length?(hb(&quot;Index out of range!&quot;),-1):(n[0]=t.nodes[e].x,n[1]=t.nodes[e].r,n[2]=t.nodes[e].g,n[3]=t.nodes[e].b,n[4]=t.nodes[e].midpoint,n[5]=t.nodes[e].sharpness,1),e.setNodeValue=(n,r)=>{if(n<0||n>=t.nodes.length)return hb(&quot;Index out of range!&quot;),-1;const o=t.nodes[n].x;return t.nodes[n].x=r[0],t.nodes[n].r=r[1],t.nodes[n].g=r[2],t.nodes[n].b=r[3],t.nodes[n].midpoint=r[4],t.nodes[n].sharpness=r[5],o!==r[0]?e.sortAndUpdateRange():e.modified(),1},e.getNumberOfAvailableColors=()=>{if(t.indexedLookup&&e.getSize())return e.getSize();if(t.tableSize)return t.tableSize;const n=t.nodes?.length??0;return Math.max(4094,n)},e.getIndexedColor=(t,n)=>{const r=e.getSize();if(r>0&&t>=0){const o=[];e.getNodeValue(t%r,o);for(let e=0;e<3;++e)n[e]=o[e+1];return void(n[3]=1)}const o=e.getNanColorByReference();n[0]=o[0],n[1]=o[1],n[2]=o[2],n[3]=1},e.fillFromDataPointer=(t,n)=>{if(!(t<=0)&&n){e.removeAllPoints();for(let r=0;r<t;r++)e.addRGBPoint(n[4*r],n[4*r+1],n[4*r+2],n[4*r+3])}},e.setMappingRange=(n,r)=>{const o=[n,r],a=[n,r],i=e.getRange(),s=e.logScaleEnabled();if(i[1]===o[1]&&i[0]===o[0])return;if(o[1]===o[0])return void hb(&quot;attempt to set zero width color range&quot;);s&&(o[0]<=0?console.warn(&quot;attempt to set log scale color range with non-positive minimum&quot;):(a[0]=Math.log10(o[0]),a[1]=Math.log10(o[1])));const l=(a[1]-a[0])/(i[1]-i[0]),c=a[0]-i[0]*l;for(let e=0;e<t.nodes.length;++e)t.nodes[e].x=t.nodes[e].x*l+c;t.mappingRange[0]=o[0],t.mappingRange[1]=o[1],e.modified()},e.adjustRange=n=>{const r=e.getRange(),o=[];r[0]<n[0]?(e.getColor(n[0],o),e.addRGBPoint(n[0],o[0],o[1],o[2])):(e.getColor(r[0],o),e.addRGBPoint(n[0],o[0],o[1],o[2])),r[1]>n[1]?(e.getColor(n[1],o),e.addRGBPoint(n[1],o[0],o[1],o[2])):(e.getColor(r[1],o),e.addRGBPoint(n[1],o[0],o[1],o[2])),e.sortAndUpdateRange();for(let e=0;e<t.nodes.length;)t.nodes[e].x>=n[0]&&t.nodes[e].x<=n[1]?t.nodes.splice(e,1):++e;return 1},e.estimateMinNumberOfSamples=(t,n)=>{const r=e.findMinimumXDistance();return Math.ceil((n-t)/r)},e.findMinimumXDistance=()=>{if(t.nodes.length<2)return-1;let e=Number.MAX_VALUE;for(let n=0;n<t.nodes.length-1;n++){const r=t.nodes[n+1].x-t.nodes[n].x;r<e&&(e=r)}return e},e.mapScalarsThroughTable=(n,r,o,a)=>{0!==e.getSize()?t.indexedLookup?e.mapDataIndexed(n,r,o,a):e.mapData(n,r,o,a):mb(&quot;Transfer Function Has No Points!&quot;)},e.mapData=(t,n,r,o)=>{if(0===e.getSize())return void vb(&quot;Transfer Function Has No Points!&quot;);const a=Math.floor(255*e.getAlpha()+.5),i=t.getNumberOfTuples(),s=t.getNumberOfComponents(),l=n.getData(),c=t.getData(),u=[];if(r===gb.RGBA)for(let t=0;t<i;t++){const n=c[t*s+o];e.getColor(n,u),l[4*t]=Math.floor(255*u[0]+.5),l[4*t+1]=Math.floor(255*u[1]+.5),l[4*t+2]=Math.floor(255*u[2]+.5),l[4*t+3]=a}if(r===gb.RGB)for(let t=0;t<i;t++){const n=c[t*s+o];e.getColor(n,u),l[3*t]=Math.floor(255*u[0]+.5),l[3*t+1]=Math.floor(255*u[1]+.5),l[3*t+2]=Math.floor(255*u[2]+.5)}if(r===gb.LUMINANCE)for(let t=0;t<i;t++){const n=c[t*s+o];e.getColor(n,u),l[t]=Math.floor(76.5*u[0]+150.45*u[1]+28.05*u[2]+.5)}if(r===gb.LUMINANCE_ALPHA)for(let t=0;t<i;t++){const n=c[t*s+o];e.getColor(n,u),l[2*t]=Math.floor(76.5*u[0]+150.45*u[1]+28.05*u[2]+.5),l[2*t+1]=a}},e.applyColorMap=n=>{const r=JSON.stringify(t.colorSpace);n.ColorSpace&&(t.colorSpace=pb[n.ColorSpace.toUpperCase()],void 0===t.colorSpace&&(hb(`ColorSpace ${n.ColorSpace} not supported, using RGB instead`),t.colorSpace=pb.RGB));let o=r!==JSON.stringify(t.colorSpace);const a=o||JSON.stringify(t.nanColor);if(n.NanColor)for(t.nanColor=[].concat(n.NanColor);t.nanColor.length<4;)t.nanColor.push(1);o=o||a!==JSON.stringify(t.nanColor);const i=o||JSON.stringify(t.nodes);if(n.RGBPoints){const e=n.RGBPoints.length;t.nodes=[];const r=.5,o=0;for(let a=0;a<e;a+=4)t.nodes.push({x:n.RGBPoints[a],r:n.RGBPoints[a+1],g:n.RGBPoints[a+2],b:n.RGBPoints[a+3],midpoint:r,sharpness:o})}const s=e.sortAndUpdateRange(),l=!s&&(o||i!==JSON.stringify(t.nodes));return l&&e.modified(),s||l}}(e,t)}var Sb={newInstance:Wt.newInstance(Cb,&quot;vtkColorTransferFunction&quot;),extend:Cb,...db},Ab={OrientationModes:{DIRECTION:0,ROTATION:1,MATRIX:2},ScaleModes:{SCALE_BY_CONSTANT:0,SCALE_BY_MAGNITUDE:1,SCALE_BY_COMPONENTS:2}};const{OrientationModes:Ib,ScaleModes:wb}=Ab,{vtkErrorMacro:Ob}=Wt,Pb={orient:!0,orientationMode:Ib.DIRECTION,orientationArray:null,scaling:!0,scaleFactor:1,scaleMode:wb.SCALE_BY_MAGNITUDE,scaleArray:null,matrixArray:null,normalArray:null,colorArray:null};function Rb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Pb,n),Gl.extend(e,t,n),Wt.algo(e,t,2,0),t.buildTime={},Wt.obj(t.buildTime,{mtime:0}),t.boundsTime={},Wt.obj(t.boundsTime,{mtime:0}),Wt.setGet(e,t,[&quot;orient&quot;,&quot;orientationMode&quot;,&quot;orientationArray&quot;,&quot;scaleArray&quot;,&quot;scaleFactor&quot;,&quot;scaleMode&quot;,&quot;scaling&quot;]),Wt.get(e,t,[&quot;colorArray&quot;,&quot;matrixArray&quot;,&quot;normalArray&quot;,&quot;buildTime&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkGlyph3DMapper&quot;),e.getOrientationModeAsString=()=>Wt.enumToString(Ib,t.orientationMode),e.setOrientationModeToDirection=()=>e.setOrientationMode(Ib.DIRECTION),e.setOrientationModeToRotation=()=>e.setOrientationMode(Ib.ROTATION),e.setOrientationModeToMatrix=()=>e.setOrientationMode(Ib.MATRIX),e.getOrientationArrayData=()=>{const n=e.getInputData(0);return n&&n.getPointData()?t.orientationArray?n.getPointData().getArray(t.orientationArray):n.getPointData().getVectors():null},e.getScaleModeAsString=()=>Wt.enumToString(wb,t.scaleMode),e.setScaleModeToScaleByMagnitude=()=>e.setScaleMode(wb.SCALE_BY_MAGNITUDE),e.setScaleModeToScaleByComponents=()=>e.setScaleMode(wb.SCALE_BY_COMPONENTS),e.setScaleModeToScaleByConstant=()=>e.setScaleMode(wb.SCALE_BY_CONSTANT),e.getScaleArrayData=()=>{const n=e.getInputData(0);return n&&n.getPointData()?t.scaleArray?n.getPointData().getArray(t.scaleArray):n.getPointData().getScalars():null},e.getBounds=()=>{const n=e.getInputData(0),r=e.getInputData(1);return n&&r?(e.buildArrays(),t.bounds):Pa()},e.buildArrays=()=>{const n=e.getInputData(0),r=e.getInputData(1);if(t.buildTime.getMTime()<r.getMTime()||t.buildTime.getMTime()<n.getMTime()||t.buildTime.getMTime()<e.getMTime()){const o=n.getPoints().getData();let a=e.getScaleArrayData(),i=null,s=0;a&&(i=a.getData(),s=a.getNumberOfComponents()),t.scaling&&a&&t.scaleMode===wb.SCALE_BY_COMPONENTS&&3!==a.getNumberOfComponents()&&(Ob(&quot;Cannot scale by components since scale array does not have 3 components.&quot;),a=null);const l=r.getBounds(),c=[];Gi.getCorners(l,c),t.bounds[0]=Gi.INIT_BOUNDS[0],t.bounds[1]=Gi.INIT_BOUNDS[1],t.bounds[2]=Gi.INIT_BOUNDS[2],t.bounds[3]=Gi.INIT_BOUNDS[3],t.bounds[4]=Gi.INIT_BOUNDS[4],t.bounds[5]=Gi.INIT_BOUNDS[5];const u=new Float64Array(3),d=e.getOrientationArrayData(),p=m(new Float64Array(16)),f=[],g=[],h=o.length/3;t.matrixArray=new Float32Array(16*h);const v=t.matrixArray.buffer;t.normalArray=new Float32Array(9*h);const T=t.normalArray.buffer,y=[],O=[];for(let e=0;e<h;++e){const n=new Float32Array(v,64*e,16);if(f[0]=o[3*e],f[1]=o[3*e+1],f[2]=o[3*e+2],x(n,p,f),d)switch(d.getTuple(e,O),t.orientationMode){case Ib.MATRIX:b(n,n,[...O.slice(0,3),0,...O.slice(3,6),0,...O.slice(6,9),0,0,0,0,1]);break;case Ib.ROTATION:w(n,n,O[2]),A(n,n,O[0]),I(n,n,O[1]);break;case Ib.DIRECTION:if(0===O[1]&&0===O[2])O[0]<0&&I(n,n,3.1415926);else{const e=No(O),t=[];t[0]=(O[0]+e)/2,t[1]=O[1]/2,t[2]=O[2]/2,S(n,n,3.1415926,t)}}if(t.scaling){if(g[0]=t.scaleFactor,g[1]=t.scaleFactor,g[2]=t.scaleFactor,a)switch(t.scaleMode){case wb.SCALE_BY_MAGNITUDE:for(let t=0;t<s;++t)y[t]=i[e*s+t];g[0]*=No(y,s),g[1]=g[0],g[2]=g[0];break;case wb.SCALE_BY_COMPONENTS:for(let t=0;t<s;++t)y[t]=i[e*s+t];g[0]*=y[0],g[1]*=y[1],g[2]*=y[2];case wb.SCALE_BY_CONSTANT:}0===g[0]&&(g[0]=1e-10),0===g[1]&&(g[1]=1e-10),0===g[2]&&(g[2]=1e-10),C(n,n,g)}for(let e=0;e<8;++e)In(u,c[e],n),u[0]<t.bounds[0]&&(t.bounds[0]=u[0]),u[1]<t.bounds[2]&&(t.bounds[2]=u[1]),u[2]<t.bounds[4]&&(t.bounds[4]=u[2]),u[0]>t.bounds[1]&&(t.bounds[1]=u[0]),u[1]>t.bounds[3]&&(t.bounds[3]=u[1]),u[2]>t.bounds[5]&&(t.bounds[5]=u[2]);const r=new Float32Array(T,36*e,9);le(r,n),me(r,r),ge(r,r)}const P=e.getAbstractScalars(n,t.scalarMode,t.arrayAccessMode,t.arrayId,t.colorByArrayName).scalars;t.useLookupTableScalarRange||e.getLookupTable().setRange(t.scalarRange[0],t.scalarRange[1]),t.colorArray=null;const R=e.getLookupTable();R&&P&&(R.build(),t.colorArray=R.mapScalars(P,t.colorMode,0)),t.buildTime.modified()}},e.getPrimitiveCount=()=>{const t=e.getInputData(1),n=e.getInputData().getPoints().getNumberOfValues()/3;return{points:n*t.getPoints().getNumberOfValues()/3,verts:n*(t.getVerts().getNumberOfValues()-t.getVerts().getNumberOfCells()),lines:n*(t.getLines().getNumberOfValues()-2*t.getLines().getNumberOfCells()),triangles:n*(t.getPolys().getNumberOfValues()-3*t.getLines().getNumberOfCells())}},e.setSourceConnection=t=>e.setInputConnection(t,1)}(e,t)}var Mb={newInstance:Wt.newInstance(Rb,&quot;vtkGlyph3DMapper&quot;),extend:Rb,...Ab};const{vtkErrorMacro:Eb}=Wt,Vb={range:[0,0],clamping:!0,allowDuplicateScalars:!1};function Db(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Vb,n),Wt.obj(e,t),t.nodes=[],Wt.setGet(e,t,[&quot;allowDuplicateScalars&quot;,&quot;clamping&quot;]),Wt.setArray(e,t,[&quot;range&quot;],2),Wt.getArray(e,t,[&quot;range&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkPiecewiseFunction&quot;),e.getSize=()=>t.nodes.length,e.getType=()=>{let e,n=0,r=0;t.nodes.length>0&&(n=t.nodes[0].y);for(let o=1;o<t.nodes.length;o++){if(e=t.nodes[o].y,e!==n)if(e>n)switch(r){case 0:case 1:r=1;break;default:r=3}else switch(r){case 0:case 2:r=2;break;default:r=3}if(n=e,3===r)break}switch(r){case 0:return&quot;Constant&quot;;case 1:return&quot;NonDecreasing&quot;;case 2:return&quot;NonIncreasing&quot;;default:return&quot;Varied&quot;}},e.getDataPointer=()=>{const e=t.nodes.length;if(t.function=null,e>0){t.function=[];for(let n=0;n<e;n++)t.function[2*n]=t.nodes[n].x,t.function[2*n+1]=t.nodes[n].y}return t.function},e.getFirstNonZeroValue=()=>{if(0===t.nodes.length)return 0;let e=1,n=0,r=0;for(;r<t.nodes.length;r++)if(0!==t.nodes[r].y){e=0;break}return n=e?Number.MAX_VALUE:r>0?t.nodes[r-1].x:t.clamping?-Number.MAX_VALUE:t.nodes[0].x,n},e.getNodeValue=(e,n)=>{const r=t.nodes.length;return e<0||e>=r?(Eb(&quot;Index out of range!&quot;),-1):(n[0]=t.nodes[e].x,n[1]=t.nodes[e].y,n[2]=t.nodes[e].midpoint,n[3]=t.nodes[e].sharpness,1)},e.setNodeValue=(n,r)=>{const o=t.nodes.length;if(n<0||n>=o)return Eb(&quot;Index out of range!&quot;),-1;const a=t.nodes[n].x;return t.nodes[n].x=r[0],t.nodes[n].y=r[1],t.nodes[n].midpoint=r[2],t.nodes[n].sharpness=r[3],a!==r[0]?e.sortAndUpdateRange():e.modified(),1},e.addPoint=(t,n)=>e.addPointLong(t,n,.5,0),e.addPointLong=(n,r,o,a)=>{if(o<0||o>1)return Eb(&quot;Midpoint outside range [0.0, 1.0]&quot;),-1;if(a<0||a>1)return Eb(&quot;Sharpness outside range [0.0, 1.0]&quot;),-1;t.allowDuplicateScalars||e.removePoint(n);const i={x:n,y:r,midpoint:o,sharpness:a};let s;for(t.nodes.push(i),e.sortAndUpdateRange(),s=0;s<t.nodes.length&&t.nodes[s].x!==n;s++);return s<t.nodes.length?s:-1},e.setNodes=n=>{t.nodes!==n&&(t.nodes=n,e.sortAndUpdateRange())},e.sortAndUpdateRange=()=>{t.nodes.sort(((e,t)=>e.x-t.x)),e.updateRange()||e.modified()},e.updateRange=()=>{const n=t.range.slice(),r=t.nodes.length;return r?(t.range[0]=t.nodes[0].x,t.range[1]=t.nodes[r-1].x):(t.range[0]=0,t.range[1]=0),(n[0]!==t.range[0]||n[1]!==t.range[1])&&(e.modified(),!0)},e.removePoint=n=>{let r;for(r=0;r<t.nodes.length&&t.nodes[r].x!==n;r++);if(r>=t.nodes.length)return-1;const o=r;let a=!1;return t.nodes.splice(r,1),0!==r&&r!==t.nodes.length||(a=e.updateRange()),a||e.modified(),o},e.removeAllPoints=()=>{t.nodes=[],e.sortAndUpdateRange()},e.addSegment=(n,r,o,a)=>{e.sortAndUpdateRange();for(let e=0;e<t.nodes.length;)t.nodes[e].x>=n&&t.nodes[e].x<=o?t.nodes.splice(e,1):e++;e.addPoint(n,r,.5,0),e.addPoint(o,a,.5,0)},e.getValue=t=>{const n=[];return e.getTable(t,t,1,n),n[0]},e.adjustRange=n=>{if(n.length<2)return 0;const r=e.getRange();r[0]<n[0]?e.addPoint(n[0],e.getValue(n[0])):e.addPoint(n[0],e.getValue(r[0])),r[1]>n[1]?e.addPoint(n[1],e.getValue(n[1])):e.addPoint(n[1],e.getValue(r[1])),e.sortAndUpdateRange();for(let e=0;e<t.nodes.length;)t.nodes[e].x>=n[0]&&t.nodes[e].x<=n[1]?t.nodes.splice(e,1):++e;return e.sortAndUpdateRange(),1},e.estimateMinNumberOfSamples=(t,n)=>{const r=e.findMinimumXDistance();return Math.ceil((n-t)/r)},e.findMinimumXDistance=()=>{const e=t.nodes.length;if(e<2)return-1;let n=t.nodes[1].x-t.nodes[0].x;for(let r=0;r<e-1;r++){const e=t.nodes[r+1].x-t.nodes[r].x;e<n&&(n=e)}return n},e.getTable=function(e,n,r,o){let a,i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:1,s=0;const l=t.nodes.length;let c=0;0!==l&&(c=t.nodes[l-1].y);let u=0,d=0,p=0,f=0,g=0,m=0,h=0;for(a=0;a<r;a++){const v=i*a;for(u=r>1?e+a/(r-1)*(n-e):.5*(e+n);s<l&&u>t.nodes[s].x;)s++,s<l&&(d=t.nodes[s-1].x,p=t.nodes[s].x,f=t.nodes[s-1].y,g=t.nodes[s].y,m=t.nodes[s-1].midpoint,h=t.nodes[s-1].sharpness,m<1e-5&&(m=1e-5),m>.99999&&(m=.99999));if(s>=l)o[v]=t.clamping?c:0;else if(0===s)o[v]=t.clamping?t.nodes[0].y:0;else{let e=(u-d)/(p-d);if(e=e<m?.5*e/m:.5+.5*(e-m)/(1-m),h>.99){if(e<.5){o[v]=f;continue}o[v]=g;continue}if(h<.01){o[v]=(1-e)*f+e*g;continue}e<.5?e=.5*(2*e)**(1+10*h):e>.5&&(e=1-.5*(2*(1-e))**(1+10*h));const t=e*e,n=t*e,r=2*n-3*t+1,a=-2*n+3*t,i=n-2*t+e,s=n-t,l=(1-h)*(g-f);o[v]=r*f+a*g+i*l+s*l;const c=f<g?f:g,T=f>g?f:g;o[v]=o[v]<c?c:o[v],o[v]=o[v]>T?T:o[v]}}}}(e,t)}var Lb={newInstance:Wt.newInstance(Db,&quot;vtkPiecewiseFunction&quot;),extend:Db};const{InterpolationType:Bb,OpacityMode:Nb,FilterMode:Fb,ColorMixPreset:_b}=Jf,{vtkErrorMacro:kb}=Wt;function Gb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};if(Object.assign(t,(e=>({colorMixPreset:_b.DEFAULT,independentComponents:!0,interpolationType:Bb.FAST_LINEAR,shade:!1,ambient:.1,diffuse:.7,specular:.2,specularPower:10,useLabelOutline:!1,labelOutlineThickness:[1],labelOutlineOpacity:1,ipScalarRange:[-1e6,1e6],filterMode:Fb.OFF,preferSizeOverAccuracy:!1,computeNormalFromOpacity:!1,volumetricScatteringBlending:0,globalIlluminationReach:0,anisotropy:0,localAmbientOcclusion:!1,LAOKernelSize:15,LAOKernelRadius:7,updatedExtents:[],...e}))(n)),Wt.obj(e,t),!t.componentData){t.componentData=[];for(let e=0;e<4;++e)t.componentData.push({colorChannels:1,grayTransferFunction:null,rGBTransferFunction:null,scalarOpacity:null,scalarOpacityUnitDistance:1,opacityMode:Nb.FRACTIONAL,gradientOpacityMinimumValue:0,gradientOpacityMinimumOpacity:0,gradientOpacityMaximumValue:1,gradientOpacityMaximumOpacity:1,useGradientOpacity:!1,componentWeight:1,forceNearestInterpolation:!1})}Wt.setGet(e,t,[&quot;colorMixPreset&quot;,&quot;independentComponents&quot;,&quot;interpolationType&quot;,&quot;shade&quot;,&quot;ambient&quot;,&quot;diffuse&quot;,&quot;specular&quot;,&quot;specularPower&quot;,&quot;useLabelOutline&quot;,&quot;labelOutlineOpacity&quot;,&quot;filterMode&quot;,&quot;preferSizeOverAccuracy&quot;,&quot;computeNormalFromOpacity&quot;,&quot;volumetricScatteringBlending&quot;,&quot;globalIlluminationReach&quot;,&quot;anisotropy&quot;,&quot;localAmbientOcclusion&quot;,&quot;LAOKernelSize&quot;,&quot;LAOKernelRadius&quot;,&quot;updatedExtents&quot;]),Wt.setGetArray(e,t,[&quot;ipScalarRange&quot;],2),Wt.setGetArray(e,t,[&quot;labelOutlineThickness&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkVolumeProperty&quot;);const n={...e};e.getMTime=()=>{let e,n=t.mtime;for(let r=0;r<4;r++)1===t.componentData[r].colorChannels?t.componentData[r].grayTransferFunction&&(e=t.componentData[r].grayTransferFunction.getMTime(),n=n>e?n:e):3===t.componentData[r].colorChannels&&t.componentData[r].rGBTransferFunction&&(e=t.componentData[r].rGBTransferFunction.getMTime(),n=n>e?n:e),t.componentData[r].scalarOpacity&&(e=t.componentData[r].scalarOpacity.getMTime(),n=n>e?n:e),t.componentData[r].gradientOpacity&&(t.componentData[r].disableGradientOpacity||(e=t.componentData[r].gradientOpacity.getMTime(),n=n>e?n:e));return n},e.getColorChannels=e=>e<0||e>3?(kb(&quot;Bad index - must be between 0 and 3&quot;),0):t.componentData[e].colorChannels,e.setGrayTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,o=!1;return t.componentData[n].grayTransferFunction!==r&&(t.componentData[n].grayTransferFunction=r,o=!0),1!==t.componentData[n].colorChannels&&(t.componentData[n].colorChannels=1,o=!0),o&&e.modified(),o},e.getGrayTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return null===t.componentData[n].grayTransferFunction&&(t.componentData[n].grayTransferFunction=Lb.newInstance(),t.componentData[n].grayTransferFunction.addPoint(0,0),t.componentData[n].grayTransferFunction.addPoint(1024,1),1!==t.componentData[n].colorChannels&&(t.componentData[n].colorChannels=1),e.modified()),t.componentData[n].grayTransferFunction},e.setRGBTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,o=!1;return t.componentData[n].rGBTransferFunction!==r&&(t.componentData[n].rGBTransferFunction=r,o=!0),3!==t.componentData[n].colorChannels&&(t.componentData[n].colorChannels=3,o=!0),o&&e.modified(),o},e.getRGBTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return null===t.componentData[n].rGBTransferFunction&&(t.componentData[n].rGBTransferFunction=Sb.newInstance(),t.componentData[n].rGBTransferFunction.addRGBPoint(0,0,0,0),t.componentData[n].rGBTransferFunction.addRGBPoint(1024,1,1,1),3!==t.componentData[n].colorChannels&&(t.componentData[n].colorChannels=3),e.modified()),t.componentData[n].rGBTransferFunction},e.setScalarOpacity=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;return t.componentData[n].scalarOpacity!==r&&(t.componentData[n].scalarOpacity=r,e.modified(),!0)},e.getScalarOpacity=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return null===t.componentData[n].scalarOpacity&&(t.componentData[n].scalarOpacity=Lb.newInstance(),t.componentData[n].scalarOpacity.addPoint(0,1),t.componentData[n].scalarOpacity.addPoint(1024,1),e.modified()),t.componentData[n].scalarOpacity},e.setComponentWeight=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;if(n<0||n>=4)return kb(&quot;Invalid index&quot;),!1;const o=Math.min(1,Math.max(0,r));return t.componentData[n].componentWeight!==o&&(t.componentData[n].componentWeight=o,e.modified(),!0)},e.getComponentWeight=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return e<0||e>=4?(kb(&quot;Invalid index&quot;),0):t.componentData[e].componentWeight},e.setInterpolationTypeToNearest=()=>e.setInterpolationType(Bb.NEAREST),e.setInterpolationTypeToLinear=()=>e.setInterpolationType(Bb.LINEAR),e.setInterpolationTypeToFastLinear=()=>e.setInterpolationType(Bb.FAST_LINEAR),e.getInterpolationTypeAsString=()=>Wt.enumToString(Bb,t.interpolationType),[&quot;useGradientOpacity&quot;,&quot;scalarOpacityUnitDistance&quot;,&quot;gradientOpacityMinimumValue&quot;,&quot;gradientOpacityMinimumOpacity&quot;,&quot;gradientOpacityMaximumValue&quot;,&quot;gradientOpacityMaximumOpacity&quot;,&quot;opacityMode&quot;,&quot;forceNearestInterpolation&quot;].forEach((n=>{const r=Wt.capitalize(n);e[`set${r}`]=(r,o)=>t.componentData[r][`${n}`]!==o&&(t.componentData[r][`${n}`]=o,e.modified(),!0)})),[&quot;useGradientOpacity&quot;,&quot;scalarOpacityUnitDistance&quot;,&quot;gradientOpacityMinimumValue&quot;,&quot;gradientOpacityMinimumOpacity&quot;,&quot;gradientOpacityMaximumValue&quot;,&quot;gradientOpacityMaximumOpacity&quot;,&quot;opacityMode&quot;,&quot;forceNearestInterpolation&quot;].forEach((n=>{const r=Wt.capitalize(n);e[`get${r}`]=e=>t.componentData[e][`${n}`]})),e.setAverageIPScalarRange=(t,n)=>{console.warn(&quot;setAverageIPScalarRange is deprecated use setIpScalarRange&quot;),e.setIpScalarRange(t,n)},e.getFilterModeAsString=()=>Wt.enumToString(Fb,t.filterMode),e.setFilterModeToOff=()=>{e.setFilterMode(Fb.OFF)},e.setFilterModeToNormalized=()=>{e.setFilterMode(Fb.NORMALIZED)},e.setFilterModeToRaw=()=>{e.setFilterMode(Fb.RAW)},e.setGlobalIlluminationReach=e=>n.setGlobalIlluminationReach(ba(e,0,1)),e.setVolumetricScatteringBlending=e=>n.setVolumetricScatteringBlending(ba(e,0,1)),e.setAnisotropy=e=>n.setAnisotropy(ba(e,-.99,.99)),e.setLAOKernelSize=e=>n.setLAOKernelSize(bo(ba(e,1,32))),e.setLAOKernelRadius=e=>n.setLAOKernelRadius(e>=1?e:1)}(e,t)}var Ub={newInstance:Wt.newInstance(Gb,&quot;vtkVolumeProperty&quot;),extend:Gb,...Jf};const zb={mapper:null};function Wb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,zb,n),Xi.extend(e,t,n),t.boundsMTime={},Wt.obj(t.boundsMTime),Wt.setGet(e,t,[&quot;mapper&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkVolume&quot;),e.getVolumes=()=>[e],e.makeProperty=Ub.newInstance,e.getRedrawMTime=()=>{let e=t.mtime;if(null!==t.mapper){let n=t.mapper.getMTime();e=n>e?n:e,null!==t.mapper.getInput()&&(t.mapper.getInputAlgorithm().update(),n=t.mapper.getInput().getMTime(),e=n>e?n:e)}return e}}(e,t)}var Hb={newInstance:Wt.newInstance(Wb,&quot;vtkVolume&quot;),extend:Wb};const{BlendMode:jb}=tg,Kb=[&quot;getAnisotropy&quot;,&quot;getComputeNormalFromOpacity&quot;,&quot;getFilterMode&quot;,&quot;getFilterModeAsString&quot;,&quot;getGlobalIlluminationReach&quot;,&quot;getIpScalarRange&quot;,&quot;getIpScalarRangeByReference&quot;,&quot;getLAOKernelRadius&quot;,&quot;getLAOKernelSize&quot;,&quot;getLocalAmbientOcclusion&quot;,&quot;getPreferSizeOverAccuracy&quot;,&quot;getVolumetricScatteringBlending&quot;,&quot;setAnisotropy&quot;,&quot;setAverageIPScalarRange&quot;,&quot;setComputeNormalFromOpacity&quot;,&quot;setFilterMode&quot;,&quot;setFilterModeToNormalized&quot;,&quot;setFilterModeToOff&quot;,&quot;setFilterModeToRaw&quot;,&quot;setGlobalIlluminationReach&quot;,&quot;setIpScalarRange&quot;,&quot;setIpScalarRangeFrom&quot;,&quot;setLAOKernelRadius&quot;,&quot;setLAOKernelSize&quot;,&quot;setLocalAmbientOcclusion&quot;,&quot;setPreferSizeOverAccuracy&quot;,&quot;setVolumetricScatteringBlending&quot;],$b={createRadonTransferFunction:function(e,t,n,r,o){let a=null;return o?(a=o,a.removeAllPoints()):a=Lb.newInstance(),a.addPointLong(-1024,0,1,1),a.addPoint(e,t),a.addPoint(n,r),a}};function qb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,(e=>({bounds:[...Gi.INIT_BOUNDS],sampleDistance:1,imageSampleDistance:1,maximumSamplesPerRay:1e3,autoAdjustSampleDistances:!0,initialInteractionScale:1,interactionSampleDistanceFactor:1,blendMode:jb.COMPOSITE_BLEND,volumeShadowSamplingDistFactor:5,colorTextureWidth:1024,opacityTextureWidth:1024,labelOutlineTextureWidth:1024,...e}))(n)),As(e,t,n),Wt.setGet(e,t,[&quot;sampleDistance&quot;,&quot;imageSampleDistance&quot;,&quot;maximumSamplesPerRay&quot;,&quot;autoAdjustSampleDistances&quot;,&quot;initialInteractionScale&quot;,&quot;interactionSampleDistanceFactor&quot;,&quot;blendMode&quot;,&quot;volumeShadowSamplingDistFactor&quot;,&quot;colorTextureWidth&quot;,&quot;opacityTextureWidth&quot;,&quot;labelOutlineTextureWidth&quot;]),Wt.event(e,t,&quot;lightingActivated&quot;),function(e,t){t.classHierarchy.push(&quot;vtkVolumeMapper&quot;);const n={...e};e.getBounds=()=>(t.static||e.update(),t.bounds=[...e.getInputData().getBounds()],t.bounds),e.setBlendModeToComposite=()=>{e.setBlendMode(jb.COMPOSITE_BLEND)},e.setBlendModeToMaximumIntensity=()=>{e.setBlendMode(jb.MAXIMUM_INTENSITY_BLEND)},e.setBlendModeToMinimumIntensity=()=>{e.setBlendMode(jb.MINIMUM_INTENSITY_BLEND)},e.setBlendModeToAverageIntensity=()=>{e.setBlendMode(jb.AVERAGE_INTENSITY_BLEND)},e.setBlendModeToAdditiveIntensity=()=>{e.setBlendMode(jb.ADDITIVE_INTENSITY_BLEND)},e.setBlendModeToRadonTransform=()=>{e.setBlendMode(jb.RADON_TRANSFORM_BLEND)},e.getBlendModeAsString=()=>Wt.enumToString(jb,t.blendMode),e.setVolumeShadowSamplingDistFactor=e=>n.setVolumeShadowSamplingDistFactor(e>=1?e:1),Kb.forEach((t=>{e[t]=()=>{throw new Error(`The method &quot;volumeMapper.${t}()&quot; doesn't exist anymore. It is a rendering property that has been moved to the volume property. Replace your code with:\\nvolumeActor.getProperty().${t}()\\n`)}}))}(e,t)}var Xb={newInstance:Wt.newInstance(qb,&quot;vtkVolumeMapper&quot;),extend:qb,...$b};const{InterpolationType:Yb}=Rf,{vtkErrorMacro:Zb}=Wt;function Qb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};if(Object.assign(t,(e=>({independentComponents:!1,interpolationType:Yb.LINEAR,colorWindow:255,colorLevel:127.5,ambient:1,diffuse:0,opacity:1,useLookupTableScalarRange:!1,useLabelOutline:!1,labelOutlineThickness:[1],labelOutlineOpacity:1,updatedExtents:[],...e}))(n)),Wt.obj(e,t),!t.componentData){t.componentData=[];for(let e=0;e<4;e++)t.componentData.push({rGBTransferFunction:null,piecewiseFunction:null,componentWeight:1})}Wt.setGet(e,t,[&quot;independentComponents&quot;,&quot;interpolationType&quot;,&quot;colorWindow&quot;,&quot;colorLevel&quot;,&quot;ambient&quot;,&quot;diffuse&quot;,&quot;opacity&quot;,&quot;useLookupTableScalarRange&quot;,&quot;useLabelOutline&quot;,&quot;labelOutlineOpacity&quot;,&quot;updatedExtents&quot;]),Wt.setGetArray(e,t,[&quot;labelOutlineThickness&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkImageProperty&quot;),e.getMTime=()=>{let e,n=t.mtime;for(let r=0;r<4;r++)t.componentData[r].rGBTransferFunction&&(e=t.componentData[r].rGBTransferFunction.getMTime(),n=n>e?n:e),t.componentData[r].piecewiseFunction&&(e=t.componentData[r].piecewiseFunction.getMTime(),n=n>e?n:e);return n},e.setRGBTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=n,o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;return Number.isInteger(n)||(o=n,r=0),t.componentData[r].rGBTransferFunction!==o&&(t.componentData[r].rGBTransferFunction=o,e.modified(),!0)},e.getRGBTransferFunction=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.componentData[e].rGBTransferFunction},e.setPiecewiseFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=n,o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;return Number.isInteger(n)||(o=n,r=0),t.componentData[r].piecewiseFunction!==o&&(t.componentData[r].piecewiseFunction=o,e.modified(),!0)},e.getPiecewiseFunction=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.componentData[e].piecewiseFunction},e.setScalarOpacity=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,n=t,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;return Number.isInteger(t)||(r=t,n=0),e.setPiecewiseFunction(n,r)},e.getScalarOpacity=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return e.getPiecewiseFunction(t)},e.setComponentWeight=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;if(n<0||n>=4)return Zb(&quot;Invalid index&quot;),!1;const o=Math.min(1,Math.max(0,r));return t.componentData[n].componentWeight!==o&&(t.componentData[n].componentWeight=o,e.modified(),!0)},e.getComponentWeight=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return e<0||e>=4?(Zb(&quot;Invalid index&quot;),0):t.componentData[e].componentWeight},e.setInterpolationTypeToNearest=()=>e.setInterpolationType(Yb.NEAREST),e.setInterpolationTypeToLinear=()=>e.setInterpolationType(Yb.LINEAR),e.getInterpolationTypeAsString=()=>Wt.enumToString(Yb,t.interpolationType)}(e,t)}var Jb={newInstance:Wt.newInstance(Qb,&quot;vtkImageProperty&quot;),extend:Qb};const ex={mapper:null,forceOpaque:!1,forceTranslucent:!1};function tx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ex,n),Xi.extend(e,t,n),t.boundsMTime={},Wt.obj(t.boundsMTime),Wt.setGet(e,t,[&quot;mapper&quot;,&quot;forceOpaque&quot;,&quot;forceTranslucent&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkImageSlice&quot;),e.getActors=()=>e,e.getImages=()=>e,e.getIsOpaque=()=>{if(t.forceOpaque)return!0;if(t.forceTranslucent)return!1;t.properties[0]||e.getProperty();let n=t.properties[0].getOpacity()>=1;return n=n&&(!t.mapper||t.mapper.getIsOpaque()),n},e.hasTranslucentPolygonalGeometry=()=>!1,e.makeProperty=Jb.newInstance,e.getBoundsForSlice=(n,r)=>{const o=t.mapper.getBoundsForSlice(n,r);if(!Gi.isValid(o))return o;e.computeMatrix();const a=new Float64Array(16);return h(a,t.matrix),Gi.transformBounds(o,a)},e.getMinXBound=()=>e.getBounds()[0],e.getMaxXBound=()=>e.getBounds()[1],e.getMinYBound=()=>e.getBounds()[2],e.getMaxYBound=()=>e.getBounds()[3],e.getMinZBound=()=>e.getBounds()[4],e.getMaxZBound=()=>e.getBounds()[5],e.getRedrawMTime=()=>{let e=t.mtime;if(null!==t.mapper){let n=t.mapper.getMTime();e=n>e?n:e,null!==t.mapper.getInput()&&(t.mapper.getInputAlgorithm().update(),n=t.mapper.getInput().getMTime(),e=n>e?n:e)}return t.properties.forEach((t=>{e=Math.max(e,t.getMTime());const n=t.getRGBTransferFunction();null!==n&&(e=Math.max(e,n.getMTime()))})),e},e.getSupportsSelection=()=>!!t.mapper&&t.mapper.getSupportsSelection()}(e,t)}var nx={newInstance:Wt.newInstance(tx,&quot;vtkImageSlice&quot;),extend:tx};const rx={slice:0,customDisplayExtent:[0,0,0,0,0,0],useCustomExtents:!1,backgroundColor:[0,0,0,1],colorTextureWidth:1024,opacityTextureWidth:1024,labelOutlineTextureWidth:1024};var ox=function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,rx,n),As(e,t,n),Wt.setGet(e,t,[&quot;slice&quot;,&quot;useCustomExtents&quot;,&quot;colorTextureWidth&quot;,&quot;opacityTextureWidth&quot;,&quot;labelOutlineTextureWidth&quot;]),Wt.setGetArray(e,t,[&quot;customDisplayExtent&quot;],6),Wt.setGetArray(e,t,[&quot;backgroundColor&quot;],4),function(e,t){t.classHierarchy.push(&quot;vtkAbstractImageMapper&quot;),e.getIsOpaque=()=>!0,e.getCurrentImage=()=>null,e.getBoundsForSlice=()=>(Wt.vtkErrorMacro(&quot;vtkAbstractImageMapper.getBoundsForSlice - NOT IMPLEMENTED&quot;),Pa())}(e,t)};function ax(e,t,n){const r=n.getCurrentImage(),o=r.getExtent(),a=[o[0],o[2],o[4]],{ijkMode:i}=n.getClosestIJKAxis();let s=n.isA(&quot;vtkImageArrayMapper&quot;)?n.getSubSlice():n.getSlice();i!==n.getSlicingMode()&&(s=n.getSliceAtPosition(s)),a[i]+=s;const l=[0,0,0];r.indexToWorld(a,l),a[i]+=1;const c=[0,0,0];r.indexToWorld(a,c),c[0]-=l[0],c[1]-=l[1],c[2]-=l[2],Cn(c,c);const u=ei.intersectWithLine(e,t,l,c);if(u.intersection){const e=u.x,t=[0,0,0];return r.worldToIndex(e,t),{t:u.t,absoluteIJK:t}}return null}const{staticOffsetAPI:ix,otherStaticMethods:sx}=Sl,{SlicingMode:lx}=Lf;const cx={slicingMode:lx.NONE,closestIJKAxis:{ijkMode:lx.NONE,flip:!1},renderToRectangle:!1,sliceAtFocalPoint:!1,preferSizeOverAccuracy:!1};function ux(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,cx,n),ox(e,t,n),Wt.get(e,t,[&quot;slicingMode&quot;]),Wt.setGet(e,t,[&quot;closestIJKAxis&quot;,&quot;renderToRectangle&quot;,&quot;sliceAtFocalPoint&quot;,&quot;preferSizeOverAccuracy&quot;]),Sl.implementCoincidentTopologyMethods(e,t),function(e,t){function n(){let n;switch(t.slicingMode){case lx.X:n=0;break;case lx.Y:n=1;break;case lx.Z:n=2;break;default:return void(t.closestIJKAxis={ijkMode:t.slicingMode,flip:!1})}const r=Ra(e.getCurrentImage().getDirection());let o=0;for(;o<3&&0===r[n+3*o];++o);const a=r[n+3*o]<0;t.closestIJKAxis={ijkMode:o,flip:a}}t.classHierarchy.push(&quot;vtkImageMapper&quot;),e.getSliceAtPosition=n=>{const r=e.getCurrentImage();let o;if(3===n.length)o=n;else if(Number.isFinite(n)){const e=r.getBounds();switch(t.slicingMode){case lx.X:o=[n,(e[3]+e[2])/2,(e[5]+e[4])/2];break;case lx.Y:o=[(e[1]+e[0])/2,n,(e[5]+e[4])/2];break;case lx.Z:o=[(e[1]+e[0])/2,(e[3]+e[2])/2,n]}}const a=[0,0,0];r.worldToIndex(o,a);const i=r.getExtent(),{ijkMode:s}=e.getClosestIJKAxis();let l=0;switch(s){case lx.I:l=ba(a[0],i[0],i[1]);break;case lx.J:l=ba(a[1],i[2],i[3]);break;case lx.K:l=ba(a[2],i[4],i[5]);break;default:return 0}return l},e.setSliceFromCamera=n=>{const r=n.getFocalPoint();switch(t.slicingMode){case lx.I:case lx.J:case lx.K:{const t=e.getSliceAtPosition(r);e.setSlice(t)}break;case lx.X:e.setSlice(r[0]);break;case lx.Y:e.setSlice(r[1]);break;case lx.Z:e.setSlice(r[2])}},e.setXSlice=t=>{e.setSlicingMode(lx.X),e.setSlice(t)},e.setYSlice=t=>{e.setSlicingMode(lx.Y),e.setSlice(t)},e.setZSlice=t=>{e.setSlicingMode(lx.Z),e.setSlice(t)},e.setISlice=t=>{e.setSlicingMode(lx.I),e.setSlice(t)},e.setJSlice=t=>{e.setSlicingMode(lx.J),e.setSlice(t)},e.setKSlice=t=>{e.setSlicingMode(lx.K),e.setSlice(t)},e.getSlicingModeNormal=()=>{const n=[0,0,0],r=e.getCurrentImage().getDirection();switch(t.slicingMode){case lx.X:n[0]=1;break;case lx.Y:n[1]=1;break;case lx.Z:n[2]=1;break;case lx.I:Ho(r,[1,0,0],n);break;case lx.J:Ho(r,[0,1,0],n);break;case lx.K:Ho(r,[0,0,1],n)}return n},e.setSlicingMode=r=>{t.slicingMode!==r&&(t.slicingMode=r,e.getCurrentImage()&&n(),e.modified())},e.getClosestIJKAxis=()=>(void 0!==t.closestIJKAxis&&t.closestIJKAxis.ijkMode!==lx.NONE||!e.getCurrentImage()||n(),t.closestIJKAxis),e.getBounds=()=>{const n=e.getCurrentImage();if(!n)return Pa();if(!t.useCustomExtents)return n.getBounds();const r=t.customDisplayExtent.slice(),{ijkMode:o}=e.getClosestIJKAxis();let a=t.slice;switch(o!==t.slicingMode&&(a=e.getSliceAtPosition(t.slice)),o){case lx.I:r[0]=a,r[1]=a;break;case lx.J:r[2]=a,r[3]=a;break;case lx.K:r[4]=a,r[5]=a}return n.extentToBounds(r)},e.getBoundsForSlice=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:t.slice,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;const o=e.getCurrentImage();if(!o)return Pa();const a=o.getSpatialExtent(),{ijkMode:i}=e.getClosestIJKAxis();let s=n;switch(i!==t.slicingMode&&(s=e.getSliceAtPosition(n)),i){case lx.I:a[0]=s-r,a[1]=s+r;break;case lx.J:a[2]=s-r,a[3]=s+r;break;case lx.K:a[4]=s-r,a[5]=s+r}return o.extentToBounds(a)},e.intersectWithLineForPointPicking=(t,n)=>function(e,t,n){const r=ax(e,t,n);if(r){const e=n.getCurrentImage().getExtent(),t=[Math.round(r.absoluteIJK[0]),Math.round(r.absoluteIJK[1]),Math.round(r.absoluteIJK[2])];return t[0]<e[0]||t[0]>e[1]||t[1]<e[2]||t[1]>e[3]||t[2]<e[4]||t[2]>e[5]?null:{t:r.t,ijk:t}}return null}(t,n,e),e.intersectWithLineForCellPicking=(t,n)=>function(e,t,n){const r=ax(e,t,n);if(r){const e=n.getCurrentImage().getExtent(),t=r.absoluteIJK,o=[Math.floor(t[0]),Math.floor(t[1]),Math.floor(t[2])];if(o[0]<e[0]||o[0]>e[1]-1||o[1]<e[2]||o[1]>e[3]-1||o[2]<e[4]||o[2]>(e[5]?e[5]-1:e[5]))return null;const a=[t[0]-o[0],t[1]-o[1],t[2]-o[2]];return{t:r.t,ijk:o,pCoords:a}}return null}(t,n,e),e.getCurrentImage=()=>e.getInputData()}(e,t)}var dx={newInstance:Wt.newInstance(ux,&quot;vtkImageMapper&quot;),extend:ux,...ix,...sx,...Lf};const{vtkErrorMacro:px}=Wt;function fx(e,t,n,r){e.set(function(e,t){let n=0;return e.map(((e,r)=>r===n?(n+=e+1,e):e+t))}(t,n),r)}const gx={outputPointsPrecision:Ms.DEFAULT};function mx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,gx,n),Wt.setGet(e,t,[&quot;outputPointsPrecision&quot;]),Wt.obj(e,t),Wt.algo(e,t,1,1),function(e,t){t.classHierarchy.push(&quot;vtkAppendPolyData&quot;),e.requestData=(n,r)=>{const o=e.getNumberOfInputPorts();if(!o)return void px(&quot;No input specified.&quot;);if(1===o)return void(r[0]=n[0]);const a=r[0]&&n[0]!==r[0]?r[0].initialize():gu.newInstance();let i=0,s=0,l=1,c=1,u=0,d=0,p=0,f=0,g=!0,m=!0,h=!0;for(let e=0;e<o;e++){const t=n[e];if(!t)continue;const r=t.getPoints().getNumberOfPoints();i+=r,u+=t.getVerts().getNumberOfValues(),d+=t.getLines().getNumberOfValues(),p+=t.getStrips().getNumberOfValues(),f+=t.getPolys().getNumberOfValues(),r&&(c&&(c=0,s=t.getPoints().getDataType()),l=t.getPoints().getDataType(),s=s>l?s:l);const o=t.getPointData();o?(g=g&&null!==o.getNormals(),m=m&&null!==o.getTCoords(),h=h&&null!==o.getScalars()):(g=!1,m=!1,h=!1)}t.outputPointsPrecision===Ms.SINGLE?s=cs.FLOAT:t.outputPointsPrecision===Ms.DOUBLE&&(s=cs.DOUBLE);const v=Yl.newInstance({dataType:s});v.setNumberOfPoints(i);const T=v.getData(),y=new Uint32Array(u),b=new Uint32Array(d),x=new Uint32Array(p),C=new Uint32Array(f);let S=null,A=null,I=null;const w=n[o-1];if(g){const e=w.getPointData().getNormals();S=xs.newInstance({numberOfComponents:3,numberOfTuples:i,size:3*i,dataType:e.getDataType(),name:e.getName()})}if(m){const e=w.getPointData().getTCoords();A=xs.newInstance({numberOfComponents:2,numberOfTuples:i,size:2*i,dataType:e.getDataType(),name:e.getName()})}if(h){const e=w.getPointData().getScalars();I=xs.newInstance({numberOfComponents:e.getNumberOfComponents(),numberOfTuples:i,size:i*e.getNumberOfComponents(),dataType:e.getDataType(),name:e.getName()})}i=0,u=0,d=0,p=0,f=0;for(let e=0;e<o;e++){const t=n[e];T.set(t.getPoints().getData(),3*i),fx(y,t.getVerts().getData(),i,u),u+=t.getVerts().getNumberOfValues(),fx(b,t.getLines().getData(),i,d),d+=t.getLines().getNumberOfValues(),fx(x,t.getStrips().getData(),i,p),p+=t.getStrips().getNumberOfValues(),fx(C,t.getPolys().getData(),i,f),f+=t.getPolys().getNumberOfValues();const r=t.getPointData();if(g){const e=r.getNormals();S.getData().set(e.getData(),3*i)}if(m){const e=r.getTCoords();A.getData().set(e.getData(),2*i)}if(h){const e=r.getScalars();I.getData().set(e.getData(),i*I.getNumberOfComponents())}i+=t.getPoints().getNumberOfPoints()}a.setPoints(v),a.getVerts().setData(y),a.getLines().setData(b),a.getStrips().setData(x),a.getPolys().setData(C),S&&a.getPointData().setNormals(S),A&&a.getPointData().setTCoords(A),I&&a.getPointData().setScalars(I),r[0]=a}}(e,t)}var hx={newInstance:Wt.newInstance(mx,&quot;vtkAppendPolyData&quot;),extend:mx};const vx={height:1,radius:.5,resolution:6,center:[0,0,0],direction:[1,0,0],capping:!0,pointType:&quot;Float64Array&quot;};function Tx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,vx,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;height&quot;,&quot;radius&quot;,&quot;resolution&quot;,&quot;capping&quot;]),Wt.setGetArray(e,t,[&quot;center&quot;,&quot;direction&quot;],3),Wt.algo(e,t,0,1),function(e,t){t.classHierarchy.push(&quot;vtkConeSource&quot;),e.requestData=(e,n)=>{const r=2*Math.PI/t.resolution,o=-t.height/2,a=t.resolution+1,i=4*t.resolution+1+t.resolution;let s=0;const l=Wt.newTypedArray(t.pointType,3*a);let c=0;const u=new Uint32Array(i);l[0]=t.height/2,l[1]=0,l[2]=0,t.capping&&(u[c++]=t.resolution);for(let e=0;e<t.resolution;e++)s++,l[3*s+0]=o,l[3*s+1]=t.radius*Math.cos(e*r),l[3*s+2]=t.radius*Math.sin(e*r),t.capping&&(u[t.resolution-c+++1]=s);for(let e=0;e<t.resolution;e++)u[c++]=3,u[c++]=0,u[c++]=e+1,u[c++]=e+2>t.resolution?1:e+2;df().translate(...t.center).rotateFromDirections([1,0,0],t.direction).apply(l);const d=n[0]?.initialize()||gu.newInstance();d.getPoints().setData(l,3),d.getPolys().setData(u,1),n[0]=d}}(e,t)}var yx={newInstance:Wt.newInstance(Tx,&quot;vtkConeSource&quot;),extend:Tx};const bx={height:1,initAngle:0,radius:1,resolution:6,center:[0,0,0],direction:[0,1,0],capping:!0,pointType:&quot;Float64Array&quot;};function xx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,bx,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;height&quot;,&quot;initAngle&quot;,&quot;otherRadius&quot;,&quot;radius&quot;,&quot;resolution&quot;,&quot;capping&quot;]),Wt.setGetArray(e,t,[&quot;center&quot;,&quot;direction&quot;],3),Wt.algo(e,t,0,1),function(e,t){t.classHierarchy.push(&quot;vtkCylinderSource&quot;),e.requestData=(e,n)=>{const r=2*Math.PI/t.resolution;let o=2*t.resolution,a=5*t.resolution;t.capping&&(o=4*t.resolution,a=7*t.resolution+2);const i=Wt.newTypedArray(t.pointType,3*o);let s=0;const l=new Uint32Array(a),c=new Float32Array(3*o),u=xs.newInstance({numberOfComponents:3,values:c,name:&quot;Normals&quot;}),d=new Float32Array(2*o),p=xs.newInstance({numberOfComponents:2,values:d,name:&quot;TCoords&quot;}),f=[0,0,0],g=[0,0,0],m=[0,0,0],h=[0,0,0],v=[0,0],T=[0,0],y=null==t.otherRadius?t.radius:t.otherRadius;for(let e=0;e<t.resolution;e++){f[0]=Math.cos(e*r+t.initAngle),g[0]=f[0],m[0]=t.radius*f[0]+t.center[0],h[0]=m[0],v[0]=Math.abs(2*e/t.resolution-1),T[0]=v[0],m[1]=.5*t.height+t.center[1],h[1]=-.5*t.height+t.center[1],v[1]=0,T[1]=1,f[2]=-Math.sin(e*r+t.initAngle),g[2]=f[2],m[2]=y*f[2]+t.center[2],h[2]=m[2];const n=2*e;for(let e=0;e<3;e++)c[3*n+e]=f[e],c[3*(n+1)+e]=g[e],i[3*n+e]=m[e],i[3*(n+1)+e]=h[e],e<2&&(d[2*n+e]=v[e],d[2*(n+1)+e]=T[e])}for(let e=0;e<t.resolution;e++){l[s++]=4,l[s++]=2*e,l[s++]=2*e+1;const n=(2*e+3)%(2*t.resolution);l[s++]=n,l[s++]=n-1}if(t.capping){for(let e=0;e<t.resolution;e++){m[0]=t.radius*Math.cos(e*r+t.initAngle),h[0]=m[0],v[0]=m[0],T[0]=m[0],m[0]+=t.center[0],h[0]+=t.center[0],f[1]=1,g[1]=-1,m[1]=.5*t.height+t.center[1],h[1]=-.5*t.height+t.center[1],m[2]=-y*Math.sin(e*r+t.initAngle),h[2]=m[2],v[1]=m[2],T[1]=m[2],m[2]+=t.center[2],h[2]+=t.center[2];const n=2*t.resolution+e,o=3*t.resolution+t.resolution-e-1;for(let e=0;e<3;e++)c[3*n+e]=f[e],c[3*o+e]=g[e],i[3*n+e]=m[e],i[3*o+e]=h[e],e<2&&(d[2*n+e]=v[e],d[2*o+e]=T[e])}l[s++]=t.resolution;for(let e=0;e<t.resolution;e++)l[s++]=2*t.resolution+e;l[s++]=t.resolution;for(let e=0;e<t.resolution;e++)l[s++]=3*t.resolution+e}df().translate(...t.center).rotateFromDirections([0,1,0],t.direction).translate(...t.center.map((e=>-1*e))).apply(i);const b=n[0]?.initialize()||gu.newInstance();b.getPoints().setData(i,3),b.getPolys().setData(l,1),b.getPointData().setNormals(u),b.getPointData().setTCoords(p),n[0]=b}}(e,t)}var Cx={newInstance:Wt.newInstance(xx,&quot;vtkCylinderSource&quot;),extend:xx};const Sx={tipResolution:6,tipRadius:.1,tipLength:.35,shaftResolution:6,shaftRadius:.03,invert:!1,direction:[1,0,0],pointType:&quot;Float64Array&quot;};function Ax(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Sx,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;tipResolution&quot;,&quot;tipRadius&quot;,&quot;tipLength&quot;,&quot;shaftResolution&quot;,&quot;shaftRadius&quot;,&quot;invert&quot;]),Wt.setGetArray(e,t,[&quot;direction&quot;],3),Wt.algo(e,t,0,1),function(e,t){t.classHierarchy.push(&quot;vtkArrowSource&quot;),e.requestData=(e,n)=>{const r=Cx.newInstance({capping:!0});r.setResolution(t.shaftResolution),r.setRadius(t.shaftRadius),r.setHeight(1-t.tipLength),r.setCenter(0,.5*(1-t.tipLength),0);const o=r.getOutputData(),a=o.getPoints().getData(),i=o.getPointData().getNormals().getData();uf().rotateZ(-90).apply(a).apply(i);const s=yx.newInstance();s.setResolution(t.tipResolution),s.setHeight(t.tipLength),s.setRadius(t.tipRadius);const l=s.getOutputData(),c=l.getPoints().getData();df().translate(1-.5*t.tipLength,0,0).apply(c);const u=hx.newInstance();u.setInputData(o),u.addInputData(l);const d=u.getOutputData(),p=d.getPoints().getData();df().translate(.5*t.tipLength-.5,0,0).apply(p),t.invert?(df().rotateFromDirections([1,0,0],t.direction).scale(-1,-1,-1).apply(p),n[0]=d):(df().rotateFromDirections([1,0,0],t.direction).scale(1,1,1).apply(p),n[0]=u.getOutputData())}}(e,t)}var Ix={newInstance:Wt.newInstance(Ax,&quot;vtkArrowSource&quot;),extend:Ax};function wx(e){const t=e.getPoints().getBounds(),n=[.5*-(t[0]+t[1]),.5*-(t[2]+t[3]),.5*-(t[4]+t[5])];uf().translate(...n).apply(e.getPoints().getData())}function Ox(e,t){let n=arguments.length>2&&void 0!==arguments[2]&&arguments[2];const r=e.getPoints().getBounds(),o=[0,0,0];o[t]=n?-r[2*t+1]:-r[2*t],uf().translate(...o).apply(e.getPoints().getData())}function Px(e,t,n,r){const o=e.getPoints().getData().length,a=new Uint8ClampedArray(o);let i=0;for(;i<o;)a[i++]=t,a[i++]=n,a[i++]=r;e.getPointData().setScalars(xs.newInstance({name:&quot;color&quot;,numberOfComponents:3,values:a}))}function Rx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};ss.extend(e,t,function(e){return{config:{recenter:!0,tipResolution:60,tipRadius:.1,tipLength:.2,shaftResolution:60,shaftRadius:.03,invert:!1,...e?.config},xConfig:{color:[255,0,0],invert:!1,...e?.xConfig},yConfig:{color:[255,255,0],invert:!1,...e?.yConfig},zConfig:{color:[0,128,0],invert:!1,...e?.zConfig}}}(n)),Wt.setGet(e,t,[&quot;config&quot;,&quot;xConfig&quot;,&quot;yConfig&quot;,&quot;zConfig&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkAxesActor&quot;);const n=Gl.newInstance();e.setMapper(n),e.update=()=>{let e={...t.config,...t.xConfig};const r=Ix.newInstance({direction:[1,0,0],...e}).getOutputData();t.config.recenter?wx(r):Ox(r,0,e.invert),Px(r,...e.color),e={...t.config,...t.yConfig};const o=Ix.newInstance({direction:[0,1,0],...e}).getOutputData();t.config.recenter?wx(o):Ox(o,1,e.invert),Px(o,...e.color),e={...t.config,...t.zConfig};const a=Ix.newInstance({direction:[0,0,1],...e}).getOutputData();t.config.recenter?wx(a):Ox(a,2,e.invert),Px(a,...e.color);const i=hx.newInstance();i.setInputData(r),i.addInputData(o),i.addInputData(a),n.setInputConnection(i.getOutputPort())},e.update();const r=Wt.debounce(e.update,0);e.setXAxisColor=t=>e.setXConfig({...e.getXConfig(),color:t}),e.setYAxisColor=t=>e.setYConfig({...e.getYConfig(),color:t}),e.setZAxisColor=t=>e.setZConfig({...e.getZConfig(),color:t}),e.getXAxisColor=()=>t.getXConfig().color,e.getYAxisColor=()=>t.getYConfig().color,e.getZAxisColor=()=>t.getZConfig().color,t._onConfigChanged=r,t._onXConfigChanged=r,t._onYConfigChanged=r,t._onZConfigChanged=r}(e,t)}var Mx={newInstance:Wt.newInstance(Rx,&quot;vtkAxesActor&quot;),extend:Rx};const Ex=&quot;resetcamera&quot;,Vx=&quot;orientation&quot;,Dx={MODE_RESET_CAMERA:Ex,MODE_ORIENTATION:Vx,MODE_SAME:&quot;same&quot;};const Lx={mode:Vx,focalPoint:[0,0,0],distance:6.8,active:!0};function Bx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Lx,n),ht(e,t),Ct(e,t,[&quot;mode&quot;,&quot;active&quot;,&quot;srcRenderer&quot;,&quot;dstRenderer&quot;,&quot;distance&quot;]),It(e,t,[&quot;focalPoint&quot;],3,0),function(e,t){t.classHierarchy.push(&quot;vtkCameraSynchronizer&quot;);const n=new Float64Array(9),r=new Float64Array(3),o=[];function a(){for(;o.length;)o.pop().unsubscribe();if(!t.srcRenderer||!t.dstRenderer)return;const n=t.srcRenderer.getActiveCamera(),r=t.srcRenderer.getRenderWindow().getInteractor();o.push(n.onModified((()=>{r.isAnimating()||e.update()}))),o.push(r.onAnimation(e.update)),o.push(r.onEndAnimation(e.update))}t._onSrcRendererChanged=a,t._onDstRendererChanged=a,e.update=()=>{if(!t.active||!t.srcRenderer||!t.dstRenderer)return;const e=t.srcRenderer.getActiveCamera(),o=t.dstRenderer.getActiveCamera(),a=(i=e.getReferenceByName(&quot;position&quot;),s=e.getReferenceByName(&quot;focalPoint&quot;),l=e.getReferenceByName(&quot;viewUp&quot;),(n[0]!==i[0]||n[1]!==i[1]||n[2]!==i[2]||n[3]!==s[0]||n[4]!==s[1]||n[5]!==s[2]||n[6]!==l[0]||n[7]!==l[1]||n[8]!==l[2])&&(n[0]=i[0],n[1]=i[1],n[2]=i[2],n[3]=s[0],n[4]=s[1],n[5]=s[2],n[6]=l[0],n[7]=l[1],n[8]=l[2],n));var i,s,l;a&&(t.mode===Vx?(r[0]=a[0]-a[3],r[1]=a[1]-a[4],r[2]=a[2]-a[5],Fo(r),o.setPosition(t.focalPoint[0]+t.distance*r[0],t.focalPoint[1]+t.distance*r[1],t.focalPoint[2]+t.distance*r[2]),o.setFocalPoint(t.focalPoint[0],t.focalPoint[1],t.focalPoint[2]),o.setViewUp(a[6],a[7],a[8])):(o.setPosition(a[0],a[1],a[2]),o.setFocalPoint(a[3],a[4],a[5]),o.setViewUp(a[6],a[7],a[8])),t.mode===Ex&&t.dstRenderer.resetCamera())},e.delete=Et((()=>e.setSrcRenderer(null)),e.delete),a()}(e,t)}var Nx={newInstance:Mt(Bx,&quot;vtkCameraSynchronizer&quot;),extend:Bx,SynchronizationMode:Dx};const Fx={},_x={CameraSync:class{constructor(e,t){this.ctx=e,this.behavior=Nx.newInstance(this.getProperties(t)),this.behavior.update()}getProperties(e){let{actorBounds:t,srcRenderer:n,dstRenderer:r}=e;return{distance:3.4*Math.max(t[1]-t[0],t[3]-t[2],t[5]-t[4]),focalPoint:[.5*(t[0]+t[1]),.5*(t[2]+t[3]),.5*(t[4]+t[5])],mode:Nx.SynchronizationMode.MODE_ORIENTATION,srcRenderer:this.ctx.getInstance(n),dstRenderer:this.ctx.getInstance(r)}}update(e){this.behavior.set(this.getProperties(e)),this.behavior.update()}delete(){this.behavior.delete()}}};var kx=function(e,t,n){const r=e.get(&quot;synchronizedViewId&quot;).synchronizedViewId;if(!t.behaviors||!r)return;Fx[r]||(Fx[r]={});const o=Fx[r];if(t.behaviors.autoOrientation){const t=e.getRenderers();if(!o.autoOrientationAxes&&2===t.length){let e=null,n=null;for(let r=0;r<t.length;r++){const o=t[r];o.getInteractive()?e=o:n=o}e&&n&&(o.autoOrientationAxes=Nx.newInstance({srcRenderer:e,dstRenderer:n}))}o.autoOrientationAxes&&2!==t.length&&(o.autoOrientationAxes.delete(),delete o.autoOrientationAxes)}const a=Object.keys(t.behaviors),i=Object.keys(o);for(let e=0;e<a.length;e++){const r=a[e];if(o[r])o[r].update(t.behaviors[r]);else{const e=t.behaviors[r];_x[e.type]?o[r]=new _x[e.type](n,e):console.log(&quot;No mapping for&quot;,e)}}for(let e=0;e<i.length;e++){const n=a[e];t.behaviors[n]||(o[n].delete(),delete o[n])}};const Gx={},Ux=/instance:\\${([^}]+)}/,zx={},Wx=[],Hx={},jx={vtkPoints:Yl,vtkCellArray:Kl,vtkDataArray:xs};function Kx(e){return e.map((e=>Ux.exec(e))).filter((e=>e)).map((e=>e[1]))}function $x(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return e.dependencies&&e.dependencies.forEach((e=>{t.push(e.id),$x(e,t)})),t}function qx(e,t,n,r){if(!t)return Promise.reject(new Error(&quot;No instance provided.&quot;));const o=Gx[e];return o&&o.update?o.update(t,n,r):Promise.reject(new Error(`No updater for ${e}`))}function Xx(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};const n=Gx[e];return n&&n.build?n.build(t):(console.log(&quot;No builder for&quot;,e),null)}function Yx(){Object.keys(Gx).forEach((e=>{delete Gx[e]}))}function Zx(e){if(1===e[1].length)return-1===Wx.indexOf(e[1][0]);let t=!1;for(let n=0;n<e[1].length;n++)t=t||-1===Wx.indexOf(e[1][n]);return t}function Qx(e,t,n){n.start(),e.set(t.properties),t.dependencies&&t.dependencies.forEach((e=>{const{id:t,type:r}=e;if(Hx[r]){const{key:n,value:o}=Hx[r];if(!n||e.properties[n]===o)return void Wx.push((e=>`instance:\\${${e}}`)(t))}let o=n.getInstance(t);o||(o=Xx(r,{managedInstanceId:t}),n.registerInstance(t,o)),qx(r,o,e,n)})),t.calls&&t.calls.filter(Zx).forEach((t=>{var r;e[t[0]].apply(null,(r=n,t[1].map((e=>{const t=Ux.exec(e);return t?r.getInstance(t[1]):e}))))}));const r=[];if(t.arrays){const o=[],a=Object.values(t.arrays).map((t=>(n.start(),n.getArray(t.hash,t.dataType,n).then(function(e,t,n){return r=>{const o=t.registration?t.registration:&quot;addArray&quot;,a=t.location?e.getReferenceByName(t.location):e;let i=null;if(i=t.location?e.getReferenceByName(t.location).getArray(t.name):e[`get${o.substring(3)}`](),i)return i.getData()!==r&&n.push([i.setData,[r,t.numberOfComponents]]),i;const s=t.vtkClass?t.vtkClass:&quot;vtkDataArray&quot;,l=jx[s].newInstance({...t,values:r});return n.push([a[o],[l]]),l}}(e,t,o)).catch((e=>{console.log(&quot;Error fetching array&quot;,JSON.stringify(t),e)})).finally(n.end))));n.start(),r.push(Promise.all(a).then((()=>(o.length&&e.modified(),function(e){for(;e.length;){const[t,n]=e.shift();t(...n)}}(o),!0))).catch((e=>{console.error(&quot;Error in array handling for state&quot;,JSON.stringify(t),e)})).finally(n.end))}return n.end(),Promise.all(r)}function Jx(e,t,n){zx[t.id]||Qx(e,t,n),zx[t.id]=!0}function eC(e,t){const n=[],r=e.getNumberOfArrays();for(let o=0;o<r;o++){const r=e.getArray(o).getName();t.has(r)||n.push(r)}for(let t=0;t<n.length;t++)e.removeArray(n[t])}function tC(e){const t=e.name?`_${e.name}`:&quot;&quot;;return`${e.hash}_${e.dataType}${t}`}function nC(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[];return(t,n,r)=>{r.start();const o={...n.properties};n.arrays||(n.arrays={});for(let t=0;t<e.length;t++){const r=e[t];if(n.properties[r]){const e=n.properties[r];e.registration=`set${st(r)}`;const t=tC(e);n.arrays[t]=e,delete o[r]}}const a=n.properties.fields||[];for(let e=0;e<a.length;e++){const t=a[e],r=tC(t);n.arrays[r]=t}delete o.fields;const i={pointData:new Set,cellData:new Set,fieldData:new Set};a.forEach((e=>{let{location:t,name:n}=e;i[t].add(n)})),eC(t.getPointData(),i.pointData),eC(t.getCellData(),i.cellData);const s={...n};s.properties=o;const l=Qx(t,s,r);return r.end(),l}}const rC=nC([&quot;points&quot;,&quot;polys&quot;,&quot;verts&quot;,&quot;lines&quot;,&quot;strips&quot;]),oC=nC([]);function aC(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:Qx;Xx||qx?Gx[e]={build:t,update:n}:delete Gx[e]}const iC={vtkMapper:[&quot;vtkOpenGLPolyDataMapper&quot;,&quot;vtkCompositePolyDataMapper2&quot;,&quot;vtkDataSetMapper&quot;],vtkProperty:[&quot;vtkOpenGLProperty&quot;],vtkRenderer:[&quot;vtkOpenGLRenderer&quot;],vtkCamera:[&quot;vtkOpenGLCamera&quot;],vtkColorTransferFunction:[&quot;vtkPVDiscretizableColorTransferFunction&quot;],vtkActor:[&quot;vtkOpenGLActor&quot;,&quot;vtkPVLODActor&quot;],vtkLight:[&quot;vtkOpenGLLight&quot;,&quot;vtkPVLight&quot;],vtkTexture:[&quot;vtkOpenGLTexture&quot;],vtkImageMapper:[&quot;vtkOpenGLImageSliceMapper&quot;],vtkVolumeMapper:[&quot;vtkFixedPointVolumeRayCastMapper&quot;]},sC={vtkAxesActor:{build:Mx.newInstance,update:Qx},vtkRenderWindow:{build:hh.newInstance,update:function(e,t,n){t.calls&&t.calls.filter(Zx).filter((e=>&quot;removeRenderer&quot;===e[0])).forEach((e=>{Kx(e[1]).forEach((e=>{n.getInstance(e).getViewProps().forEach((e=>{const t=e.get(&quot;flattenedDepIds&quot;).flattenedDepIds;t&&t.forEach((e=>n.unregisterInstance(e))),n.unregisterInstance(n.getInstanceId(e))}))}))})),e.render(),Qx(e,t,n),kx(e,t,n)}},vtkRenderer:{build:uh.newInstance,update:function(e,t,n){Qx(e,t,n);const r=new Set;t.dependencies&&t.dependencies.forEach((e=>{const t=n.getInstance(e.id);if(t){const n=$x(e);t.set({flattenedDepIds:n},!0),n.forEach((e=>r.add(e)))}}));const o=new Set;t.calls&&t.calls.filter(Zx).filter((e=>&quot;removeViewProp&quot;===e[0])).forEach((e=>{Kx(e[1]).forEach((e=>{const t=n.getInstance(e).get(&quot;flattenedDepIds&quot;).flattenedDepIds;t&&t.forEach((e=>o.add(e))),o.add(e)}))})),[...o].filter((e=>!r.has(e))).forEach((e=>n.unregisterInstance(e)))}},vtkLookupTable:{build:fl.newInstance,update:Qx},vtkCamera:{build:Ym.newInstance,update:Jx},vtkPolyData:{build:gu.newInstance,update:rC},vtkImageData:{build:Xs.newInstance,update:oC},vtkMapper:{build:Gl.newInstance,update:Qx},vtkGlyph3DMapper:{build:Mb.newInstance,update:Qx},vtkProperty:{build:os.newInstance,update:Qx},vtkActor:{build:ss.newInstance,update:Qx},vtkLight:{build:Jm.newInstance,update:Qx},vtkColorTransferFunction:{build:Sb.newInstance,update:function(e,t,n){if(n.start(),t.properties.nodes){const n=t.properties.nodes.map((e=>{let[t,n,r,o,a,i]=e;return{x:t,r:n,g:r,b:o,midpoint:a,sharpness:i}}));e.set({...t.properties,nodes:n},!0)}else e.set(t.properties);n.end()}},vtkTexture:{build:vu.newInstance,update:Qx},vtkVolume:{build:Hb.newInstance,update:Qx},vtkVolumeMapper:{build:Xb.newInstance,update:Qx},vtkVolumeProperty:{build:Ub.newInstance,update:Qx},vtkImageSlice:{build:nx.newInstance,update:Qx},vtkImageMapper:{build:dx.newInstance,update:Qx},vtkImageProperty:{build:Jb.newInstance,update:Qx},vtkPiecewiseFunction:{build:Lb.newInstance,update:function(e,t,n){if(n.start(),t.properties.nodes){const n=t.properties.nodes.map((e=>{let[t,n,r,o]=e;return{x:t,y:n,midpoint:r,sharpness:o}}));e.set({...t.properties,nodes:n},!0),e.sortAndUpdateRange()}else e.set(t.properties);n.end()}},vtkCubeAxesActor:{build:Lu.newInstance,update:Qx},vtkScalarBarActor:{build:dp.newInstance,update:Qx}};function lC(){(!(arguments.length>0&&void 0!==arguments[0])||arguments[0])&&Yx(),Object.keys(sC).forEach((e=>{const t=sC[e];aC(e,t.build,t.update)}))}function cC(){Object.keys(iC).forEach((e=>{iC[e].forEach((t=>{Gx[t]=Gx[e]}))}))}lC(),cC(),Hx.vtkPVLight={};var uC={build:Xx,update:qx,genericUpdater:Qx,oneTimeGenericUpdater:Jx,setTypeMapping:aC,clearTypeMapping:Yx,getSupportedTypes:function(){return Object.keys(Gx)},clearOneTimeUpdaters:function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];if(0===t.length)return void Object.keys(zx).forEach((e=>{delete zx[e]}));let r=t;return 1===r.length&&Array.isArray(r[0])&&(r=r[0]),r.forEach((e=>{delete zx[e]})),r},updateRenderWindow:function(e,t,n){return qx(&quot;vtkRenderWindow&quot;,e,t,n)},excludeInstance:function(e,t,n){Hx[e]={key:t,value:n}},setDefaultMapping:lC,applyDefaultAliases:cC,alwaysUpdateCamera:function(){aC(&quot;vtkCamera&quot;,Ym.newInstance),cC()}};const dC={};function pC(){const e={};let t=null;return{setFetchArrayFunction:function(e){t=e},getArray:function(n,r,o){const a=e[n];return a?(a.mtimes[o.getActiveViewId()]=o.getMTime(),new Promise(((e,t)=>{e(a.array)}))):t?new Promise(((a,i)=>{t(n).then((t=>{let i=t;if(&quot;string&quot;==typeof t&&(i=$g.toArrayBuffer(t)),i instanceof Blob){const t=new FileReader;t.onload=()=>{const i=at(r,t.result),s={[o.getActiveViewId()]:o.getMTime()};e[n]={mtimes:s,array:i},a(i)},t.readAsArrayBuffer(i)}else{const t=at(r,i),s={[o.getActiveViewId()]:o.getMTime()};e[n]={mtimes:s,array:t},a(t)}}),(e=>{console.log(&quot;Error getting data array:&quot;),console.log(e),i(e)}))})):Promise.reject(new Error('No array fetcher found, please use &quot;setArrayFetcher&quot; to provide one'))},emptyCachedArrays:function(){Object.keys(e).forEach((t=>{delete e[t]}))},freeOldArrays:function(t,n){const r=n.getMTime()-t;Object.keys(e).filter((t=>e[t].mtimes[n.getActiveViewId()])).filter((t=>e[t].mtimes[n.getActiveViewId()]<r)).forEach((t=>{delete e[t]}))}}}function fC(){const e={};return{getInstance:function(t){return e[t]},getInstanceId:function(t){let n=null;return Object.keys(e).forEach((r=>{t===e[r]&&(n=r)})),n},registerInstance:function(t,n){e[t]=n,n.set({remoteId:t},!0,!0)},unregisterInstance:function(t){delete e[t]},emptyCachedInstances:function(){Object.keys(e).forEach((t=>{delete e[t]}))}}}function gC(){let e=0;const t={start(){e+=1,t.invokeProgressEvent(e)},end(){e-=1,t.invokeProgressEvent(e),0===e&&t.invokeProgressDone()},resetProgress(){e=0}},n={};return Rt(t,n,&quot;progressEvent&quot;),Rt(t,n,&quot;progressDone&quot;),t}function mC(){const e={};let t=&quot;default&quot;;return{getMTime:function(n){return e[n||t]||1},incrementMTime:function(n){const r=n||t;e[r]||(e[r]=1),e[r]+=1},setActiveViewId:function(e){t=e},getActiveViewId:function(){return t}}}function hC(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;default&quot;,t=dC[e];return t||(t={...pC(),...fC(),...gC(),...mC()},dC[e]=t),t}function vC(e,t){let n=-1,r=100;const o=e=>e.get(&quot;managedInstanceId&quot;).managedInstanceId,a=()=>Dt(e,o);function i(t){e.set({synchronizedViewId:t},!0,!0)}function s(){return e.get(&quot;synchronizedViewId&quot;).synchronizedViewId}return{synchronize:function(o){s()||i(o.id);const a=o.mtime||0;return s()===o.id&&n<a?new Promise(((i,s)=>{const l=t.onProgressDone((()=>{l.unsubscribe(),e.render(),i(!0)}));n=a,t.setActiveViewId(o.id),t.incrementMTime(),uC.updateRenderWindow(e,o,t),t.freeOldArrays(r,t)})):Promise.resolve(!1)},setSynchronizedViewId:i,getSynchronizedViewId:s,updateGarbageCollectorThreshold:function(e){r=e},getManagedInstanceIds:a,clearOneTimeUpdaters:function(){uC.clearOneTimeUpdaters(a())}}}const TC={synchronizerContextName:&quot;default&quot;,synchronizerContext:null,synchronizedViewId:null};function yC(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,TC,n),hh.extend(e,t),Tt(e,t,[&quot;synchronizerContext&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkSynchronizableRenderWindow&quot;),t.synchronizerContext||(t.synchronizerContext=hC(t.synchronizerContextName));const n=vC(e,t.synchronizerContext);Object.keys(n).forEach((t=>{e[t]?e[t]=Et(e[t],n[t]):e[t]=n[t]}))}(e,t)}var bC={newInstance:Mt(yC,&quot;vtkSynchronizableRenderWindow&quot;),extend:yC,getSynchronizerContext:hC,setSynchronizerContext:function(e,t){dC[e]=t},clearSynchronizerContext:function(e){if(e&&dC[e]&&delete dC[e],!e){const e=Object.keys(dC);for(let t=0;t<e.length;t++)delete dC[e[t]]}},decorate:function(e){const t=vC(e,hC(arguments.length>1&&void 0!==arguments[1]?arguments[1]:&quot;default&quot;));return{...t,...e,delete:Et(e.delete,t.delete)}},createInstanceMap:fC,createArrayHandler:pC,createProgressHandler:gC,createSceneMtimeHandler:mC,vtkObjectManager:uC};const{vtkErrorMacro:xC,vtkDebugMacro:CC}=Wt;let SC=0;function AC(e){const t=document.querySelector(`.webResource[data-url=&quot;${e}&quot;]`);return t?t.innerHTML:null}function IC(e){return&quot;/&quot;===e[0]?e.substr(1):e}const wC={fetchJSON:function(e,t){return new Promise(((e,n)=>{const r=AC(IC(t));null===r?n(new Error(`No such JSON ${t}`)):e(JSON.parse(r))}))},fetchText:function(e,t){return new Promise(((e,n)=>{const r=AC(t);null===r?n(new Error(`No such text ${t}`)):e(r)}))},fetchArray:function(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return new Promise(((o,a)=>{const i=IC([t,n.ref.basepath,r.compression?`${n.ref.id}.gz`:n.ref.id].join(&quot;/&quot;)),s=AC(i);if(null===s)a(new Error(`No such array ${i}`));else{if(&quot;string&quot;===n.dataType){let e=atob(s);r.compression&&(e=Lm(Em(e))),n.values=JSON.parse(e)}else{const e=new Uint8Array($g.toArrayBuffer(s));n.buffer=new ArrayBuffer(e.length),new Uint8Array(n.buffer).set(e),r.compression&&(&quot;string&quot;===n.dataType||&quot;JSON&quot;===n.dataType?n.buffer=Lm(Em(new Uint8Array(n.buffer))):n.buffer=Em(new Uint8Array(n.buffer)).buffer),&quot;JSON&quot;===n.ref.encode?n.values=JSON.parse(n.buffer):(Gm!==n.ref.encode&&Gm&&(CC(`Swap bytes of ${n.name}`),Um(n.buffer,ls[n.dataType])),n.values=Wt.newTypedArray(n.dataType,n.buffer)),n.values.length!==n.size&&xC(`Error in FetchArray: ${n.name} does not have the proper array size. Got ${n.values.length}, instead of ${n.size}`)}delete n.ref,0==--SC&&e?.invokeBusy&&e.invokeBusy(!1),e?.modified&&e.modified(),o(n)}}))},fetchImage:function(e,t){return new Promise(((e,n)=>{const r=function(e){return document.querySelector(`.webResource[data-url=&quot;${e}&quot;]`)}(t);r?e(r):n(new Error(`No such image ${t}`))}))}};Xg(&quot;html&quot;,(e=>wC));const{vtkErrorMacro:OC,vtkDebugMacro:PC}=Wt;function RC(e){return function(e){return&quot;/&quot;===e[0]?e.substr(1):e}(function(e){return new URL(e,&quot;http://any&quot;).pathname}(e))}const MC=function(e){let t=!1,n=0,r=null,o=&quot;&quot;;var a;return(a=e.zipContent,new Promise(((e,t)=>{&quot;string&quot;==typeof a?e(function(e,t){if(t){for(var n=new Zg(e.length),r=0;r<e.length;++r)n[r]=e.charCodeAt(r);return n}if(Vm)return Vm.encode(e);var o=e.length,a=new Zg(e.length+(e.length>>1)),i=0,s=function(e){a[i++]=e};for(r=0;r<o;++r){if(i+5>a.length){var l=new Zg(i+8+(o-r<<1));l.set(a),a=l}var c=e.charCodeAt(r);c<128||t?s(c):c<2048?(s(192|c>>6),s(128|63&c)):c>55295&&c<57344?(s(240|(c=65536+(1047552&c)|1023&e.charCodeAt(++r))>>18),s(128|c>>12&63),s(128|c>>6&63),s(128|63&c)):(s(224|c>>12),s(128|c>>6&63),s(128|63&c))}return bm(a,0,i)}(a)):a instanceof Blob?e(a.arrayBuffer().then((e=>new Uint8Array(e)))):a instanceof ArrayBuffer?e(new Uint8Array(a)):a?.buffer instanceof ArrayBuffer?e(new Uint8Array(a.buffer)):t(new Error(&quot;Invalid datatype to unpack.&quot;))}))).then((n=>{r=_m(n),t=!0;const a=[];Object.keys(r).forEach((e=>{e.endsWith(&quot;index.json&quot;)&&a.push(e)})),a.sort(((e,t)=>e.length-t.length)),o=a[0].replace(/index\\.json$/,&quot;&quot;),e.callback&&e.callback(r)})),{fetchArray(e,a,i){let s=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return new Promise(((l,c)=>{t||OC(&quot;ERROR!!! zip not ready...&quot;);const u=RC([a,i.ref.basepath,s.compression?`${i.ref.id}.gz`:i.ref.id].join(&quot;/&quot;));function d(){delete i.ref,0==--n&&e?.invokeBusy&&e.invokeBusy(!1),e?.modified&&e.modified(),l(i)}1==++n&&e?.invokeBusy&&e.invokeBusy(!0);const p=r[`${o}${u}`];if(&quot;string&quot;!==i.dataType||s.compression){const e=function(e,t,n){return r=>{e.buffer=new ArrayBuffer(r.length),new Uint8Array(e.buffer).set(r),t&&(&quot;string&quot;===e.dataType||&quot;JSON&quot;===e.dataType?e.buffer=Lm(Em(new Uint8Array(e.buffer))):e.buffer=Em(new Uint8Array(e.buffer)).buffer),&quot;JSON&quot;===e.ref.encode?e.values=JSON.parse(e.buffer):(Gm!==e.ref.encode&&Gm&&(PC(`Swap bytes of ${e.name}`),Um(e.buffer,ls[e.dataType])),e.values=Wt.newTypedArray(e.dataType,e.buffer)),e.values.length!==e.size&&OC(`Error in FetchArray: ${e.name} does not have the proper array size. Got ${e.values.length}, instead of ${e.size}`),n()}}(i,s.compression,d);e(p)}else{const e=function(e,t,n){return r=>{e.values=t?JSON.parse(Lm(Em(r))):JSON.parse(r),n()}}(i,s.compression,d);e(Lm(p))}}))},fetchJSON(e,n){let a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};const i=RC(n);t||OC(&quot;ERROR!!! zip not ready...&quot;);const s=r[`${o}${i}`];if(a.compression){if(&quot;gz&quot;===a.compression){const e=Lm(Em(s));return Promise.resolve(JSON.parse(e))}return Promise.reject(new Error(&quot;Invalid compression&quot;))}return Promise.resolve(JSON.parse(Lm(s)))},fetchText(e,n){let a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};const i=RC(n);t||OC(&quot;ERROR!!! zip not ready...&quot;);const s=r[`${o}${i}`];return a.compression?&quot;gz&quot;===a.compression?Promise.resolve(Lm(_m(s))):Promise.reject(new Error(&quot;Invalid compression&quot;)):Promise.resolve(Lm(s))},fetchImage(e,n){const a=RC(n);t||OC(&quot;ERROR!!! zip not ready...&quot;);const i=r[`${o}${a}`];return new Promise(((e,t)=>{const n=new Image;n.onload=()=>e(n),n.onerror=t;const r=Kg(i.buffer);n.src=`data:image/${function(e){const t=e.split(&quot;.&quot;).pop().toLowerCase();return&quot;jpg&quot;===t?&quot;jpeg&quot;:t}(a)};base64,${r}`}))},fetchBinary(e,n){let a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};const i=RC(n);t||OC(&quot;ERROR!!! zip not ready...&quot;);const s=r[`${o}${i}`];return a.compression?&quot;gz&quot;===a.compression?Promise.resolve(Em(s).buffer):Promise.reject(new Error(&quot;Invalid compression&quot;)):Promise.resolve(s.buffer)}}};Xg(&quot;zip&quot;,(e=>MC(e)));var EC=n(911),VC=n.n(EC),DC=n(893),LC=n.n(DC),BC=n(383),NC=n.n(BC),FC=n(884),_C=n.n(FC),kC=n(88),GC=n.n(kC),UC=n(997),zC=n.n(UC),WC=n(96),HC={};HC.styleTagTransform=zC(),HC.setAttributes=_C(),HC.insert=NC().bind(null,&quot;head&quot;),HC.domAPI=LC(),HC.insertStyleElement=GC(),VC()(WC.A,HC);var jC=WC.A&&WC.A.locals?WC.A.locals:void 0;let KC=!0;function $C(e){e.preventDefault(),e.stopPropagation()}function qC(e,t){KC=!1,function(e){for(;e.firstChild;)e.removeChild(e.firstChild)}(e);const r=ub.newInstance({background:[1,1,1],rootContainer:e,containerStyle:{height:&quot;100%&quot;,width:&quot;100%&quot;,position:&quot;absolute&quot;}}).getRenderWindow(),o=bC.getSynchronizerContext(),a=bC.decorate(r);function i(e){o.setFetchArrayFunction((t=>Promise.resolve(e.hashes[t].content))),console.log(Object.keys(e)),a.synchronize(e.scene),a.render()}if(n.g.renderWindow=r,t.fileURL||t.url){const n=document.createElement(&quot;div&quot;);n.setAttribute(&quot;class&quot;,jC.progress),e.appendChild(n);const r=e=>{if(e.lengthComputable){const t=Math.floor(100*e.loaded/e.total);n.innerHTML=`Loading ${t}%`}else n.innerHTML=Wt.formatBytesToProperUnit(e.loaded)};t.fileURL?Km.fetchBinary(t.fileURL,{progressCallback:r}).then((t=>{e.removeChild(n);const r=Yg.get(&quot;zip&quot;,{zipContent:t,callback:e=>{r.fetchJSON(null,&quot;index.json&quot;).then(i)}})})):Km.fetchJSON(t.url,{progressCallback:r}).then((t=>{e.removeChild(n),i(t)}))}else if(t.file){const e=Yg.get(&quot;zip&quot;,{zipContent:t.file,callback:t=>{e.fetchJSON(null,&quot;index.json&quot;).then(i)}})}else if(t.base64Str){const e=$g.toArrayBuffer(t.base64Str),n=Yg.get(&quot;zip&quot;,{zipContent:e,callback:e=>{n.fetchJSON(null,&quot;index.json&quot;).then(i)}})}}function XC(e){KC=!1;const t=document.querySelector(&quot;.content&quot;),n=document.querySelector(&quot;body&quot;),r=e||t||n;r!==e?(r.classList.add(jC.fullScreen),n.style.margin=&quot;0&quot;,n.style.padding=&quot;0&quot;):(n.style.margin=&quot;0&quot;,n.style.padding=&quot;0&quot;);const o=document.createElement(&quot;div&quot;);o.innerHTML=`<div class=&quot;${jC.bigFileDrop}&quot;/><input type=&quot;file&quot; accept=&quot;.zip,.vtksz&quot; style=&quot;display: none;&quot;/>`,r.appendChild(o);const a=o.querySelector(&quot;input&quot;);function i(e){$C(e);const t=e.dataTransfer,n=e.target.files||t.files;if(1===n.length){r.removeChild(o);const e=n[0].name.split(&quot;.&quot;).slice(-1)[0];qC(r,{file:n[0],ext:e})}}a.addEventListener(&quot;change&quot;,i),o.addEventListener(&quot;drop&quot;,i),o.addEventListener(&quot;click&quot;,(e=>a.click())),o.addEventListener(&quot;dragover&quot;,$C)}const YC=Zh();if(YC.url||YC.fileURL){const e=document.querySelector(&quot;.content&quot;),t=document.querySelector(&quot;body&quot;),n=e||t;n&&(n.classList.add(jC.fullScreen),t.style.margin=&quot;0&quot;,t.style.padding=&quot;0&quot;),KC=!1,function(e){if(!window.frameElement)return e(),!0;window.frameElement.getClientRects().length>0?e():function(e,t){new window.parent.IntersectionObserver(((e,n)=>{e.forEach((e=>{e.intersectionRatio>0&&(t(),n.disconnect())}))})).observe(e)}(window.frameElement,e)}((()=>qC(n,YC)))}setTimeout((()=>{KC&&XC()}),100),window.OfflineLocalView={initLocalFileLoader:XC,load:qC}},613:function(e){&quot;use strict&quot;;e.exports=function(e){var t=[];return t.toString=function(){return this.map((function(t){var n=&quot;&quot;,r=void 0!==t[5];return t[4]&&(n+=&quot;@supports (&quot;.concat(t[4],&quot;) {&quot;)),t[2]&&(n+=&quot;@media &quot;.concat(t[2],&quot; {&quot;)),r&&(n+=&quot;@layer&quot;.concat(t[5].length>0?&quot; &quot;.concat(t[5]):&quot;&quot;,&quot; {&quot;)),n+=e(t),r&&(n+=&quot;}&quot;),t[2]&&(n+=&quot;}&quot;),t[4]&&(n+=&quot;}&quot;),n})).join(&quot;&quot;)},t.i=function(e,n,r,o,a){&quot;string&quot;==typeof e&&(e=[[null,e,void 0]]);var i={};if(r)for(var s=0;s<this.length;s++){var l=this[s][0];null!=l&&(i[l]=!0)}for(var c=0;c<e.length;c++){var u=[].concat(e[c]);r&&i[u[0]]||(void 0!==a&&(void 0===u[5]||(u[1]=&quot;@layer&quot;.concat(u[5].length>0?&quot; &quot;.concat(u[5]):&quot;&quot;,&quot; {&quot;).concat(u[1],&quot;}&quot;)),u[5]=a),n&&(u[2]?(u[1]=&quot;@media &quot;.concat(u[2],&quot; {&quot;).concat(u[1],&quot;}&quot;),u[2]=n):u[2]=n),o&&(u[4]?(u[1]=&quot;@supports (&quot;.concat(u[4],&quot;) {&quot;).concat(u[1],&quot;}&quot;),u[4]=o):u[4]=&quot;&quot;.concat(o)),t.push(u))}},t}},336:function(e){&quot;use strict&quot;;e.exports=function(e,t){return t||(t={}),e?(e=String(e.__esModule?e.default:e),/^['&quot;].*['&quot;]$/.test(e)&&(e=e.slice(1,-1)),t.hash&&(e+=t.hash),/[&quot;'() \\t\\n]|(%20)/.test(e)||t.needQuotes?'&quot;'.concat(e.replace(/&quot;/g,'\\\\&quot;').replace(/\\n/g,&quot;\\\\n&quot;),'&quot;'):e):e}},20:function(e){&quot;use strict&quot;;e.exports=function(e){return e[1]}},555:function(e,t,n){&quot;use strict&quot;;var r=n(382),o=&quot;function&quot;==typeof Symbol&&&quot;symbol&quot;==typeof Symbol(&quot;foo&quot;),a=Object.prototype.toString,i=Array.prototype.concat,s=Object.defineProperty,l=s&&function(){var e={};try{for(var t in s(e,&quot;x&quot;,{enumerable:!1,value:e}),e)return!1;return e.x===e}catch(e){return!1}}(),c=function(e,t,n,r){var o;(!(t in e)||&quot;function&quot;==typeof(o=r)&&&quot;[object Function]&quot;===a.call(o)&&r())&&(l?s(e,t,{configurable:!0,enumerable:!1,value:n,writable:!0}):e[t]=n)},u=function(e,t){var n=arguments.length>2?arguments[2]:{},a=r(t);o&&(a=i.call(a,Object.getOwnPropertySymbols(t)));for(var s=0;s<a.length;s+=1)c(e,a[s],t[a[s]],n[a[s]])};u.supportsDescriptors=!!l,e.exports=u},77:function(e,t,n){&quot;use strict&quot;;e.exports=function(){if(&quot;object&quot;==typeof globalThis)return globalThis;var e;try{e=this||new Function(&quot;return this&quot;)()}catch(e){if(&quot;object&quot;==typeof window)return window;if(&quot;object&quot;==typeof self)return self;if(void 0!==n.g)return n.g}return e}()},730:function(e){&quot;use strict&quot;;e.exports=function e(t,n){if(t===n)return!0;if(t&&n&&&quot;object&quot;==typeof t&&&quot;object&quot;==typeof n){if(t.constructor!==n.constructor)return!1;var r,o,a;if(Array.isArray(t)){if((r=t.length)!=n.length)return!1;for(o=r;0!=o--;)if(!e(t[o],n[o]))return!1;return!0}if(t.constructor===RegExp)return t.source===n.source&&t.flags===n.flags;if(t.valueOf!==Object.prototype.valueOf)return t.valueOf()===n.valueOf();if(t.toString!==Object.prototype.toString)return t.toString()===n.toString();if((r=(a=Object.keys(t)).length)!==Object.keys(n).length)return!1;for(o=r;0!=o--;)if(!Object.prototype.hasOwnProperty.call(n,a[o]))return!1;for(o=r;0!=o--;){var i=a[o];if(!e(t[i],n[i]))return!1}return!0}return t!=t&&n!=n}},979:function(e){&quot;use strict&quot;;&quot;undefined&quot;!=typeof self?e.exports=self:&quot;undefined&quot;!=typeof window?e.exports=window:e.exports=Function(&quot;return this&quot;)()},59:function(e,t,n){&quot;use strict&quot;;var r=n(555),o=n(979),a=n(920),i=n(482),s=a(),l=function(){return s};r(l,{getPolyfill:a,implementation:o,shim:i}),e.exports=l},920:function(e,t,n){&quot;use strict&quot;;var r=n(979);e.exports=function(){return&quot;object&quot;==typeof n.g&&n.g&&n.g.Math===Math&&n.g.Array===Array?n.g:r}},482:function(e,t,n){&quot;use strict&quot;;var r=n(555),o=n(920);e.exports=function(){var e=o();if(r.supportsDescriptors){var t=Object.getOwnPropertyDescriptor(e,&quot;globalThis&quot;);t&&(!t.configurable||!t.enumerable&&t.writable&&globalThis===e)||Object.defineProperty(e,&quot;globalThis&quot;,{configurable:!0,enumerable:!1,value:e,writable:!0})}else&quot;object&quot;==typeof globalThis&&globalThis===e||(e.globalThis=e);return e}},982:function(e,t,n){&quot;use strict&quot;;var r;if(!Object.keys){var o=Object.prototype.hasOwnProperty,a=Object.prototype.toString,i=n(642),s=Object.prototype.propertyIsEnumerable,l=!s.call({toString:null},&quot;toString&quot;),c=s.call((function(){}),&quot;prototype&quot;),u=[&quot;toString&quot;,&quot;toLocaleString&quot;,&quot;valueOf&quot;,&quot;hasOwnProperty&quot;,&quot;isPrototypeOf&quot;,&quot;propertyIsEnumerable&quot;,&quot;constructor&quot;],d=function(e){var t=e.constructor;return t&&t.prototype===e},p={$applicationCache:!0,$console:!0,$external:!0,$frame:!0,$frameElement:!0,$frames:!0,$innerHeight:!0,$innerWidth:!0,$onmozfullscreenchange:!0,$onmozfullscreenerror:!0,$outerHeight:!0,$outerWidth:!0,$pageXOffset:!0,$pageYOffset:!0,$parent:!0,$scrollLeft:!0,$scrollTop:!0,$scrollX:!0,$scrollY:!0,$self:!0,$webkitIndexedDB:!0,$webkitStorageInfo:!0,$window:!0},f=function(){if(&quot;undefined&quot;==typeof window)return!1;for(var e in window)try{if(!p[&quot;$&quot;+e]&&o.call(window,e)&&null!==window[e]&&&quot;object&quot;==typeof window[e])try{d(window[e])}catch(e){return!0}}catch(e){return!0}return!1}();r=function(e){var t=null!==e&&&quot;object&quot;==typeof e,n=&quot;[object Function]&quot;===a.call(e),r=i(e),s=t&&&quot;[object String]&quot;===a.call(e),p=[];if(!t&&!n&&!r)throw new TypeError(&quot;Object.keys called on a non-object&quot;);var g=c&&n;if(s&&e.length>0&&!o.call(e,0))for(var m=0;m<e.length;++m)p.push(String(m));if(r&&e.length>0)for(var h=0;h<e.length;++h)p.push(String(h));else for(var v in e)g&&&quot;prototype&quot;===v||!o.call(e,v)||p.push(String(v));if(l)for(var T=function(e){if(&quot;undefined&quot;==typeof window||!f)return d(e);try{return d(e)}catch(e){return!1}}(e),y=0;y<u.length;++y)T&&&quot;constructor&quot;===u[y]||!o.call(e,u[y])||p.push(u[y]);return p}}e.exports=r},382:function(e,t,n){&quot;use strict&quot;;var r=Array.prototype.slice,o=n(642),a=Object.keys,i=a?function(e){return a(e)}:n(982),s=Object.keys;i.shim=function(){if(Object.keys){var e=function(){var e=Object.keys(arguments);return e&&e.length===arguments.length}(1,2);e||(Object.keys=function(e){return o(e)?s(r.call(e)):s(e)})}else Object.keys=i;return Object.keys||i},e.exports=i},642:function(e){&quot;use strict&quot;;var t=Object.prototype.toString;e.exports=function(e){var n=t.call(e),r=&quot;[object Arguments]&quot;===n;return r||(r=&quot;[object Array]&quot;!==n&&null!==e&&&quot;object&quot;==typeof e&&&quot;number&quot;==typeof e.length&&e.length>=0&&&quot;[object Function]&quot;===t.call(e.callee)),r}},318:function(e,t,n){var r=n(767),o=n(698),a=n(744),i=n(402),s=n(576),l=n(886),c=n(262);c.alea=r,c.xor128=o,c.xorwow=a,c.xorshift7=i,c.xor4096=s,c.tychei=l,e.exports=c},767:function(e,t,n){var r;!function(e,o){function a(e){var t,n=this,r=(t=4022871197,function(e){e=String(e);for(var n=0;n<e.length;n++){var r=.02519603282416938*(t+=e.charCodeAt(n));r-=t=r>>>0,t=(r*=t)>>>0,t+=4294967296*(r-=t)}return 2.3283064365386963e-10*(t>>>0)});n.next=function(){var e=2091639*n.s0+2.3283064365386963e-10*n.c;return n.s0=n.s1,n.s1=n.s2,n.s2=e-(n.c=0|e)},n.c=1,n.s0=r(&quot; &quot;),n.s1=r(&quot; &quot;),n.s2=r(&quot; &quot;),n.s0-=r(e),n.s0<0&&(n.s0+=1),n.s1-=r(e),n.s1<0&&(n.s1+=1),n.s2-=r(e),n.s2<0&&(n.s2+=1),r=null}function i(e,t){return t.c=e.c,t.s0=e.s0,t.s1=e.s1,t.s2=e.s2,t}function s(e,t){var n=new a(e),r=t&&t.state,o=n.next;return o.int32=function(){return 4294967296*n.next()|0},o.double=function(){return o()+11102230246251565e-32*(2097152*o()|0)},o.quick=o,r&&(&quot;object&quot;==typeof r&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.alea=s}(0,e=n.nmd(e),n.amdD)},886:function(e,t,n){var r;!function(e,o){function a(e){var t=this,n=&quot;&quot;;t.next=function(){var e=t.b,n=t.c,r=t.d,o=t.a;return e=e<<25^e>>>7^n,n=n-r|0,r=r<<24^r>>>8^o,o=o-e|0,t.b=e=e<<20^e>>>12^n,t.c=n=n-r|0,t.d=r<<16^n>>>16^o,t.a=o-e|0},t.a=0,t.b=0,t.c=-1640531527,t.d=1367130551,e===Math.floor(e)?(t.a=e/4294967296|0,t.b=0|e):n+=e;for(var r=0;r<n.length+20;r++)t.b^=0|n.charCodeAt(r),t.next()}function i(e,t){return t.a=e.a,t.b=e.b,t.c=e.c,t.d=e.d,t}function s(e,t){var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(&quot;object&quot;==typeof r&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.tychei=s}(0,e=n.nmd(e),n.amdD)},698:function(e,t,n){var r;!function(e,o){function a(e){var t=this,n=&quot;&quot;;t.x=0,t.y=0,t.z=0,t.w=0,t.next=function(){var e=t.x^t.x<<11;return t.x=t.y,t.y=t.z,t.z=t.w,t.w^=t.w>>>19^e^e>>>8},e===(0|e)?t.x=e:n+=e;for(var r=0;r<n.length+64;r++)t.x^=0|n.charCodeAt(r),t.next()}function i(e,t){return t.x=e.x,t.y=e.y,t.z=e.z,t.w=e.w,t}function s(e,t){var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(&quot;object&quot;==typeof r&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.xor128=s}(0,e=n.nmd(e),n.amdD)},576:function(e,t,n){var r;!function(e,o){function a(e){var t=this;t.next=function(){var e,n,r=t.w,o=t.X,a=t.i;return t.w=r=r+1640531527|0,n=o[a+34&127],e=o[a=a+1&127],n^=n<<13,e^=e<<17,n^=n>>>15,e^=e>>>12,n=o[a]=n^e,t.i=a,n+(r^r>>>16)|0},function(e,t){var n,r,o,a,i,s=[],l=128;for(t===(0|t)?(r=t,t=null):(t+=&quot;\\0&quot;,r=0,l=Math.max(l,t.length)),o=0,a=-32;a<l;++a)t&&(r^=t.charCodeAt((a+32)%t.length)),0===a&&(i=r),r^=r<<10,r^=r>>>15,r^=r<<4,r^=r>>>13,a>=0&&(i=i+1640531527|0,o=0==(n=s[127&a]^=r+i)?o+1:0);for(o>=128&&(s[127&(t&&t.length||0)]=-1),o=127,a=512;a>0;--a)r=s[o+34&127],n=s[o=o+1&127],r^=r<<13,n^=n<<17,r^=r>>>15,n^=n>>>12,s[o]=r^n;e.w=i,e.X=s,e.i=o}(t,e)}function i(e,t){return t.i=e.i,t.w=e.w,t.X=e.X.slice(),t}function s(e,t){null==e&&(e=+new Date);var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(r.X&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.xor4096=s}(0,e=n.nmd(e),n.amdD)},402:function(e,t,n){var r;!function(e,o){function a(e){var t=this;t.next=function(){var e,n,r=t.x,o=t.i;return e=r[o],n=(e^=e>>>7)^e<<24,n^=(e=r[o+1&7])^e>>>10,n^=(e=r[o+3&7])^e>>>3,n^=(e=r[o+4&7])^e<<7,e=r[o+7&7],n^=(e^=e<<13)^e<<9,r[o]=n,t.i=o+1&7,n},function(e,t){var n,r=[];if(t===(0|t))r[0]=t;else for(t=&quot;&quot;+t,n=0;n<t.length;++n)r[7&n]=r[7&n]<<15^t.charCodeAt(n)+r[n+1&7]<<13;for(;r.length<8;)r.push(0);for(n=0;n<8&&0===r[n];++n);for(8==n?r[7]=-1:r[n],e.x=r,e.i=0,n=256;n>0;--n)e.next()}(t,e)}function i(e,t){return t.x=e.x.slice(),t.i=e.i,t}function s(e,t){null==e&&(e=+new Date);var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(r.x&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.xorshift7=s}(0,e=n.nmd(e),n.amdD)},744:function(e,t,n){var r;!function(e,o){function a(e){var t=this,n=&quot;&quot;;t.next=function(){var e=t.x^t.x>>>2;return t.x=t.y,t.y=t.z,t.z=t.w,t.w=t.v,(t.d=t.d+362437|0)+(t.v=t.v^t.v<<4^e^e<<1)|0},t.x=0,t.y=0,t.z=0,t.w=0,t.v=0,e===(0|e)?t.x=e:n+=e;for(var r=0;r<n.length+64;r++)t.x^=0|n.charCodeAt(r),r==n.length&&(t.d=t.x<<10^t.x>>>4),t.next()}function i(e,t){return t.x=e.x,t.y=e.y,t.z=e.z,t.w=e.w,t.v=e.v,t.d=e.d,t}function s(e,t){var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(&quot;object&quot;==typeof r&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.xorwow=s}(0,e=n.nmd(e),n.amdD)},262:function(e,t,n){var r;!function(o,a,i){var s,l=256,c=i.pow(l,6),u=i.pow(2,52),d=2*u,p=255;function f(e,t,n){var r=[],p=v(h((t=1==t?{entropy:!0}:t||{}).entropy?[e,T(a)]:null==e?function(){try{var e;return s&&(e=s.randomBytes)?e=e(l):(e=new Uint8Array(l),(o.crypto||o.msCrypto).getRandomValues(e)),T(e)}catch(e){var t=o.navigator,n=t&&t.plugins;return[+new Date,o,n,o.screen,T(a)]}}():e,3),r),f=new g(r),y=function(){for(var e=f.g(6),t=c,n=0;e<u;)e=(e+n)*l,t*=l,n=f.g(1);for(;e>=d;)e/=2,t/=2,n>>>=1;return(e+n)/t};return y.int32=function(){return 0|f.g(4)},y.quick=function(){return f.g(4)/4294967296},y.double=y,v(T(f.S),a),(t.pass||n||function(e,t,n,r){return r&&(r.S&&m(r,f),e.state=function(){return m(f,{})}),n?(i.random=e,t):e})(y,p,&quot;global&quot;in t?t.global:this==i,t.state)}function g(e){var t,n=e.length,r=this,o=0,a=r.i=r.j=0,i=r.S=[];for(n||(e=[n++]);o<l;)i[o]=o++;for(o=0;o<l;o++)i[o]=i[a=p&a+e[o%n]+(t=i[o])],i[a]=t;(r.g=function(e){for(var t,n=0,o=r.i,a=r.j,i=r.S;e--;)t=i[o=p&o+1],n=n*l+i[p&(i[o]=i[a=p&a+t])+(i[a]=t)];return r.i=o,r.j=a,n})(l)}function m(e,t){return t.i=e.i,t.j=e.j,t.S=e.S.slice(),t}function h(e,t){var n,r=[],o=typeof e;if(t&&&quot;object&quot;==o)for(n in e)try{r.push(h(e[n],t-1))}catch(e){}return r.length?r:&quot;string&quot;==o?e:e+&quot;\\0&quot;}function v(e,t){for(var n,r=e+&quot;&quot;,o=0;o<r.length;)t[p&o]=p&(n^=19*t[p&o])+r.charCodeAt(o++);return T(t)}function T(e){return String.fromCharCode.apply(0,e)}if(v(i.random(),a),e.exports){e.exports=f;try{s=n(1)}catch(e){}}else void 0===(r=function(){return f}.call(t,n,t,e))||(e.exports=r)}(&quot;undefined&quot;!=typeof self?self:this,[],Math)},292:function(e){e.exports=function(){&quot;use strict&quot;;var e=[&quot;0&quot;,&quot;1&quot;,&quot;2&quot;,&quot;3&quot;,&quot;4&quot;,&quot;5&quot;,&quot;6&quot;,&quot;7&quot;,&quot;8&quot;,&quot;9&quot;,&quot;a&quot;,&quot;b&quot;,&quot;c&quot;,&quot;d&quot;,&quot;e&quot;,&quot;f&quot;];function t(e,t){var n=e[0],r=e[1],o=e[2],a=e[3];r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&o|~r&a)+t[0]-680876936|0)<<7|n>>>25)+r|0)&r|~n&o)+t[1]-389564586|0)<<12|a>>>20)+n|0)&n|~a&r)+t[2]+606105819|0)<<17|o>>>15)+a|0)&a|~o&n)+t[3]-1044525330|0)<<22|r>>>10)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&o|~r&a)+t[4]-176418897|0)<<7|n>>>25)+r|0)&r|~n&o)+t[5]+1200080426|0)<<12|a>>>20)+n|0)&n|~a&r)+t[6]-1473231341|0)<<17|o>>>15)+a|0)&a|~o&n)+t[7]-45705983|0)<<22|r>>>10)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&o|~r&a)+t[8]+1770035416|0)<<7|n>>>25)+r|0)&r|~n&o)+t[9]-1958414417|0)<<12|a>>>20)+n|0)&n|~a&r)+t[10]-42063|0)<<17|o>>>15)+a|0)&a|~o&n)+t[11]-1990404162|0)<<22|r>>>10)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&o|~r&a)+t[12]+1804603682|0)<<7|n>>>25)+r|0)&r|~n&o)+t[13]-40341101|0)<<12|a>>>20)+n|0)&n|~a&r)+t[14]-1502002290|0)<<17|o>>>15)+a|0)&a|~o&n)+t[15]+1236535329|0)<<22|r>>>10)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&a|o&~a)+t[1]-165796510|0)<<5|n>>>27)+r|0)&o|r&~o)+t[6]-1069501632|0)<<9|a>>>23)+n|0)&r|n&~r)+t[11]+643717713|0)<<14|o>>>18)+a|0)&n|a&~n)+t[0]-373897302|0)<<20|r>>>12)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&a|o&~a)+t[5]-701558691|0)<<5|n>>>27)+r|0)&o|r&~o)+t[10]+38016083|0)<<9|a>>>23)+n|0)&r|n&~r)+t[15]-660478335|0)<<14|o>>>18)+a|0)&n|a&~n)+t[4]-405537848|0)<<20|r>>>12)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&a|o&~a)+t[9]+568446438|0)<<5|n>>>27)+r|0)&o|r&~o)+t[14]-1019803690|0)<<9|a>>>23)+n|0)&r|n&~r)+t[3]-187363961|0)<<14|o>>>18)+a|0)&n|a&~n)+t[8]+1163531501|0)<<20|r>>>12)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&a|o&~a)+t[13]-1444681467|0)<<5|n>>>27)+r|0)&o|r&~o)+t[2]-51403784|0)<<9|a>>>23)+n|0)&r|n&~r)+t[7]+1735328473|0)<<14|o>>>18)+a|0)&n|a&~n)+t[12]-1926607734|0)<<20|r>>>12)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r^o^a)+t[5]-378558|0)<<4|n>>>28)+r|0)^r^o)+t[8]-2022574463|0)<<11|a>>>21)+n|0)^n^r)+t[11]+1839030562|0)<<16|o>>>16)+a|0)^a^n)+t[14]-35309556|0)<<23|r>>>9)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r^o^a)+t[1]-1530992060|0)<<4|n>>>28)+r|0)^r^o)+t[4]+1272893353|0)<<11|a>>>21)+n|0)^n^r)+t[7]-155497632|0)<<16|o>>>16)+a|0)^a^n)+t[10]-1094730640|0)<<23|r>>>9)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r^o^a)+t[13]+681279174|0)<<4|n>>>28)+r|0)^r^o)+t[0]-358537222|0)<<11|a>>>21)+n|0)^n^r)+t[3]-722521979|0)<<16|o>>>16)+a|0)^a^n)+t[6]+76029189|0)<<23|r>>>9)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r^o^a)+t[9]-640364487|0)<<4|n>>>28)+r|0)^r^o)+t[12]-421815835|0)<<11|a>>>21)+n|0)^n^r)+t[15]+530742520|0)<<16|o>>>16)+a|0)^a^n)+t[2]-995338651|0)<<23|r>>>9)+o|0,r=((r+=((a=((a+=(r^((n=((n+=(o^(r|~a))+t[0]-198630844|0)<<6|n>>>26)+r|0)|~o))+t[7]+1126891415|0)<<10|a>>>22)+n|0)^((o=((o+=(n^(a|~r))+t[14]-1416354905|0)<<15|o>>>17)+a|0)|~n))+t[5]-57434055|0)<<21|r>>>11)+o|0,r=((r+=((a=((a+=(r^((n=((n+=(o^(r|~a))+t[12]+1700485571|0)<<6|n>>>26)+r|0)|~o))+t[3]-1894986606|0)<<10|a>>>22)+n|0)^((o=((o+=(n^(a|~r))+t[10]-1051523|0)<<15|o>>>17)+a|0)|~n))+t[1]-2054922799|0)<<21|r>>>11)+o|0,r=((r+=((a=((a+=(r^((n=((n+=(o^(r|~a))+t[8]+1873313359|0)<<6|n>>>26)+r|0)|~o))+t[15]-30611744|0)<<10|a>>>22)+n|0)^((o=((o+=(n^(a|~r))+t[6]-1560198380|0)<<15|o>>>17)+a|0)|~n))+t[13]+1309151649|0)<<21|r>>>11)+o|0,r=((r+=((a=((a+=(r^((n=((n+=(o^(r|~a))+t[4]-145523070|0)<<6|n>>>26)+r|0)|~o))+t[11]-1120210379|0)<<10|a>>>22)+n|0)^((o=((o+=(n^(a|~r))+t[2]+718787259|0)<<15|o>>>17)+a|0)|~n))+t[9]-343485551|0)<<21|r>>>11)+o|0,e[0]=n+e[0]|0,e[1]=r+e[1]|0,e[2]=o+e[2]|0,e[3]=a+e[3]|0}function n(e){var t,n=[];for(t=0;t<64;t+=4)n[t>>2]=e.charCodeAt(t)+(e.charCodeAt(t+1)<<8)+(e.charCodeAt(t+2)<<16)+(e.charCodeAt(t+3)<<24);return n}function r(e){var t,n=[];for(t=0;t<64;t+=4)n[t>>2]=e[t]+(e[t+1]<<8)+(e[t+2]<<16)+(e[t+3]<<24);return n}function o(e){var r,o,a,i,s,l,c=e.length,u=[1732584193,-271733879,-1732584194,271733878];for(r=64;r<=c;r+=64)t(u,n(e.substring(r-64,r)));for(o=(e=e.substring(r-64)).length,a=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],r=0;r<o;r+=1)a[r>>2]|=e.charCodeAt(r)<<(r%4<<3);if(a[r>>2]|=128<<(r%4<<3),r>55)for(t(u,a),r=0;r<16;r+=1)a[r]=0;return i=(i=8*c).toString(16).match(/(.*?)(.{0,8})$/),s=parseInt(i[2],16),l=parseInt(i[1],16)||0,a[14]=s,a[15]=l,t(u,a),u}function a(t){var n,r=&quot;&quot;;for(n=0;n<4;n+=1)r+=e[t>>8*n+4&15]+e[t>>8*n&15];return r}function i(e){var t;for(t=0;t<e.length;t+=1)e[t]=a(e[t]);return e.join(&quot;&quot;)}function s(e){return/[\\u0080-\\uFFFF]/.test(e)&&(e=unescape(encodeURIComponent(e))),e}function l(e){var t,n=[],r=e.length;for(t=0;t<r-1;t+=2)n.push(parseInt(e.substr(t,2),16));return String.fromCharCode.apply(String,n)}function c(){this.reset()}return i(o(&quot;hello&quot;)),&quot;undefined&quot;==typeof ArrayBuffer||ArrayBuffer.prototype.slice||function(){function e(e,t){return(e=0|e||0)<0?Math.max(e+t,0):Math.min(e,t)}ArrayBuffer.prototype.slice=function(t,n){var r,o,a,i,s=this.byteLength,l=e(t,s),c=s;return undefined!==n&&(c=e(n,s)),l>c?new ArrayBuffer(0):(r=c-l,o=new ArrayBuffer(r),a=new Uint8Array(o),i=new Uint8Array(this,l,r),a.set(i),o)}}(),c.prototype.append=function(e){return this.appendBinary(s(e)),this},c.prototype.appendBinary=function(e){this._buff+=e,this._length+=e.length;var r,o=this._buff.length;for(r=64;r<=o;r+=64)t(this._hash,n(this._buff.substring(r-64,r)));return this._buff=this._buff.substring(r-64),this},c.prototype.end=function(e){var t,n,r=this._buff,o=r.length,a=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;t<o;t+=1)a[t>>2]|=r.charCodeAt(t)<<(t%4<<3);return this._finish(a,o),n=i(this._hash),e&&(n=l(n)),this.reset(),n},c.prototype.reset=function(){return this._buff=&quot;&quot;,this._length=0,this._hash=[1732584193,-271733879,-1732584194,271733878],this},c.prototype.getState=function(){return{buff:this._buff,length:this._length,hash:this._hash.slice()}},c.prototype.setState=function(e){return this._buff=e.buff,this._length=e.length,this._hash=e.hash,this},c.prototype.destroy=function(){delete this._hash,delete this._buff,delete this._length},c.prototype._finish=function(e,n){var r,o,a,i=n;if(e[i>>2]|=128<<(i%4<<3),i>55)for(t(this._hash,e),i=0;i<16;i+=1)e[i]=0;r=(r=8*this._length).toString(16).match(/(.*?)(.{0,8})$/),o=parseInt(r[2],16),a=parseInt(r[1],16)||0,e[14]=o,e[15]=a,t(this._hash,e)},c.hash=function(e,t){return c.hashBinary(s(e),t)},c.hashBinary=function(e,t){var n=i(o(e));return t?l(n):n},c.ArrayBuffer=function(){this.reset()},c.ArrayBuffer.prototype.append=function(e){var n,o,a,i,s,l=(o=this._buff.buffer,a=e,i=!0,(s=new Uint8Array(o.byteLength+a.byteLength)).set(new Uint8Array(o)),s.set(new Uint8Array(a),o.byteLength),i?s:s.buffer),c=l.length;for(this._length+=e.byteLength,n=64;n<=c;n+=64)t(this._hash,r(l.subarray(n-64,n)));return this._buff=n-64<c?new Uint8Array(l.buffer.slice(n-64)):new Uint8Array(0),this},c.ArrayBuffer.prototype.end=function(e){var t,n,r=this._buff,o=r.length,a=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;t<o;t+=1)a[t>>2]|=r[t]<<(t%4<<3);return this._finish(a,o),n=i(this._hash),e&&(n=l(n)),this.reset(),n},c.ArrayBuffer.prototype.reset=function(){return this._buff=new Uint8Array(0),this._length=0,this._hash=[1732584193,-271733879,-1732584194,271733878],this},c.ArrayBuffer.prototype.getState=function(){var e,t=c.prototype.getState.call(this);return t.buff=(e=t.buff,String.fromCharCode.apply(null,new Uint8Array(e))),t},c.ArrayBuffer.prototype.setState=function(e){return e.buff=function(e,t){var n,r=e.length,o=new ArrayBuffer(r),a=new Uint8Array(o);for(n=0;n<r;n+=1)a[n]=e.charCodeAt(n);return t?a:o}(e.buff,!0),c.prototype.setState.call(this,e)},c.ArrayBuffer.prototype.destroy=c.prototype.destroy,c.ArrayBuffer.prototype._finish=c.prototype._finish,c.ArrayBuffer.hash=function(e,n){var o=i(function(e){var n,o,a,i,s,l,c=e.length,u=[1732584193,-271733879,-1732584194,271733878];for(n=64;n<=c;n+=64)t(u,r(e.subarray(n-64,n)));for(o=(e=n-64<c?e.subarray(n-64):new Uint8Array(0)).length,a=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],n=0;n<o;n+=1)a[n>>2]|=e[n]<<(n%4<<3);if(a[n>>2]|=128<<(n%4<<3),n>55)for(t(u,a),n=0;n<16;n+=1)a[n]=0;return i=(i=8*c).toString(16).match(/(.*?)(.{0,8})$/),s=parseInt(i[2],16),l=parseInt(i[1],16)||0,a[14]=s,a[15]=l,t(u,a),u}(new Uint8Array(e)));return n?l(o):o},c}()},96:function(e,t,n){&quot;use strict&quot;;var r=n(20),o=n.n(r),a=n(613),i=n.n(a),s=n(336),l=n.n(s),c=new URL(n(183),n.b),u=i()(o()),d=l()(c);u.push([e.id,&quot;.viewer-module-fullScreen_bbk9Y {\\n  position: absolute;\\n  width: 100vw;\\n  height: 100vh;\\n  top: 0;\\n  left: 0;\\n  overflow: hidden;\\n  background: black;\\n  margin: 0;\\n  padding: 0;\\n  z-index: -1;\\n  display: flex;\\n  align-items: center;\\n  justify-content: center;\\n}\\n\\n.viewer-module-fullParentSize_ETopO {\\n  position: absolute;\\n  width: 100%;\\n  height: 100%;\\n  top: 0;\\n  left: 0;\\n  overflow: hidden;\\n}\\n\\n.viewer-module-bigFileDrop_aqCgh {\\n  position: absolute;\\n  left: 50%;\\n  top: 50%;\\n  transform: translate(-50%, -50%);\\n  background-color: white;\\n  background-image: url(&quot;+d+&quot;);\\n  background-repeat: no-repeat;\\n  background-position: center;\\n  background-size: contain;\\n  border-radius: 10px;\\n  width: 50px;\\n  padding: calc(50vh - 2em) calc(50vw - 25px - 2em);\\n  cursor: pointer;\\n}\\n\\n.viewer-module-progress_cYjQJ {\\n  flex: none;\\n  font-size: 50px;\\n  color: black;\\n  z-index: 1;\\n  background: rgba(128,128,128,.5);\\n  padding: 20px;\\n  border-radius: 10px;\\n  -webkit-user-select: none;\\n     -moz-user-select: none;\\n          user-select: none;\\n}\\n\\nbody {\\n  margin: 0;\\n}\\n\\nhtml { \\n  overflow: hidden; \\n}\\n&quot;,&quot;&quot;]),u.locals={fullScreen:&quot;viewer-module-fullScreen_bbk9Y&quot;,fullParentSize:&quot;viewer-module-fullParentSize_ETopO&quot;,bigFileDrop:&quot;viewer-module-bigFileDrop_aqCgh&quot;,progress:&quot;viewer-module-progress_cYjQJ&quot;},t.A=u},50:function(e,t,n){var r=n(853),o=n(77);void 0===o.OfflineLocalView&&(o.OfflineLocalView=r),e.exports=r},911:function(e){&quot;use strict&quot;;var t=[];function n(e){for(var n=-1,r=0;r<t.length;r++)if(t[r].identifier===e){n=r;break}return n}function r(e,r){for(var a={},i=[],s=0;s<e.length;s++){var l=e[s],c=r.base?l[0]+r.base:l[0],u=a[c]||0,d=&quot;&quot;.concat(c,&quot; &quot;).concat(u);a[c]=u+1;var p=n(d),f={css:l[1],media:l[2],sourceMap:l[3],supports:l[4],layer:l[5]};if(-1!==p)t[p].references++,t[p].updater(f);else{var g=o(f,r);r.byIndex=s,t.splice(s,0,{identifier:d,updater:g,references:1})}i.push(d)}return i}function o(e,t){var n=t.domAPI(t);return n.update(e),function(t){if(t){if(t.css===e.css&&t.media===e.media&&t.sourceMap===e.sourceMap&&t.supports===e.supports&&t.layer===e.layer)return;n.update(e=t)}else n.remove()}}e.exports=function(e,o){var a=r(e=e||[],o=o||{});return function(e){e=e||[];for(var i=0;i<a.length;i++){var s=n(a[i]);t[s].references--}for(var l=r(e,o),c=0;c<a.length;c++){var u=n(a[c]);0===t[u].references&&(t[u].updater(),t.splice(u,1))}a=l}}},383:function(e){&quot;use strict&quot;;var t={};e.exports=function(e,n){var r=function(e){if(void 0===t[e]){var n=document.querySelector(e);if(window.HTMLIFrameElement&&n instanceof window.HTMLIFrameElement)try{n=n.contentDocument.head}catch(e){n=null}t[e]=n}return t[e]}(e);if(!r)throw new Error(&quot;Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.&quot;);r.appendChild(n)}},88:function(e){&quot;use strict&quot;;e.exports=function(e){var t=document.createElement(&quot;style&quot;);return e.setAttributes(t,e.attributes),e.insert(t,e.options),t}},884:function(e,t,n){&quot;use strict&quot;;e.exports=function(e){var t=n.nc;t&&e.setAttribute(&quot;nonce&quot;,t)}},893:function(e){&quot;use strict&quot;;e.exports=function(e){var t=e.insertStyleElement(e);return{update:function(n){!function(e,t,n){var r=&quot;&quot;;n.supports&&(r+=&quot;@supports (&quot;.concat(n.supports,&quot;) {&quot;)),n.media&&(r+=&quot;@media &quot;.concat(n.media,&quot; {&quot;));var o=void 0!==n.layer;o&&(r+=&quot;@layer&quot;.concat(n.layer.length>0?&quot; &quot;.concat(n.layer):&quot;&quot;,&quot; {&quot;)),r+=n.css,o&&(r+=&quot;}&quot;),n.media&&(r+=&quot;}&quot;),n.supports&&(r+=&quot;}&quot;);var a=n.sourceMap;a&&&quot;undefined&quot;!=typeof btoa&&(r+=&quot;\\n/*# sourceMappingURL=data:application/json;base64,&quot;.concat(btoa(unescape(encodeURIComponent(JSON.stringify(a)))),&quot; */&quot;)),t.styleTagTransform(r,e,t.options)}(t,e,n)},remove:function(){!function(e){if(null===e.parentNode)return!1;e.parentNode.removeChild(e)}(t)}}}},997:function(e){&quot;use strict&quot;;e.exports=function(e,t){if(t.styleSheet)t.styleSheet.cssText=e;else{for(;t.firstChild;)t.removeChild(t.firstChild);t.appendChild(document.createTextNode(e))}}},183:function(e,t,n){&quot;use strict&quot;;e.exports=n.p+&quot;138e7b1469f64156810a.jpg&quot;},1:function(){}},t={};function n(r){var o=t[r];if(void 0!==o)return o.exports;var a=t[r]={id:r,loaded:!1,exports:{}};return e[r].call(a.exports,a,a.exports,n),a.loaded=!0,a.exports}n.m=e,n.amdD=function(){throw new Error(&quot;define cannot be used indirect&quot;)},n.amdO={},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,{a:t}),t},n.d=function(e,t){for(var r in t)n.o(t,r)&&!n.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},n.g=function(){if(&quot;object&quot;==typeof globalThis)return globalThis;try{return this||new Function(&quot;return this&quot;)()}catch(e){if(&quot;object&quot;==typeof window)return window}}(),n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.r=function(e){&quot;undefined&quot;!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:&quot;Module&quot;}),Object.defineProperty(e,&quot;__esModule&quot;,{value:!0})},n.nmd=function(e){return e.paths=[],e.children||(e.children=[]),e},n.p=&quot;&quot;,n.b=document.baseURI||self.location.href,n.nc=void 0,n(50)}();\n</script>\n<script>\nvar container = document.querySelector('.content');\nvar base64Str = &quot;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&quot;;\n\nOfflineLocalView.load(container, { base64Str });\n</script>\n</body>\n</html>\n\" class=\"pyvista\" style=\"width: 100%; height: 600px; border: 1px solid rgb(221,221,221);\"></iframe>"
      }
     },
     "75fb90cdf0f34089b1f9c554e66a84d4": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "2.0.0",
       "_model_name": "HTMLStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "2.0.0",
       "_view_name": "StyleView",
       "background": null,
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "8f964324e6694af4ad4588c06bea676b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "2.0.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "2.0.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_allow_html": false,
       "layout": "IPY_MODEL_219ac35db39d48b699b11a71d6d7b816",
       "placeholder": "​",
       "style": "IPY_MODEL_20bcdd4391324d5b814031dd59233ae8",
       "tabbable": null,
       "tooltip": null,
       "value": "<iframe srcdoc=\"<!DOCTYPE html>\n<html>\n  <head>\n    <meta http-equiv=&quot;Content-type&quot; content=&quot;text/html; charset=utf-8&quot;/>\n    <meta name=&quot;viewport&quot; content=&quot;width=device-width, height=device-height, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no&quot;>\n  </head>\n  <body>\n    <div class=&quot;content&quot;></div>\n<script type=&quot;text/javascript&quot;>\n!function(){var e={853:function(e,t,n){&quot;use strict&quot;;n.r(t),n.d(t,{initLocalFileLoader:function(){return XC},load:function(){return qC}});var r={};n.r(r),n.d(r,{add:function(){return J},adjoint:function(){return T},clone:function(){return d},copy:function(){return p},create:function(){return u},determinant:function(){return y},equals:function(){return oe},exactEquals:function(){return re},frob:function(){return Q},fromQuat:function(){return G},fromQuat2:function(){return L},fromRotation:function(){return R},fromRotationTranslation:function(){return D},fromRotationTranslationScale:function(){return _},fromRotationTranslationScaleOrigin:function(){return k},fromScaling:function(){return P},fromTranslation:function(){return O},fromValues:function(){return f},fromXRotation:function(){return M},fromYRotation:function(){return E},fromZRotation:function(){return V},frustum:function(){return U},getRotation:function(){return F},getScaling:function(){return N},getTranslation:function(){return B},identity:function(){return m},invert:function(){return v},lookAt:function(){return X},mul:function(){return ae},multiply:function(){return b},multiplyScalar:function(){return te},multiplyScalarAndAdd:function(){return ne},ortho:function(){return $},orthoNO:function(){return K},orthoZO:function(){return q},perspective:function(){return W},perspectiveFromFieldOfView:function(){return j},perspectiveNO:function(){return z},perspectiveZO:function(){return H},rotate:function(){return S},rotateX:function(){return A},rotateY:function(){return I},rotateZ:function(){return w},scale:function(){return C},set:function(){return g},str:function(){return Z},sub:function(){return ie},subtract:function(){return ee},targetTo:function(){return Y},translate:function(){return x},transpose:function(){return h}});var o={};n.r(o),n.d(o,{add:function(){return Ee},adjoint:function(){return he},clone:function(){return ce},copy:function(){return ue},create:function(){return se},determinant:function(){return ve},equals:function(){return Ne},exactEquals:function(){return Be},frob:function(){return Me},fromMat2d:function(){return Ie},fromMat4:function(){return le},fromQuat:function(){return we},fromRotation:function(){return Se},fromScaling:function(){return Ae},fromTranslation:function(){return Ce},fromValues:function(){return de},identity:function(){return fe},invert:function(){return me},mul:function(){return Fe},multiply:function(){return Te},multiplyScalar:function(){return De},multiplyScalarAndAdd:function(){return Le},normalFromMat4:function(){return Oe},projection:function(){return Pe},rotate:function(){return be},scale:function(){return xe},set:function(){return pe},str:function(){return Re},sub:function(){return _e},subtract:function(){return Ve},translate:function(){return ye},transpose:function(){return ge}});const a=document.querySelector(&quot;head&quot;);a&&[16,32,96,160,196].forEach((e=>{const t=document.createElement(&quot;link&quot;);t.setAttribute(&quot;rel&quot;,&quot;icon&quot;),t.setAttribute(&quot;href&quot;,`https://kitware.github.io/vtk-js/icon/favicon-${e}x${e}.png`),t.setAttribute(&quot;sizes&quot;,`${e}x${e}`),t.setAttribute(&quot;type&quot;,&quot;image/png&quot;),a.appendChild(t)}));var i=1e-6,s=&quot;undefined&quot;!=typeof Float32Array?Float32Array:Array;Math.random;var l=Math.PI/180;function c(e){return e*l}function u(){var e=new s(16);return s!=Float32Array&&(e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0),e[0]=1,e[5]=1,e[10]=1,e[15]=1,e}function d(e){var t=new s(16);return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t[4]=e[4],t[5]=e[5],t[6]=e[6],t[7]=e[7],t[8]=e[8],t[9]=e[9],t[10]=e[10],t[11]=e[11],t[12]=e[12],t[13]=e[13],t[14]=e[14],t[15]=e[15],t}function p(e,t){return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[4]=t[4],e[5]=t[5],e[6]=t[6],e[7]=t[7],e[8]=t[8],e[9]=t[9],e[10]=t[10],e[11]=t[11],e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15],e}function f(e,t,n,r,o,a,i,l,c,u,d,p,f,g,m,h){var v=new s(16);return v[0]=e,v[1]=t,v[2]=n,v[3]=r,v[4]=o,v[5]=a,v[6]=i,v[7]=l,v[8]=c,v[9]=u,v[10]=d,v[11]=p,v[12]=f,v[13]=g,v[14]=m,v[15]=h,v}function g(e,t,n,r,o,a,i,s,l,c,u,d,p,f,g,m,h){return e[0]=t,e[1]=n,e[2]=r,e[3]=o,e[4]=a,e[5]=i,e[6]=s,e[7]=l,e[8]=c,e[9]=u,e[10]=d,e[11]=p,e[12]=f,e[13]=g,e[14]=m,e[15]=h,e}function m(e){return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=1,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=1,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function h(e,t){if(e===t){var n=t[1],r=t[2],o=t[3],a=t[6],i=t[7],s=t[11];e[1]=t[4],e[2]=t[8],e[3]=t[12],e[4]=n,e[6]=t[9],e[7]=t[13],e[8]=r,e[9]=a,e[11]=t[14],e[12]=o,e[13]=i,e[14]=s}else e[0]=t[0],e[1]=t[4],e[2]=t[8],e[3]=t[12],e[4]=t[1],e[5]=t[5],e[6]=t[9],e[7]=t[13],e[8]=t[2],e[9]=t[6],e[10]=t[10],e[11]=t[14],e[12]=t[3],e[13]=t[7],e[14]=t[11],e[15]=t[15];return e}function v(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8],d=t[9],p=t[10],f=t[11],g=t[12],m=t[13],h=t[14],v=t[15],T=n*s-r*i,y=n*l-o*i,b=n*c-a*i,x=r*l-o*s,C=r*c-a*s,S=o*c-a*l,A=u*m-d*g,I=u*h-p*g,w=u*v-f*g,O=d*h-p*m,P=d*v-f*m,R=p*v-f*h,M=T*R-y*P+b*O+x*w-C*I+S*A;return M?(M=1/M,e[0]=(s*R-l*P+c*O)*M,e[1]=(o*P-r*R-a*O)*M,e[2]=(m*S-h*C+v*x)*M,e[3]=(p*C-d*S-f*x)*M,e[4]=(l*w-i*R-c*I)*M,e[5]=(n*R-o*w+a*I)*M,e[6]=(h*b-g*S-v*y)*M,e[7]=(u*S-p*b+f*y)*M,e[8]=(i*P-s*w+c*A)*M,e[9]=(r*w-n*P-a*A)*M,e[10]=(g*C-m*b+v*T)*M,e[11]=(d*b-u*C-f*T)*M,e[12]=(s*I-i*O-l*A)*M,e[13]=(n*O-r*I+o*A)*M,e[14]=(m*y-g*x-h*T)*M,e[15]=(u*x-d*y+p*T)*M,e):null}function T(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8],d=t[9],p=t[10],f=t[11],g=t[12],m=t[13],h=t[14],v=t[15];return e[0]=s*(p*v-f*h)-d*(l*v-c*h)+m*(l*f-c*p),e[1]=-(r*(p*v-f*h)-d*(o*v-a*h)+m*(o*f-a*p)),e[2]=r*(l*v-c*h)-s*(o*v-a*h)+m*(o*c-a*l),e[3]=-(r*(l*f-c*p)-s*(o*f-a*p)+d*(o*c-a*l)),e[4]=-(i*(p*v-f*h)-u*(l*v-c*h)+g*(l*f-c*p)),e[5]=n*(p*v-f*h)-u*(o*v-a*h)+g*(o*f-a*p),e[6]=-(n*(l*v-c*h)-i*(o*v-a*h)+g*(o*c-a*l)),e[7]=n*(l*f-c*p)-i*(o*f-a*p)+u*(o*c-a*l),e[8]=i*(d*v-f*m)-u*(s*v-c*m)+g*(s*f-c*d),e[9]=-(n*(d*v-f*m)-u*(r*v-a*m)+g*(r*f-a*d)),e[10]=n*(s*v-c*m)-i*(r*v-a*m)+g*(r*c-a*s),e[11]=-(n*(s*f-c*d)-i*(r*f-a*d)+u*(r*c-a*s)),e[12]=-(i*(d*h-p*m)-u*(s*h-l*m)+g*(s*p-l*d)),e[13]=n*(d*h-p*m)-u*(r*h-o*m)+g*(r*p-o*d),e[14]=-(n*(s*h-l*m)-i*(r*h-o*m)+g*(r*l-o*s)),e[15]=n*(s*p-l*d)-i*(r*p-o*d)+u*(r*l-o*s),e}function y(e){var t=e[0],n=e[1],r=e[2],o=e[3],a=e[4],i=e[5],s=e[6],l=e[7],c=e[8],u=e[9],d=e[10],p=e[11],f=e[12],g=e[13],m=e[14],h=e[15];return(t*i-n*a)*(d*h-p*m)-(t*s-r*a)*(u*h-p*g)+(t*l-o*a)*(u*m-d*g)+(n*s-r*i)*(c*h-p*f)-(n*l-o*i)*(c*m-d*f)+(r*l-o*s)*(c*g-u*f)}function b(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=t[9],f=t[10],g=t[11],m=t[12],h=t[13],v=t[14],T=t[15],y=n[0],b=n[1],x=n[2],C=n[3];return e[0]=y*r+b*s+x*d+C*m,e[1]=y*o+b*l+x*p+C*h,e[2]=y*a+b*c+x*f+C*v,e[3]=y*i+b*u+x*g+C*T,y=n[4],b=n[5],x=n[6],C=n[7],e[4]=y*r+b*s+x*d+C*m,e[5]=y*o+b*l+x*p+C*h,e[6]=y*a+b*c+x*f+C*v,e[7]=y*i+b*u+x*g+C*T,y=n[8],b=n[9],x=n[10],C=n[11],e[8]=y*r+b*s+x*d+C*m,e[9]=y*o+b*l+x*p+C*h,e[10]=y*a+b*c+x*f+C*v,e[11]=y*i+b*u+x*g+C*T,y=n[12],b=n[13],x=n[14],C=n[15],e[12]=y*r+b*s+x*d+C*m,e[13]=y*o+b*l+x*p+C*h,e[14]=y*a+b*c+x*f+C*v,e[15]=y*i+b*u+x*g+C*T,e}function x(e,t,n){var r,o,a,i,s,l,c,u,d,p,f,g,m=n[0],h=n[1],v=n[2];return t===e?(e[12]=t[0]*m+t[4]*h+t[8]*v+t[12],e[13]=t[1]*m+t[5]*h+t[9]*v+t[13],e[14]=t[2]*m+t[6]*h+t[10]*v+t[14],e[15]=t[3]*m+t[7]*h+t[11]*v+t[15]):(r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=t[9],f=t[10],g=t[11],e[0]=r,e[1]=o,e[2]=a,e[3]=i,e[4]=s,e[5]=l,e[6]=c,e[7]=u,e[8]=d,e[9]=p,e[10]=f,e[11]=g,e[12]=r*m+s*h+d*v+t[12],e[13]=o*m+l*h+p*v+t[13],e[14]=a*m+c*h+f*v+t[14],e[15]=i*m+u*h+g*v+t[15]),e}function C(e,t,n){var r=n[0],o=n[1],a=n[2];return e[0]=t[0]*r,e[1]=t[1]*r,e[2]=t[2]*r,e[3]=t[3]*r,e[4]=t[4]*o,e[5]=t[5]*o,e[6]=t[6]*o,e[7]=t[7]*o,e[8]=t[8]*a,e[9]=t[9]*a,e[10]=t[10]*a,e[11]=t[11]*a,e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15],e}function S(e,t,n,r){var o,a,s,l,c,u,d,p,f,g,m,h,v,T,y,b,x,C,S,A,I,w,O,P,R=r[0],M=r[1],E=r[2],V=Math.hypot(R,M,E);return V<i?null:(R*=V=1/V,M*=V,E*=V,o=Math.sin(n),s=1-(a=Math.cos(n)),l=t[0],c=t[1],u=t[2],d=t[3],p=t[4],f=t[5],g=t[6],m=t[7],h=t[8],v=t[9],T=t[10],y=t[11],b=R*R*s+a,x=M*R*s+E*o,C=E*R*s-M*o,S=R*M*s-E*o,A=M*M*s+a,I=E*M*s+R*o,w=R*E*s+M*o,O=M*E*s-R*o,P=E*E*s+a,e[0]=l*b+p*x+h*C,e[1]=c*b+f*x+v*C,e[2]=u*b+g*x+T*C,e[3]=d*b+m*x+y*C,e[4]=l*S+p*A+h*I,e[5]=c*S+f*A+v*I,e[6]=u*S+g*A+T*I,e[7]=d*S+m*A+y*I,e[8]=l*w+p*O+h*P,e[9]=c*w+f*O+v*P,e[10]=u*w+g*O+T*P,e[11]=d*w+m*O+y*P,t!==e&&(e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15]),e)}function A(e,t,n){var r=Math.sin(n),o=Math.cos(n),a=t[4],i=t[5],s=t[6],l=t[7],c=t[8],u=t[9],d=t[10],p=t[11];return t!==e&&(e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15]),e[4]=a*o+c*r,e[5]=i*o+u*r,e[6]=s*o+d*r,e[7]=l*o+p*r,e[8]=c*o-a*r,e[9]=u*o-i*r,e[10]=d*o-s*r,e[11]=p*o-l*r,e}function I(e,t,n){var r=Math.sin(n),o=Math.cos(n),a=t[0],i=t[1],s=t[2],l=t[3],c=t[8],u=t[9],d=t[10],p=t[11];return t!==e&&(e[4]=t[4],e[5]=t[5],e[6]=t[6],e[7]=t[7],e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15]),e[0]=a*o-c*r,e[1]=i*o-u*r,e[2]=s*o-d*r,e[3]=l*o-p*r,e[8]=a*r+c*o,e[9]=i*r+u*o,e[10]=s*r+d*o,e[11]=l*r+p*o,e}function w(e,t,n){var r=Math.sin(n),o=Math.cos(n),a=t[0],i=t[1],s=t[2],l=t[3],c=t[4],u=t[5],d=t[6],p=t[7];return t!==e&&(e[8]=t[8],e[9]=t[9],e[10]=t[10],e[11]=t[11],e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15]),e[0]=a*o+c*r,e[1]=i*o+u*r,e[2]=s*o+d*r,e[3]=l*o+p*r,e[4]=c*o-a*r,e[5]=u*o-i*r,e[6]=d*o-s*r,e[7]=p*o-l*r,e}function O(e,t){return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=1,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=1,e[11]=0,e[12]=t[0],e[13]=t[1],e[14]=t[2],e[15]=1,e}function P(e,t){return e[0]=t[0],e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=t[1],e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=t[2],e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function R(e,t,n){var r,o,a,s=n[0],l=n[1],c=n[2],u=Math.hypot(s,l,c);return u<i?null:(s*=u=1/u,l*=u,c*=u,r=Math.sin(t),a=1-(o=Math.cos(t)),e[0]=s*s*a+o,e[1]=l*s*a+c*r,e[2]=c*s*a-l*r,e[3]=0,e[4]=s*l*a-c*r,e[5]=l*l*a+o,e[6]=c*l*a+s*r,e[7]=0,e[8]=s*c*a+l*r,e[9]=l*c*a-s*r,e[10]=c*c*a+o,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e)}function M(e,t){var n=Math.sin(t),r=Math.cos(t);return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=r,e[6]=n,e[7]=0,e[8]=0,e[9]=-n,e[10]=r,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function E(e,t){var n=Math.sin(t),r=Math.cos(t);return e[0]=r,e[1]=0,e[2]=-n,e[3]=0,e[4]=0,e[5]=1,e[6]=0,e[7]=0,e[8]=n,e[9]=0,e[10]=r,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function V(e,t){var n=Math.sin(t),r=Math.cos(t);return e[0]=r,e[1]=n,e[2]=0,e[3]=0,e[4]=-n,e[5]=r,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=1,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function D(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=r+r,l=o+o,c=a+a,u=r*s,d=r*l,p=r*c,f=o*l,g=o*c,m=a*c,h=i*s,v=i*l,T=i*c;return e[0]=1-(f+m),e[1]=d+T,e[2]=p-v,e[3]=0,e[4]=d-T,e[5]=1-(u+m),e[6]=g+h,e[7]=0,e[8]=p+v,e[9]=g-h,e[10]=1-(u+f),e[11]=0,e[12]=n[0],e[13]=n[1],e[14]=n[2],e[15]=1,e}function L(e,t){var n=new s(3),r=-t[0],o=-t[1],a=-t[2],i=t[3],l=t[4],c=t[5],u=t[6],d=t[7],p=r*r+o*o+a*a+i*i;return p>0?(n[0]=2*(l*i+d*r+c*a-u*o)/p,n[1]=2*(c*i+d*o+u*r-l*a)/p,n[2]=2*(u*i+d*a+l*o-c*r)/p):(n[0]=2*(l*i+d*r+c*a-u*o),n[1]=2*(c*i+d*o+u*r-l*a),n[2]=2*(u*i+d*a+l*o-c*r)),D(e,t,n),e}function B(e,t){return e[0]=t[12],e[1]=t[13],e[2]=t[14],e}function N(e,t){var n=t[0],r=t[1],o=t[2],a=t[4],i=t[5],s=t[6],l=t[8],c=t[9],u=t[10];return e[0]=Math.hypot(n,r,o),e[1]=Math.hypot(a,i,s),e[2]=Math.hypot(l,c,u),e}function F(e,t){var n=new s(3);N(n,t);var r=1/n[0],o=1/n[1],a=1/n[2],i=t[0]*r,l=t[1]*o,c=t[2]*a,u=t[4]*r,d=t[5]*o,p=t[6]*a,f=t[8]*r,g=t[9]*o,m=t[10]*a,h=i+d+m,v=0;return h>0?(v=2*Math.sqrt(h+1),e[3]=.25*v,e[0]=(p-g)/v,e[1]=(f-c)/v,e[2]=(l-u)/v):i>d&&i>m?(v=2*Math.sqrt(1+i-d-m),e[3]=(p-g)/v,e[0]=.25*v,e[1]=(l+u)/v,e[2]=(f+c)/v):d>m?(v=2*Math.sqrt(1+d-i-m),e[3]=(f-c)/v,e[0]=(l+u)/v,e[1]=.25*v,e[2]=(p+g)/v):(v=2*Math.sqrt(1+m-i-d),e[3]=(l-u)/v,e[0]=(f+c)/v,e[1]=(p+g)/v,e[2]=.25*v),e}function _(e,t,n,r){var o=t[0],a=t[1],i=t[2],s=t[3],l=o+o,c=a+a,u=i+i,d=o*l,p=o*c,f=o*u,g=a*c,m=a*u,h=i*u,v=s*l,T=s*c,y=s*u,b=r[0],x=r[1],C=r[2];return e[0]=(1-(g+h))*b,e[1]=(p+y)*b,e[2]=(f-T)*b,e[3]=0,e[4]=(p-y)*x,e[5]=(1-(d+h))*x,e[6]=(m+v)*x,e[7]=0,e[8]=(f+T)*C,e[9]=(m-v)*C,e[10]=(1-(d+g))*C,e[11]=0,e[12]=n[0],e[13]=n[1],e[14]=n[2],e[15]=1,e}function k(e,t,n,r,o){var a=t[0],i=t[1],s=t[2],l=t[3],c=a+a,u=i+i,d=s+s,p=a*c,f=a*u,g=a*d,m=i*u,h=i*d,v=s*d,T=l*c,y=l*u,b=l*d,x=r[0],C=r[1],S=r[2],A=o[0],I=o[1],w=o[2],O=(1-(m+v))*x,P=(f+b)*x,R=(g-y)*x,M=(f-b)*C,E=(1-(p+v))*C,V=(h+T)*C,D=(g+y)*S,L=(h-T)*S,B=(1-(p+m))*S;return e[0]=O,e[1]=P,e[2]=R,e[3]=0,e[4]=M,e[5]=E,e[6]=V,e[7]=0,e[8]=D,e[9]=L,e[10]=B,e[11]=0,e[12]=n[0]+A-(O*A+M*I+D*w),e[13]=n[1]+I-(P*A+E*I+L*w),e[14]=n[2]+w-(R*A+V*I+B*w),e[15]=1,e}function G(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=n+n,s=r+r,l=o+o,c=n*i,u=r*i,d=r*s,p=o*i,f=o*s,g=o*l,m=a*i,h=a*s,v=a*l;return e[0]=1-d-g,e[1]=u+v,e[2]=p-h,e[3]=0,e[4]=u-v,e[5]=1-c-g,e[6]=f+m,e[7]=0,e[8]=p+h,e[9]=f-m,e[10]=1-c-d,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e}function U(e,t,n,r,o,a,i){var s=1/(n-t),l=1/(o-r),c=1/(a-i);return e[0]=2*a*s,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=2*a*l,e[6]=0,e[7]=0,e[8]=(n+t)*s,e[9]=(o+r)*l,e[10]=(i+a)*c,e[11]=-1,e[12]=0,e[13]=0,e[14]=i*a*2*c,e[15]=0,e}function z(e,t,n,r,o){var a,i=1/Math.tan(t/2);return e[0]=i/n,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=i,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[11]=-1,e[12]=0,e[13]=0,e[15]=0,null!=o&&o!==1/0?(a=1/(r-o),e[10]=(o+r)*a,e[14]=2*o*r*a):(e[10]=-1,e[14]=-2*r),e}Math.hypot||(Math.hypot=function(){for(var e=0,t=arguments.length;t--;)e+=arguments[t]*arguments[t];return Math.sqrt(e)});var W=z;function H(e,t,n,r,o){var a,i=1/Math.tan(t/2);return e[0]=i/n,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=i,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[11]=-1,e[12]=0,e[13]=0,e[15]=0,null!=o&&o!==1/0?(a=1/(r-o),e[10]=o*a,e[14]=o*r*a):(e[10]=-1,e[14]=-r),e}function j(e,t,n,r){var o=Math.tan(t.upDegrees*Math.PI/180),a=Math.tan(t.downDegrees*Math.PI/180),i=Math.tan(t.leftDegrees*Math.PI/180),s=Math.tan(t.rightDegrees*Math.PI/180),l=2/(i+s),c=2/(o+a);return e[0]=l,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=c,e[6]=0,e[7]=0,e[8]=-(i-s)*l*.5,e[9]=(o-a)*c*.5,e[10]=r/(n-r),e[11]=-1,e[12]=0,e[13]=0,e[14]=r*n/(n-r),e[15]=0,e}function K(e,t,n,r,o,a,i){var s=1/(t-n),l=1/(r-o),c=1/(a-i);return e[0]=-2*s,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=-2*l,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=2*c,e[11]=0,e[12]=(t+n)*s,e[13]=(o+r)*l,e[14]=(i+a)*c,e[15]=1,e}var $=K;function q(e,t,n,r,o,a,i){var s=1/(t-n),l=1/(r-o),c=1/(a-i);return e[0]=-2*s,e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[5]=-2*l,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[10]=c,e[11]=0,e[12]=(t+n)*s,e[13]=(o+r)*l,e[14]=a*c,e[15]=1,e}function X(e,t,n,r){var o,a,s,l,c,u,d,p,f,g,h=t[0],v=t[1],T=t[2],y=r[0],b=r[1],x=r[2],C=n[0],S=n[1],A=n[2];return Math.abs(h-C)<i&&Math.abs(v-S)<i&&Math.abs(T-A)<i?m(e):(d=h-C,p=v-S,f=T-A,o=b*(f*=g=1/Math.hypot(d,p,f))-x*(p*=g),a=x*(d*=g)-y*f,s=y*p-b*d,(g=Math.hypot(o,a,s))?(o*=g=1/g,a*=g,s*=g):(o=0,a=0,s=0),l=p*s-f*a,c=f*o-d*s,u=d*a-p*o,(g=Math.hypot(l,c,u))?(l*=g=1/g,c*=g,u*=g):(l=0,c=0,u=0),e[0]=o,e[1]=l,e[2]=d,e[3]=0,e[4]=a,e[5]=c,e[6]=p,e[7]=0,e[8]=s,e[9]=u,e[10]=f,e[11]=0,e[12]=-(o*h+a*v+s*T),e[13]=-(l*h+c*v+u*T),e[14]=-(d*h+p*v+f*T),e[15]=1,e)}function Y(e,t,n,r){var o=t[0],a=t[1],i=t[2],s=r[0],l=r[1],c=r[2],u=o-n[0],d=a-n[1],p=i-n[2],f=u*u+d*d+p*p;f>0&&(u*=f=1/Math.sqrt(f),d*=f,p*=f);var g=l*p-c*d,m=c*u-s*p,h=s*d-l*u;return(f=g*g+m*m+h*h)>0&&(g*=f=1/Math.sqrt(f),m*=f,h*=f),e[0]=g,e[1]=m,e[2]=h,e[3]=0,e[4]=d*h-p*m,e[5]=p*g-u*h,e[6]=u*m-d*g,e[7]=0,e[8]=u,e[9]=d,e[10]=p,e[11]=0,e[12]=o,e[13]=a,e[14]=i,e[15]=1,e}function Z(e){return&quot;mat4(&quot;+e[0]+&quot;, &quot;+e[1]+&quot;, &quot;+e[2]+&quot;, &quot;+e[3]+&quot;, &quot;+e[4]+&quot;, &quot;+e[5]+&quot;, &quot;+e[6]+&quot;, &quot;+e[7]+&quot;, &quot;+e[8]+&quot;, &quot;+e[9]+&quot;, &quot;+e[10]+&quot;, &quot;+e[11]+&quot;, &quot;+e[12]+&quot;, &quot;+e[13]+&quot;, &quot;+e[14]+&quot;, &quot;+e[15]+&quot;)&quot;}function Q(e){return Math.hypot(e[0],e[1],e[2],e[3],e[4],e[5],e[6],e[7],e[8],e[9],e[10],e[11],e[12],e[13],e[14],e[15])}function J(e,t,n){return e[0]=t[0]+n[0],e[1]=t[1]+n[1],e[2]=t[2]+n[2],e[3]=t[3]+n[3],e[4]=t[4]+n[4],e[5]=t[5]+n[5],e[6]=t[6]+n[6],e[7]=t[7]+n[7],e[8]=t[8]+n[8],e[9]=t[9]+n[9],e[10]=t[10]+n[10],e[11]=t[11]+n[11],e[12]=t[12]+n[12],e[13]=t[13]+n[13],e[14]=t[14]+n[14],e[15]=t[15]+n[15],e}function ee(e,t,n){return e[0]=t[0]-n[0],e[1]=t[1]-n[1],e[2]=t[2]-n[2],e[3]=t[3]-n[3],e[4]=t[4]-n[4],e[5]=t[5]-n[5],e[6]=t[6]-n[6],e[7]=t[7]-n[7],e[8]=t[8]-n[8],e[9]=t[9]-n[9],e[10]=t[10]-n[10],e[11]=t[11]-n[11],e[12]=t[12]-n[12],e[13]=t[13]-n[13],e[14]=t[14]-n[14],e[15]=t[15]-n[15],e}function te(e,t,n){return e[0]=t[0]*n,e[1]=t[1]*n,e[2]=t[2]*n,e[3]=t[3]*n,e[4]=t[4]*n,e[5]=t[5]*n,e[6]=t[6]*n,e[7]=t[7]*n,e[8]=t[8]*n,e[9]=t[9]*n,e[10]=t[10]*n,e[11]=t[11]*n,e[12]=t[12]*n,e[13]=t[13]*n,e[14]=t[14]*n,e[15]=t[15]*n,e}function ne(e,t,n,r){return e[0]=t[0]+n[0]*r,e[1]=t[1]+n[1]*r,e[2]=t[2]+n[2]*r,e[3]=t[3]+n[3]*r,e[4]=t[4]+n[4]*r,e[5]=t[5]+n[5]*r,e[6]=t[6]+n[6]*r,e[7]=t[7]+n[7]*r,e[8]=t[8]+n[8]*r,e[9]=t[9]+n[9]*r,e[10]=t[10]+n[10]*r,e[11]=t[11]+n[11]*r,e[12]=t[12]+n[12]*r,e[13]=t[13]+n[13]*r,e[14]=t[14]+n[14]*r,e[15]=t[15]+n[15]*r,e}function re(e,t){return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]&&e[3]===t[3]&&e[4]===t[4]&&e[5]===t[5]&&e[6]===t[6]&&e[7]===t[7]&&e[8]===t[8]&&e[9]===t[9]&&e[10]===t[10]&&e[11]===t[11]&&e[12]===t[12]&&e[13]===t[13]&&e[14]===t[14]&&e[15]===t[15]}function oe(e,t){var n=e[0],r=e[1],o=e[2],a=e[3],s=e[4],l=e[5],c=e[6],u=e[7],d=e[8],p=e[9],f=e[10],g=e[11],m=e[12],h=e[13],v=e[14],T=e[15],y=t[0],b=t[1],x=t[2],C=t[3],S=t[4],A=t[5],I=t[6],w=t[7],O=t[8],P=t[9],R=t[10],M=t[11],E=t[12],V=t[13],D=t[14],L=t[15];return Math.abs(n-y)<=i*Math.max(1,Math.abs(n),Math.abs(y))&&Math.abs(r-b)<=i*Math.max(1,Math.abs(r),Math.abs(b))&&Math.abs(o-x)<=i*Math.max(1,Math.abs(o),Math.abs(x))&&Math.abs(a-C)<=i*Math.max(1,Math.abs(a),Math.abs(C))&&Math.abs(s-S)<=i*Math.max(1,Math.abs(s),Math.abs(S))&&Math.abs(l-A)<=i*Math.max(1,Math.abs(l),Math.abs(A))&&Math.abs(c-I)<=i*Math.max(1,Math.abs(c),Math.abs(I))&&Math.abs(u-w)<=i*Math.max(1,Math.abs(u),Math.abs(w))&&Math.abs(d-O)<=i*Math.max(1,Math.abs(d),Math.abs(O))&&Math.abs(p-P)<=i*Math.max(1,Math.abs(p),Math.abs(P))&&Math.abs(f-R)<=i*Math.max(1,Math.abs(f),Math.abs(R))&&Math.abs(g-M)<=i*Math.max(1,Math.abs(g),Math.abs(M))&&Math.abs(m-E)<=i*Math.max(1,Math.abs(m),Math.abs(E))&&Math.abs(h-V)<=i*Math.max(1,Math.abs(h),Math.abs(V))&&Math.abs(v-D)<=i*Math.max(1,Math.abs(v),Math.abs(D))&&Math.abs(T-L)<=i*Math.max(1,Math.abs(T),Math.abs(L))}var ae=b,ie=ee;function se(){var e=new s(9);return s!=Float32Array&&(e[1]=0,e[2]=0,e[3]=0,e[5]=0,e[6]=0,e[7]=0),e[0]=1,e[4]=1,e[8]=1,e}function le(e,t){return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[4],e[4]=t[5],e[5]=t[6],e[6]=t[8],e[7]=t[9],e[8]=t[10],e}function ce(e){var t=new s(9);return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t[4]=e[4],t[5]=e[5],t[6]=e[6],t[7]=e[7],t[8]=e[8],t}function ue(e,t){return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[4]=t[4],e[5]=t[5],e[6]=t[6],e[7]=t[7],e[8]=t[8],e}function de(e,t,n,r,o,a,i,l,c){var u=new s(9);return u[0]=e,u[1]=t,u[2]=n,u[3]=r,u[4]=o,u[5]=a,u[6]=i,u[7]=l,u[8]=c,u}function pe(e,t,n,r,o,a,i,s,l,c){return e[0]=t,e[1]=n,e[2]=r,e[3]=o,e[4]=a,e[5]=i,e[6]=s,e[7]=l,e[8]=c,e}function fe(e){return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=1,e[5]=0,e[6]=0,e[7]=0,e[8]=1,e}function ge(e,t){if(e===t){var n=t[1],r=t[2],o=t[5];e[1]=t[3],e[2]=t[6],e[3]=n,e[5]=t[7],e[6]=r,e[7]=o}else e[0]=t[0],e[1]=t[3],e[2]=t[6],e[3]=t[1],e[4]=t[4],e[5]=t[7],e[6]=t[2],e[7]=t[5],e[8]=t[8];return e}function me(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8],d=u*i-s*c,p=-u*a+s*l,f=c*a-i*l,g=n*d+r*p+o*f;return g?(g=1/g,e[0]=d*g,e[1]=(-u*r+o*c)*g,e[2]=(s*r-o*i)*g,e[3]=p*g,e[4]=(u*n-o*l)*g,e[5]=(-s*n+o*a)*g,e[6]=f*g,e[7]=(-c*n+r*l)*g,e[8]=(i*n-r*a)*g,e):null}function he(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8];return e[0]=i*u-s*c,e[1]=o*c-r*u,e[2]=r*s-o*i,e[3]=s*l-a*u,e[4]=n*u-o*l,e[5]=o*a-n*s,e[6]=a*c-i*l,e[7]=r*l-n*c,e[8]=n*i-r*a,e}function ve(e){var t=e[0],n=e[1],r=e[2],o=e[3],a=e[4],i=e[5],s=e[6],l=e[7],c=e[8];return t*(c*a-i*l)+n*(-c*o+i*s)+r*(l*o-a*s)}function Te(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=n[0],f=n[1],g=n[2],m=n[3],h=n[4],v=n[5],T=n[6],y=n[7],b=n[8];return e[0]=p*r+f*i+g*c,e[1]=p*o+f*s+g*u,e[2]=p*a+f*l+g*d,e[3]=m*r+h*i+v*c,e[4]=m*o+h*s+v*u,e[5]=m*a+h*l+v*d,e[6]=T*r+y*i+b*c,e[7]=T*o+y*s+b*u,e[8]=T*a+y*l+b*d,e}function ye(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=n[0],f=n[1];return e[0]=r,e[1]=o,e[2]=a,e[3]=i,e[4]=s,e[5]=l,e[6]=p*r+f*i+c,e[7]=p*o+f*s+u,e[8]=p*a+f*l+d,e}function be(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=t[4],l=t[5],c=t[6],u=t[7],d=t[8],p=Math.sin(n),f=Math.cos(n);return e[0]=f*r+p*i,e[1]=f*o+p*s,e[2]=f*a+p*l,e[3]=f*i-p*r,e[4]=f*s-p*o,e[5]=f*l-p*a,e[6]=c,e[7]=u,e[8]=d,e}function xe(e,t,n){var r=n[0],o=n[1];return e[0]=r*t[0],e[1]=r*t[1],e[2]=r*t[2],e[3]=o*t[3],e[4]=o*t[4],e[5]=o*t[5],e[6]=t[6],e[7]=t[7],e[8]=t[8],e}function Ce(e,t){return e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=1,e[5]=0,e[6]=t[0],e[7]=t[1],e[8]=1,e}function Se(e,t){var n=Math.sin(t),r=Math.cos(t);return e[0]=r,e[1]=n,e[2]=0,e[3]=-n,e[4]=r,e[5]=0,e[6]=0,e[7]=0,e[8]=1,e}function Ae(e,t){return e[0]=t[0],e[1]=0,e[2]=0,e[3]=0,e[4]=t[1],e[5]=0,e[6]=0,e[7]=0,e[8]=1,e}function Ie(e,t){return e[0]=t[0],e[1]=t[1],e[2]=0,e[3]=t[2],e[4]=t[3],e[5]=0,e[6]=t[4],e[7]=t[5],e[8]=1,e}function we(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=n+n,s=r+r,l=o+o,c=n*i,u=r*i,d=r*s,p=o*i,f=o*s,g=o*l,m=a*i,h=a*s,v=a*l;return e[0]=1-d-g,e[3]=u-v,e[6]=p+h,e[1]=u+v,e[4]=1-c-g,e[7]=f-m,e[2]=p-h,e[5]=f+m,e[8]=1-c-d,e}function Oe(e,t){var n=t[0],r=t[1],o=t[2],a=t[3],i=t[4],s=t[5],l=t[6],c=t[7],u=t[8],d=t[9],p=t[10],f=t[11],g=t[12],m=t[13],h=t[14],v=t[15],T=n*s-r*i,y=n*l-o*i,b=n*c-a*i,x=r*l-o*s,C=r*c-a*s,S=o*c-a*l,A=u*m-d*g,I=u*h-p*g,w=u*v-f*g,O=d*h-p*m,P=d*v-f*m,R=p*v-f*h,M=T*R-y*P+b*O+x*w-C*I+S*A;return M?(M=1/M,e[0]=(s*R-l*P+c*O)*M,e[1]=(l*w-i*R-c*I)*M,e[2]=(i*P-s*w+c*A)*M,e[3]=(o*P-r*R-a*O)*M,e[4]=(n*R-o*w+a*I)*M,e[5]=(r*w-n*P-a*A)*M,e[6]=(m*S-h*C+v*x)*M,e[7]=(h*b-g*S-v*y)*M,e[8]=(g*C-m*b+v*T)*M,e):null}function Pe(e,t,n){return e[0]=2/t,e[1]=0,e[2]=0,e[3]=0,e[4]=-2/n,e[5]=0,e[6]=-1,e[7]=1,e[8]=1,e}function Re(e){return&quot;mat3(&quot;+e[0]+&quot;, &quot;+e[1]+&quot;, &quot;+e[2]+&quot;, &quot;+e[3]+&quot;, &quot;+e[4]+&quot;, &quot;+e[5]+&quot;, &quot;+e[6]+&quot;, &quot;+e[7]+&quot;, &quot;+e[8]+&quot;)&quot;}function Me(e){return Math.hypot(e[0],e[1],e[2],e[3],e[4],e[5],e[6],e[7],e[8])}function Ee(e,t,n){return e[0]=t[0]+n[0],e[1]=t[1]+n[1],e[2]=t[2]+n[2],e[3]=t[3]+n[3],e[4]=t[4]+n[4],e[5]=t[5]+n[5],e[6]=t[6]+n[6],e[7]=t[7]+n[7],e[8]=t[8]+n[8],e}function Ve(e,t,n){return e[0]=t[0]-n[0],e[1]=t[1]-n[1],e[2]=t[2]-n[2],e[3]=t[3]-n[3],e[4]=t[4]-n[4],e[5]=t[5]-n[5],e[6]=t[6]-n[6],e[7]=t[7]-n[7],e[8]=t[8]-n[8],e}function De(e,t,n){return e[0]=t[0]*n,e[1]=t[1]*n,e[2]=t[2]*n,e[3]=t[3]*n,e[4]=t[4]*n,e[5]=t[5]*n,e[6]=t[6]*n,e[7]=t[7]*n,e[8]=t[8]*n,e}function Le(e,t,n,r){return e[0]=t[0]+n[0]*r,e[1]=t[1]+n[1]*r,e[2]=t[2]+n[2]*r,e[3]=t[3]+n[3]*r,e[4]=t[4]+n[4]*r,e[5]=t[5]+n[5]*r,e[6]=t[6]+n[6]*r,e[7]=t[7]+n[7]*r,e[8]=t[8]+n[8]*r,e}function Be(e,t){return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]&&e[3]===t[3]&&e[4]===t[4]&&e[5]===t[5]&&e[6]===t[6]&&e[7]===t[7]&&e[8]===t[8]}function Ne(e,t){var n=e[0],r=e[1],o=e[2],a=e[3],s=e[4],l=e[5],c=e[6],u=e[7],d=e[8],p=t[0],f=t[1],g=t[2],m=t[3],h=t[4],v=t[5],T=t[6],y=t[7],b=t[8];return Math.abs(n-p)<=i*Math.max(1,Math.abs(n),Math.abs(p))&&Math.abs(r-f)<=i*Math.max(1,Math.abs(r),Math.abs(f))&&Math.abs(o-g)<=i*Math.max(1,Math.abs(o),Math.abs(g))&&Math.abs(a-m)<=i*Math.max(1,Math.abs(a),Math.abs(m))&&Math.abs(s-h)<=i*Math.max(1,Math.abs(s),Math.abs(h))&&Math.abs(l-v)<=i*Math.max(1,Math.abs(l),Math.abs(v))&&Math.abs(c-T)<=i*Math.max(1,Math.abs(c),Math.abs(T))&&Math.abs(u-y)<=i*Math.max(1,Math.abs(u),Math.abs(y))&&Math.abs(d-b)<=i*Math.max(1,Math.abs(d),Math.abs(b))}var Fe=Te,_e=Ve,ke=n(730);const Ge=n(59)(),Ue={vtkObject:()=>null};function ze(e){if(null==e)return e;if(e.isA)return e;if(!e.vtkClass)return Ge.console&&Ge.console.error&&Ge.console.error(&quot;Invalid VTK object&quot;),null;const t=Ue[e.vtkClass];if(!t)return Ge.console&&Ge.console.error&&Ge.console.error(`No vtk class found for Object of type ${e.vtkClass}`),null;const n={...e};Object.keys(n).forEach((e=>{n[e]&&&quot;object&quot;==typeof n[e]&&n[e].vtkClass&&(n[e]=ze(n[e]))}));const r=t(n);return r&&r.modified&&r.modified(),r}ze.register=function(e,t){Ue[e]=t};class We extends Array{push(){for(let e=0;e<arguments.length;e++)this.includes(arguments[e])||super.push(arguments[e]);return this.length}}let He=0;const je=e=>{throw new Error(`Named parameter '${e}' is missing`)},Ke=Symbol(&quot;void&quot;),$e={};function qe(){}[&quot;log&quot;,&quot;debug&quot;,&quot;info&quot;,&quot;warn&quot;,&quot;error&quot;,&quot;time&quot;,&quot;timeEnd&quot;,&quot;group&quot;,&quot;groupEnd&quot;].forEach((e=>{$e[e]=qe})),Ge.console=console.hasOwnProperty(&quot;log&quot;)?console:$e;const Xe={debug:qe,error:Ge.console.error||qe,info:Ge.console.info||qe,log:Ge.console.log||qe,warn:Ge.console.warn||qe};function Ye(e,t){Xe[e]&&(Xe[e]=t||qe)}function Ze(){Xe.log(...arguments)}function Qe(){Xe.info(...arguments)}function Je(){Xe.debug(...arguments)}function et(){Xe.error(...arguments)}function tt(){Xe.warn(...arguments)}const nt={};function rt(e){nt[e]||(Xe.error(e),nt[e]=!0)}const ot=Object.create(null);ot.Float32Array=Float32Array,ot.Float64Array=Float64Array,ot.Uint8Array=Uint8Array,ot.Int8Array=Int8Array,ot.Uint16Array=Uint16Array,ot.Int16Array=Int16Array,ot.Uint32Array=Uint32Array,ot.Int32Array=Int32Array,ot.Uint8ClampedArray=Uint8ClampedArray;try{ot.BigInt64Array=BigInt64Array,ot.BigUint64Array=BigUint64Array}catch{}function at(e){for(var t=arguments.length,n=new Array(t>1?t-1:0),r=1;r<t;r++)n[r-1]=arguments[r];return new(ot[e]||Float64Array)(...n)}function it(e){for(var t=arguments.length,n=new Array(t>1?t-1:0),r=1;r<t;r++)n[r-1]=arguments[r];return(ot[e]||Float64Array).from(...n)}function st(e){return e.charAt(0).toUpperCase()+e.slice(1)}function lt(e){return st(&quot;_&quot;===e[0]?e.slice(1):e)}function ct(e){return e.charAt(0).toLowerCase()+e.slice(1)}function ut(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:2,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1e3;const r=[&quot;TB&quot;,&quot;GB&quot;,&quot;MB&quot;,&quot;KB&quot;];let o=Number(e),a=&quot;B&quot;;for(;o>n;)o/=n,a=r.pop();return`${o.toFixed(t)} ${a}`}function dt(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:&quot; &quot;;const n=[];let r=e;for(;r>1e3;)n.push((&quot;000&quot;+r%1e3).slice(-3)),r=Math.floor(r/1e3);return r>0&&n.push(r),n.reverse(),n.join(t)}function pt(e){Object.keys(e).forEach((t=>{Array.isArray(e[t])&&(e[t]=[].concat(e[t]))}))}function ft(e){return e&&e.isA?e.getState():e}function gt(e){setTimeout(e,0)}function mt(e,t){const n=performance.now();e.finally((()=>{const e=performance.now()-n;t(e)}))}function ht(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};pt(t);const n=[];if(Number.isInteger(t.mtime)||(t.mtime=++He),&quot;classHierarchy&quot;in t){if(!(t.classHierarchy instanceof We)){const e=new We;for(let n=0;n<t.classHierarchy.length;n++)e.push(t.classHierarchy[n]);t.classHierarchy=e}}else t.classHierarchy=new We(&quot;vtkObject&quot;);function r(e){n[e]=null}return e.isDeleted=()=>!!t.deleted,e.modified=r=>{t.deleted?et(&quot;instance deleted - cannot call any method&quot;):r&&r<e.getMTime()||(t.mtime=++He,n.forEach((t=>t&&t(e))))},e.onModified=e=>{if(t.deleted)return et(&quot;instance deleted - cannot call any method&quot;),null;const o=n.length;return n.push(e),function(e){return Object.freeze({unsubscribe:function(){r(e)}})}(o)},e.getMTime=()=>t.mtime,e.isA=e=>{let n=t.classHierarchy.length;for(;n--;)if(t.classHierarchy[n]===e)return!0;return!1},e.getClassName=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.classHierarchy[t.classHierarchy.length-1-e]},e.set=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1&&void 0!==arguments[1]&&arguments[1],o=arguments.length>2&&void 0!==arguments[2]&&arguments[2],a=!1;return Object.keys(n).forEach((i=>{const s=o?null:e[`set${st(i)}`];s&&Array.isArray(n[i])&&s.length>1?a=s(...n[i])||a:s?a=s(n[i])||a:(-1!==[&quot;mtime&quot;].indexOf(i)||r||tt(`Warning: Set value to model directly ${i}, ${n[i]}`),a=t[i]!==n[i]||a,t[i]=n[i])})),a},e.get=function(){for(var e=arguments.length,n=new Array(e),r=0;r<e;r++)n[r]=arguments[r];if(!n.length)return t;const o={};return n.forEach((e=>{o[e]=t[e]})),o},e.getReferenceByName=e=>t[e],e.delete=()=>{Object.keys(t).forEach((e=>delete t[e])),n.forEach(((e,t)=>r(t))),t.deleted=!0},e.getState=()=>{if(t.deleted)return null;const n={...t,vtkClass:e.getClassName()};Object.keys(n).forEach((e=>{null===n[e]||void 0===n[e]||&quot;_&quot;===e[0]?delete n[e]:n[e].isA?n[e]=n[e].getState():Array.isArray(n[e])?n[e]=n[e].map(ft):function(e){return Object.values(ot).some((t=>e instanceof t))}(n[e])&&(n[e]=Array.from(n[e]))}));const r={};return Object.keys(n).sort().forEach((e=>{r[e]=n[e]})),r.mtime&&delete r.mtime,r},e.shallowCopy=function(n){let r=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(n.getClassName()!==e.getClassName())throw new Error(`Cannot ShallowCopy ${n.getClassName()} into ${e.getClassName()}`);const o=n.get(),a=Object.keys(t).sort();Object.keys(o).sort().forEach((e=>{const n=a.indexOf(e);-1===n?r&&Je(`add ${e} in shallowCopy`):a.splice(n,1),t[e]=o[e]})),a.length&&r&&Je(`Untouched keys: ${a.join(&quot;, &quot;)}`),e.modified()},e.toJSON=function(){return e.getState()},e}const vt={object(e,t,n){return function(){return{...t[n.name]}}}};function Tt(e,t,n){n.forEach((n=>{if(&quot;object&quot;==typeof n){const r=vt[n.type];e[`get${lt(n.name)}`]=r?r(e,t,n):()=>t[n.name]}else e[`get${lt(n)}`]=()=>t[n]}))}const yt={enum(e,t,n){const r=`_on${lt(n.name)}Changed`;return o=>{if(&quot;string&quot;==typeof o){if(void 0!==n.enum[o])return t[n.name]!==n.enum[o]&&(t[n.name]=n.enum[o],e.modified(),!0);throw et(`Set Enum with invalid argument ${n}, ${o}`),new RangeError(&quot;Set Enum with invalid string argument&quot;)}if(&quot;number&quot;==typeof o){if(t[n.name]!==o){if(-1!==Object.keys(n.enum).map((e=>n.enum[e])).indexOf(o)){const a=t[n.name];return t[n.name]=o,t[r]?.(e,t,o,a),e.modified(),!0}throw et(`Set Enum outside numeric range ${n}, ${o}`),new RangeError(&quot;Set Enum outside numeric range&quot;)}return!1}throw et(`Set Enum with invalid argument (String/Number) ${n}, ${o}`),new TypeError(&quot;Set Enum with invalid argument (String/Number)&quot;)}},object(e,t,n){1===n.params?.length&&tt('Setter of type &quot;object&quot; with a single &quot;param&quot; field is not supported');const r=`_on${lt(n.name)}Changed`;return function(){for(var o=arguments.length,a=new Array(o),i=0;i<o;i++)a[i]=arguments[i];let s;if(s=a.length>1&&n.params?.length?n.params.reduce(((e,t,n)=>Object.assign(e,{[t]:a[n]})),{}):a[0],!ke(t[n.name],s)){const o=t[n.name];return t[n.name]=s,t[r]?.(e,t,s,o),e.modified(),!0}return!1}}};function bt(e){if(&quot;object&quot;==typeof e){const t=yt[e.type];if(t)return(n,r)=>t(n,r,e);throw et(`No setter for field ${e}`),new TypeError(&quot;No setter for field&quot;)}return function(t,n){const r=`_on${lt(e)}Changed`;return function(o){if(n.deleted)return et(&quot;instance deleted - cannot call any method&quot;),!1;if(n[e]!==o){const a=n[e.name];return n[e]=o,n[r]?.(t,n,o,a),t.modified(),!0}return!1}}}function xt(e,t,n){n.forEach((n=>{&quot;object&quot;==typeof n?e[`set${lt(n.name)}`]=bt(n)(e,t):e[`set${lt(n)}`]=bt(n)(e,t)}))}function Ct(e,t,n){Tt(e,t,n),xt(e,t,n)}function St(e,t,n){n.forEach((n=>{e[`get${lt(n)}`]=()=>t[n]?Array.from(t[n]):t[n],e[`get${lt(n)}ByReference`]=()=>t[n]}))}function At(e,t,n,r){let o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:void 0;n.forEach((n=>{if(t[n]&&r&&t[n].length!==r)throw new RangeError(`Invalid initial number of values for array (${n})`);const a=`_on${lt(n)}Changed`;e[`set${lt(n)}`]=function(){if(t.deleted)return et(&quot;instance deleted - cannot call any method&quot;),!1;for(var i=arguments.length,s=new Array(i),l=0;l<i;l++)s[l]=arguments[l];let c,u=s,d=!1;if(1===u.length&&(null==u[0]||u[0].length>=0)&&(u=u[0],d=!0),null==u)c=t[n]!==u;else{if(r&&u.length!==r){if(!(u.length<r&&void 0!==o))throw new RangeError(`Invalid number of values for array setter (${n})`);for(u=Array.from(u),d=!1;u.length<r;)u.push(o)}c=null==t[n]||t[n].length!==u.length;for(let e=0;!c&&e<u.length;++e)c=t[n][e]!==u[e];c&&d&&(u=Array.from(u))}if(c){const r=t[n.name];t[n]=u,t[a]?.(e,t,u,r),e.modified()}return c},e[`set${lt(n)}From`]=e=>{const r=t[n];e.forEach(((e,t)=>{r[t]=e}))}}))}function It(e,t,n,r){let o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:void 0;St(e,t,n),At(e,t,n,r,o)}function wt(e,t,n){for(let e=0;e<n.length;e++){const r=n[e];void 0!==t[r]&&(t[`_${r}`]=t[r],delete t[r])}}function Ot(e,t,n,r){function o(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;t.deleted?et(&quot;instance deleted - cannot call any method&quot;):r>=t.numberOfInputs?et(`algorithm ${e.getClassName()} only has ${t.numberOfInputs} input ports. To add more input ports, use addInputData()`):(t.inputData[r]!==n||t.inputConnection[r])&&(t.inputData[r]=n,t.inputConnection[r]=null,e.modified&&e.modified())}function a(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;if(t.deleted)et(&quot;instance deleted - cannot call any method&quot;);else{if(r>=t.numberOfInputs){let n=`algorithm ${e.getClassName()} only has `;return n+=`${t.numberOfInputs}`,n+=&quot; input ports. To add more input ports, use addInputConnection()&quot;,void et(n)}t.inputData[r]=null,t.inputConnection[r]=n}}function i(){let e=t.numberOfInputs;for(;e&&!t.inputData[e-1]&&!t.inputConnection[e-1];)e--;return e===t.numberOfInputs&&t.numberOfInputs++,e}function s(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.deleted?(et(&quot;instance deleted - cannot call any method&quot;),null):(e.shouldUpdate()&&e.update(),t.output[n])}if(t.inputData?t.inputData=t.inputData.map(ze):t.inputData=[],t.inputConnection?t.inputConnection=t.inputConnection.map(ze):t.inputConnection=[],t.output?t.output=t.output.map(ze):t.output=[],t.inputArrayToProcess?t.inputArrayToProcess=t.inputArrayToProcess.map(ze):t.inputArrayToProcess=[],t.numberOfInputs=n,e.shouldUpdate=()=>{const n=e.getMTime();let o=1/0,a=r;for(;a--;){if(!t.output[a]||t.output[a].isDeleted())return!0;const e=t.output[a].getMTime();if(e<n)return!0;e<o&&(o=e)}for(a=t.numberOfInputs;a--;)if(t.inputConnection[a]?.filter.shouldUpdate()||e.getInputData(a)?.getMTime()>o)return!0;return!1},t.numberOfInputs){let n=t.numberOfInputs;for(;n--;)t.inputData.push(null),t.inputConnection.push(null);e.setInputData=o,e.setInputConnection=a,e.addInputData=function(e){t.deleted?et(&quot;instance deleted - cannot call any method&quot;):o(e,i())},e.addInputConnection=function(e){t.deleted?et(&quot;instance deleted - cannot call any method&quot;):a(e,i())},e.getInputData=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.inputConnection[e]&&(t.inputData[e]=t.inputConnection[e]()),t.inputData[e]},e.getInputConnection=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.inputConnection[e]}}r&&(e.getOutputData=s,e.getOutputPort=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;const n=()=>s(t);return n.filter=e,n}),e.update=()=>{const n=[];if(t.numberOfInputs){let r=0;for(;r<t.numberOfInputs;)n[r]=e.getInputData(r),r++}e.requestData&&!e.isDeleted()&&e.shouldUpdate()&&e.requestData(n,t.output)},e.getNumberOfInputPorts=()=>t.numberOfInputs,e.getNumberOfOutputPorts=()=>r||t.output.length,e.getInputArrayToProcess=e=>{const n=t.inputArrayToProcess[e],r=t.inputData[e];return n&&r?r[`get${n.fieldAssociation}`]().getArray(n.arrayName):null},e.setInputArrayToProcess=function(e,n,r){let o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:&quot;Scalars&quot;;for(;t.inputArrayToProcess.length<e;)t.inputArrayToProcess.push(null);t.inputArrayToProcess[e]={arrayName:n,fieldAssociation:r,attributeType:o}}}const Pt=Symbol(&quot;Event abort&quot;);function Rt(e,t,n){const r=[],o=e.delete;let a=1;function i(e){for(let t=0;t<r.length;++t){const[n]=r[t];if(n===e)return void r.splice(t,1)}}e[`invoke${lt(n)}`]=function(){if(t.deleted)return void et(&quot;instance deleted - cannot call any method&quot;);const n=r.slice();for(let t=0;t<n.length;++t){const[,r,o]=n[t];if(r)if(o<0)setTimeout((()=>r.apply(e,arguments)),1-o);else if(r.apply(e,arguments)===Pt)break}},e[`on${lt(n)}`]=function(e){let o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;if(!e.apply)return console.error(`Invalid callback for event ${n}`),null;if(t.deleted)return et(&quot;instance deleted - cannot call any method&quot;),null;const s=a++;return r.push([s,e,o]),r.sort(((e,t)=>t[2]-e[2])),function(e){return Object.freeze({unsubscribe:function(){i(e)}})}(s)},e.delete=()=>{o(),r.forEach((e=>{let[t]=e;return i(t)}))}}function Mt(e,t){const n=function(){const t={};return e(t,{},arguments.length>0&&void 0!==arguments[0]?arguments[0]:{}),Object.freeze(t)};return t&&ze.register(t,n),n}function Et(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return function(){for(var e=arguments.length,n=new Array(e),r=0;r<e;r++)n[r]=arguments[r];return t.filter((e=>!!e)).map((e=>e(...n)))}}function Vt(e){return e&&e.isA&&e.isA(&quot;vtkObject&quot;)}function Dt(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[],r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[];if(Vt(e)){if(r.indexOf(e)>=0)return n;r.push(e);const o=t(e);void 0!==o&&n.push(o);const a=e.get();Object.keys(a).forEach((e=>{const o=a[e];Array.isArray(o)?o.forEach((e=>{Dt(e,t,n,r)})):Dt(o,t,n,r)}))}return n}function Lt(e,t,n){var r=this;let o;const a=function(){for(var a=arguments.length,i=new Array(a),s=0;s<a;s++)i[s]=arguments[s];const l=r,c=n&&!o;clearTimeout(o),o=setTimeout((()=>{o=null,n||e.apply(l,i)}),t),c&&e.apply(l,i)};return a.cancel=()=>clearTimeout(o),a}function Bt(e,t){let n=!1,r=null;function o(){n=!1,null!==r&&(a(...r),r=null)}function a(){for(var a=arguments.length,i=new Array(a),s=0;s<a;s++)i[s]=arguments[s];n?r=i:(n=!0,e(...i),setTimeout(o,t))}return a}function Nt(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};t.keystore=Object.assign(t.keystore||{},n),e.setKey=(e,n)=>{t.keystore[e]=n},e.getKey=e=>t.keystore[e],e.getAllKeys=()=>Object.keys(t.keystore),e.deleteKey=e=>delete t.keystore[e],e.clearKeystore=()=>e.getAllKeys().forEach((e=>delete t.keystore[e]))}let Ft=1;const _t=&quot;__root__&quot;;function kt(e,t){Nt(e,t);const n=e.delete;t.proxyId=&quot;&quot;+Ft++,t.ui=JSON.parse(JSON.stringify(t.ui||[])),Tt(e,t,[&quot;proxyId&quot;,&quot;proxyGroup&quot;,&quot;proxyName&quot;]),Ct(e,t,[&quot;proxyManager&quot;]);const r={},o={};function a(e,t){o[t]||(o[t]=[]);const n=o[t];for(let t=0;t<e.length;t++)n.push(e[t].name),r[e[t].name]=e[t],e[t].children&&e[t].children.length&&a(e[t].children,e[t].name)}function i(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:_t;const r=[],a=t.proxyId,s=function(){return o[arguments.length>0&&void 0!==arguments[0]?arguments[0]:_t]}(n)||[];for(let t=0;t<s.length;t++){const n=s[t],o=e[`get${lt(n)}`],l={id:a,name:n,value:o?o():void 0},c=i(n);c.length&&(l.children=c),r.push(l)}return r}a(t.ui,_t),e.updateUI=n=>{t.ui=JSON.parse(JSON.stringify(n||[])),Object.keys(r).forEach((e=>delete r[e])),Object.keys(o).forEach((e=>delete o[e])),a(t.ui,_t),e.modified()},e.updateProxyProperty=(e,t)=>{const n=r[e];n?Object.assign(n,t):r[e]={...t}},e.activate=()=>{if(t.proxyManager){const n=`setActive${lt(e.getProxyGroup().slice(0,-1))}`;t.proxyManager[n]&&t.proxyManager[n](e)}},t.propertyLinkSubscribers={},e.registerPropertyLinkForGC=(e,n)=>{n in t.propertyLinkSubscribers||(t.propertyLinkSubscribers[n]=[]),t.propertyLinkSubscribers[n].push(e)},e.gcPropertyLinks=n=>{const r=t.propertyLinkSubscribers[n]||[];for(;r.length;)r.pop().unbind(e)},t.propertyLinkMap={},e.getPropertyLink=function(e){let n=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(t.propertyLinkMap[e])return t.propertyLinkMap[e];let r=null;const o=[];let a=0,i=!1;function s(n){let s=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(i)return null;const l=[];let c=null;for(a=o.length;a--;){const e=o[a];e.instance===n?c=e:l.push(e)}if(!c)return null;const u=c.instance[`get${lt(c.propertyName)}`]();if(!function(e,t){if(e===t)return!0;if(Array.isArray(e)&&Array.isArray(t)){if(e.length!==t.length)return!1;for(let n=0;n<e.length;n++)if(e[n]!==t[n])return!1;return!0}return!1}(u,r)||s){for(r=u,i=!0;l.length;){const e=l.pop();e.instance.set({[e.propertyName]:r})}i=!1}return t.propertyLinkMap[e].persistent&&(t.propertyLinkMap[e].value=u),u}function l(e,t){const n=[];for(a=o.length;a--;){const r=o[a];r.instance!==e||r.propertyName!==t&&void 0!==t||(r.subscription.unsubscribe(),n.push(a))}for(;n.length;)o.splice(n.pop(),1)}const c={bind:function(n,r){let a=arguments.length>2&&void 0!==arguments[2]&&arguments[2];const i=n.onModified(s),c=o[0];return o.push({instance:n,propertyName:r,subscription:i}),a&&(t.propertyLinkMap[e].persistent&&void 0!==t.propertyLinkMap[e].value?n.set({[r]:t.propertyLinkMap[e].value}):c&&s(c.instance,!0)),{unsubscribe:()=>l(n,r)}},unbind:l,unsubscribe:function(){for(;o.length;)o.pop().subscription.unsubscribe()},persistent:n};return t.propertyLinkMap[e]=c,c},e.listPropertyNames=()=>i().map((e=>e.name)),e.getPropertyByName=e=>i().find((t=>t.name===e)),e.getPropertyDomainByName=e=>(r[e]||{}).domain,e.getProxySection=()=>({id:t.proxyId,name:t.proxyGroup,ui:t.ui,properties:i()}),e.delete=()=>{const r=Object.keys(t.propertyLinkMap);let o=r.length;for(;o--;)t.propertyLinkMap[r[o]].unsubscribe();Object.keys(t.propertyLinkSubscribers).forEach(e.gcPropertyLinks),n()},e.getState=()=>null,gt((function(){if(t.links)for(let n=0;n<t.links.length;n++){const{link:r,property:o,persistent:a,updateOnBind:i,type:s}=t.links[n];if(&quot;application&quot;===s){const n=t.proxyManager.getPropertyLink(r,a);e.registerPropertyLinkForGC(n,&quot;application&quot;),n.bind(e,o,i)}}}))}function Gt(e,t,n){const r=e.delete,o=[],a=Object.keys(n);let i=a.length;for(;i--;){const r=a[i],{modelKey:s,property:l,modified:c=!0}=n[r],u=lt(l),d=lt(r);e[`get${d}`]=t[s][`get${u}`],e[`set${d}`]=t[s][`set${u}`],c&&o.push(t[s].onModified(e.modified))}e.delete=()=>{for(;o.length;)o.pop().unsubscribe();r()}}function Ut(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};function o(e){const n=Object.keys(e);let r=n.length;for(;r--;){const o=n[r];t[o].set(e[o])}}t.this=e;const a=Object.keys(r);let i=a.length;for(;i--;){const s=a[i];t[s]=r[s];const l=n[s];e[`set${lt(s)}`]=n=>{n!==t[s]&&(t[s]=n,o(l[n]),e.modified())}}a.length&&Tt(e,t,a)}function zt(e){let t=0,n=0,r=0,o=0;return&quot;detail&quot;in e&&(n=e.detail),&quot;wheelDelta&quot;in e&&(n=-e.wheelDelta/120),&quot;wheelDeltaY&quot;in e&&(n=-e.wheelDeltaY/120),&quot;wheelDeltaX&quot;in e&&(t=-e.wheelDeltaX/120),&quot;axis&quot;in e&&e.axis===e.HORIZONTAL_AXIS&&(t=n,n=0),r=10*t,o=10*n,&quot;deltaY&quot;in e&&(o=e.deltaY),&quot;deltaX&quot;in e&&(r=e.deltaX),(r||o)&&e.deltaMode&&(1===e.deltaMode?(r*=40,o*=40):(r*=800,o*=800)),r&&!t&&(t=r<1?-1:1),o&&!n&&(n=o<1?-1:1),{spinX:t,spinY:n||t,pixelX:r,pixelY:o||r}}var Wt={algo:Ot,capitalize:st,chain:Et,debounce:Lt,enumToString:function(e,t){return Object.keys(e).find((n=>e[n]===t))},event:Rt,EVENT_ABORT:Pt,formatBytesToProperUnit:ut,formatNumbersWithThousandSeparator:dt,get:Tt,getArray:St,getCurrentGlobalMTime:function(){return He},getStateArrayMapFunc:ft,isVtkObject:Vt,keystore:Nt,measurePromiseExecution:mt,moveToProtected:wt,newInstance:Mt,newTypedArray:at,newTypedArrayFrom:it,normalizeWheel:zt,obj:ht,proxy:kt,proxyPropertyMapping:Gt,proxyPropertyState:Ut,safeArrays:pt,set:xt,setArray:At,setGet:Ct,setGetArray:It,setImmediate:gt,setLoggerFunction:Ye,throttle:Bt,traverseInstanceTree:Dt,TYPED_ARRAYS:ot,uncapitalize:ct,VOID:Ke,vtkDebugMacro:Je,vtkErrorMacro:et,vtkInfoMacro:Qe,vtkLogMacro:Ze,vtkOnceErrorMacro:rt,vtkWarningMacro:tt,objectSetterMap:yt,requiredParam:je},Ht=Object.freeze({__proto__:null,requiredParam:je,VOID:Ke,setLoggerFunction:Ye,vtkLogMacro:Ze,vtkInfoMacro:Qe,vtkDebugMacro:Je,vtkErrorMacro:et,vtkWarningMacro:tt,vtkOnceErrorMacro:rt,TYPED_ARRAYS:ot,newTypedArray:at,newTypedArrayFrom:it,capitalize:st,_capitalize:lt,uncapitalize:ct,formatBytesToProperUnit:ut,formatNumbersWithThousandSeparator:dt,setImmediateVTK:gt,measurePromiseExecution:mt,obj:ht,get:Tt,set:xt,setGet:Ct,getArray:St,setArray:At,setGetArray:It,moveToProtected:wt,algo:Ot,EVENT_ABORT:Pt,event:Rt,newInstance:Mt,chain:Et,isVtkObject:Vt,traverseInstanceTree:Dt,debounce:Lt,throttle:Bt,keystore:Nt,proxy:kt,proxyPropertyMapping:Gt,proxyPropertyState:Ut,normalizeWheel:zt,default:Wt});const{vtkErrorMacro:jt}=Wt,Kt={renderable:null,myFactory:null,children:[],visited:!1};function $t(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Kt,n),Wt.obj(e,t),Wt.event(e,t,&quot;event&quot;),t._renderableChildMap=new Map,Wt.get(e,t,[&quot;visited&quot;]),Wt.setGet(e,t,[&quot;_parent&quot;,&quot;renderable&quot;,&quot;myFactory&quot;]),Wt.getArray(e,t,[&quot;children&quot;]),Wt.moveToProtected(e,t,[&quot;parent&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkViewNode&quot;),e.build=e=>{},e.render=e=>{},e.traverse=n=>{const r=n.getTraverseOperation(),o=e[r];if(o)o(n);else{e.apply(n,!0);for(let e=0;e<t.children.length;e++)t.children[e].traverse(n);e.apply(n,!1)}},e.apply=(t,n)=>{const r=e[t.getOperation()];r&&r(n,t)},e.getViewNodeFor=n=>{if(t.renderable===n)return e;for(let e=0;e<t.children.length;++e){const r=t.children[e].getViewNodeFor(n);if(r)return r}},e.getFirstAncestorOfType=e=>t._parent?t._parent.isA(e)?t._parent:t._parent.getFirstAncestorOfType(e):null,e.getLastAncestorOfType=e=>t._parent?t._parent.getLastAncestorOfType(e)||(t._parent.isA(e)?t._parent:null):null,e.addMissingNode=n=>{if(!n)return;const r=t._renderableChildMap.get(n);if(void 0!==r)return r.setVisited(!0),r;const o=e.createViewNode(n);return o?(o.setParent(e),o.setVisited(!0),t._renderableChildMap.set(n,o),t.children.push(o),o):void 0},e.addMissingNodes=function(n){let r=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(n&&n.length)for(let o=0;o<n.length;++o){const a=n[o],i=e.addMissingNode(a);if(r&&void 0!==i&&t.children[o]!==i)for(let e=o+1;e<t.children.length;++e)if(t.children[e]===i){t.children.splice(e,1),t.children.splice(o,0,i);break}}},e.addMissingChildren=n=>{if(n&&n.length)for(let r=0;r<n.length;++r){const o=n[r];if(-1===t.children.indexOf(o)){o.setParent(e),t.children.push(o);const n=o.getRenderable();n&&t._renderableChildMap.set(n,o)}o.setVisited(!0)}},e.removeNode=e=>{const n=t.children.findIndex((t=>t===e));if(n<0)return!1;const r=e.getRenderable();return r&&t._renderableChildMap.delete(r),e.delete(),t.children.splice(n,1),!0},e.prepareNodes=()=>{for(let e=0;e<t.children.length;++e)t.children[e].setVisited(!1)},e.setVisited=e=>{t.visited=e},e.removeUnusedNodes=()=>{let e=0;for(let n=0;n<t.children.length;++n){const r=t.children[n];if(r.getVisited())t.children[e++]=r,r.setVisited(!1);else{const e=r.getRenderable();e&&t._renderableChildMap.delete(e),r.delete()}}t.children.length=e},e.createViewNode=e=>{if(!t.myFactory)return jt(&quot;Cannot create view nodes without my own factory&quot;),null;const n=t.myFactory.createNode(e);return n&&n.setRenderable(e),n};const n=e.delete;e.delete=()=>{for(let e=0;e<t.children.length;e++)t.children[e].delete();n()}}(e,t)}var qt={newInstance:Wt.newInstance($t,&quot;vtkViewNode&quot;),extend:$t,PASS_TYPES:[&quot;Build&quot;,&quot;Render&quot;]};const Xt={};function Yt(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Xt,n),Wt.obj(e,t),function(e,t){t.overrides||(t.overrides={}),t.classHierarchy.push(&quot;vtkViewNodeFactory&quot;),e.createNode=n=>{if(n.isDeleted())return null;let r=0,o=n.getClassName(r++),a=!1;const i=Object.keys(t.overrides);for(;o&&!a;)-1!==i.indexOf(o)?a=!0:o=n.getClassName(r++);if(!a)return null;const s=t.overrides[o]();return s.setMyFactory(e),s}}(e,t)}var Zt={newInstance:Wt.newInstance(Yt,&quot;vtkViewNodeFactory&quot;),extend:Yt};const Qt=Object.create(null);function Jt(e,t){Qt[e]=t}const en={};function tn(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,en,n),t.overrides=Qt,Zt.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLViewNodeFactory&quot;)}(0,t)}var nn={newInstance:Wt.newInstance(tn,&quot;vtkOpenGLViewNodeFactory&quot;),extend:tn};const rn={context:null,lastRenderer:null,keyMatrixTime:null,keyMatrices:null};const on=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,rn,n),qt.extend(e,t,n),t.keyMatrixTime={},ht(t.keyMatrixTime),t.keyMatrices={normalMatrix:new Float64Array(9),vcpc:new Float64Array(16),wcvc:new Float64Array(16),wcpc:new Float64Array(16)},Ct(e,t,[&quot;context&quot;,&quot;keyMatrixTime&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLCamera&quot;),e.buildPass=n=>{n&&(t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getParent(),t.context=t._openGLRenderWindow.getContext())},e.opaquePass=e=>{if(e){const e=t._openGLRenderer.getTiledSizeAndOrigin();t.context.viewport(e.lowerLeftU,e.lowerLeftV,e.usize,e.vsize),t.context.scissor(e.lowerLeftU,e.lowerLeftV,e.usize,e.vsize)}},e.translucentPass=e.opaquePass,e.zBufferPass=e.opaquePass,e.opaqueZBufferPass=e.opaquePass,e.volumePass=e.opaquePass,e.getKeyMatrices=n=>{if(n!==t.lastRenderer||t._openGLRenderWindow.getMTime()>t.keyMatrixTime.getMTime()||e.getMTime()>t.keyMatrixTime.getMTime()||n.getMTime()>t.keyMatrixTime.getMTime()||t.renderable.getMTime()>t.keyMatrixTime.getMTime()){p(t.keyMatrices.wcvc,t.renderable.getViewMatrix()),le(t.keyMatrices.normalMatrix,t.keyMatrices.wcvc),me(t.keyMatrices.normalMatrix,t.keyMatrices.normalMatrix),h(t.keyMatrices.wcvc,t.keyMatrices.wcvc);const e=t._openGLRenderer.getAspectRatio();p(t.keyMatrices.vcpc,t.renderable.getProjectionMatrix(e,-1,1)),h(t.keyMatrices.vcpc,t.keyMatrices.vcpc),b(t.keyMatrices.wcpc,t.keyMatrices.vcpc,t.keyMatrices.wcvc),t.keyMatrixTime.modified(),t.lastRenderer=n}return t.keyMatrices}}(e,t)}));Jt(&quot;vtkCamera&quot;,on);const{vtkDebugMacro:an}=Ht,sn={context:null,_openGLRenderWindow:null,selector:null};const ln=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,sn,n),qt.extend(e,t,n),Tt(e,t,[&quot;shaderCache&quot;]),Ct(e,t,[&quot;selector&quot;]),wt(0,t,[&quot;openGLRenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLRenderer&quot;),e.buildPass=n=>{if(n){if(!t.renderable)return;e.updateLights(),e.prepareNodes(),e.addMissingNode(t.renderable.getActiveCamera()),e.addMissingNodes(t.renderable.getViewPropsWithNestedProps(),!0),e.removeUnusedNodes()}},e.updateLights=()=>{let e=0;const n=t.renderable.getLightsByReference();for(let t=0;t<n.length;++t)n[t].getSwitch()>0&&e++;return e||(an(&quot;No lights are on, creating one.&quot;),t.renderable.createLight()),e},e.zBufferPass=n=>{if(n){let n=0;const r=t.context;t.renderable.getTransparent()||(t.context.clearColor(1,0,0,1),n|=r.COLOR_BUFFER_BIT),t.renderable.getPreserveDepthBuffer()||(r.clearDepth(1),n|=r.DEPTH_BUFFER_BIT,t.context.depthMask(!0));const o=e.getTiledSizeAndOrigin();r.enable(r.SCISSOR_TEST),r.scissor(o.lowerLeftU,o.lowerLeftV,o.usize,o.vsize),r.viewport(o.lowerLeftU,o.lowerLeftV,o.usize,o.vsize),r.colorMask(!0,!0,!0,!0),n&&r.clear(n),r.enable(r.DEPTH_TEST)}},e.opaqueZBufferPass=t=>e.zBufferPass(t),e.cameraPass=t=>{t&&e.clear()},e.getAspectRatio=()=>{const e=t._parent.getSizeByReference(),n=t.renderable.getViewportByReference();return e[0]*(n[2]-n[0])/((n[3]-n[1])*e[1])},e.getTiledSizeAndOrigin=()=>{const e=t.renderable.getViewportByReference(),n=[0,0,1,1],r=e[0]-n[0],o=e[1]-n[1],a=t._parent.normalizedDisplayToDisplay(r,o),i=Math.round(a[0]),s=Math.round(a[1]),l=e[2]-n[0],c=e[3]-n[1],u=t._parent.normalizedDisplayToDisplay(l,c);let d=Math.round(u[0])-i,p=Math.round(u[1])-s;return d<0&&(d=0),p<0&&(p=0),{usize:d,vsize:p,lowerLeftU:i,lowerLeftV:s}},e.clear=()=>{let n=0;const r=t.context;if(!t.renderable.getTransparent()){const e=t.renderable.getBackgroundByReference();r.clearColor(e[0],e[1],e[2],e[3]),n|=r.COLOR_BUFFER_BIT}t.renderable.getPreserveDepthBuffer()||(r.clearDepth(1),n|=r.DEPTH_BUFFER_BIT,r.depthMask(!0)),r.colorMask(!0,!0,!0,!0);const o=e.getTiledSizeAndOrigin();r.enable(r.SCISSOR_TEST),r.scissor(o.lowerLeftU,o.lowerLeftV,o.usize,o.vsize),r.viewport(o.lowerLeftU,o.lowerLeftV,o.usize,o.vsize),n&&r.clear(n),r.enable(r.DEPTH_TEST)},e.releaseGraphicsResources=()=>{null!==t.selector&&t.selector.releaseGraphicsResources(),t.renderable&&t.renderable.getViewProps().forEach((e=>{e.modified()}))},e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))}}(e,t)}),&quot;vtkOpenGLRenderer&quot;);Jt(&quot;vtkRenderer&quot;,ln);const cn={context:null,keyMatrixTime:null,keyMatrices:null,activeTextures:null};const un=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,cn,n),qt.extend(e,t,n),t.keyMatrixTime={},ht(t.keyMatrixTime,{mtime:0}),t.keyMatrices={normalMatrix:fe(new Float64Array(9)),mcwc:m(new Float64Array(16))},Ct(e,t,[&quot;context&quot;]),Tt(e,t,[&quot;activeTextures&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLActor&quot;),e.buildPass=n=>{if(n){t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t.context=t._openGLRenderWindow.getContext(),e.prepareNodes(),e.addMissingNodes(t.renderable.getTextures()),e.addMissingNode(t.renderable.getMapper()),e.removeUnusedNodes(),t.ogltextures=null,t.activeTextures=null;for(let e=0;e<t.children.length;e++){const n=t.children[e];n.isA(&quot;vtkOpenGLTexture&quot;)?(t.ogltextures||(t.ogltextures=[]),t.ogltextures.push(n)):t.oglmapper=n}}},e.traverseZBufferPass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.traverseOpaqueZBufferPass=t=>e.traverseOpaquePass(t),e.traverseOpaquePass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&t.renderable.getIsOpaque()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.traverseTranslucentPass=n=>{!t.renderable||!t.renderable.getNestedVisibility()||t.renderable.getIsOpaque()||t._openGLRenderer.getSelector()&&!t.renderable.getNestedPickable()||(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.activateTextures=()=>{if(t.ogltextures){t.activeTextures=[];for(let e=0;e<t.ogltextures.length;e++){const n=t.ogltextures[e];n.render(),n.getHandle()&&t.activeTextures.push(n)}}},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;t.renderable.getIsOpaque()?n.incrementOpaqueActorCount():n.incrementTranslucentActorCount()}},e.zBufferPass=(t,n)=>e.opaquePass(t,n),e.opaqueZBufferPass=(t,n)=>e.opaquePass(t,n),e.opaquePass=(n,r)=>{if(n)t.context.depthMask(!0),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()},e.translucentPass=(n,r)=>{if(n)t.context.depthMask(t._openGLRenderer.getSelector()&&t.renderable.getNestedPickable()),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()},e.getKeyMatrices=()=>(t.renderable.getMTime()>t.keyMatrixTime.getMTime()&&(t.renderable.computeMatrix(),p(t.keyMatrices.mcwc,t.renderable.getMatrix()),h(t.keyMatrices.mcwc,t.keyMatrices.mcwc),t.renderable.getIsIdentity()?fe(t.keyMatrices.normalMatrix):(le(t.keyMatrices.normalMatrix,t.keyMatrices.mcwc),me(t.keyMatrices.normalMatrix,t.keyMatrices.normalMatrix),ge(t.keyMatrices.normalMatrix,t.keyMatrices.normalMatrix)),t.keyMatrixTime.modified()),t.keyMatrices)}(e,t)}));Jt(&quot;vtkActor&quot;,un);const dn={context:null,activeTextures:null};const pn=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,dn,n),qt.extend(e,t,n),Ct(e,t,[&quot;context&quot;]),Tt(e,t,[&quot;activeTextures&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLActor2D&quot;),e.buildPass=n=>{if(n){if(!t.renderable)return;t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t.context=t._openGLRenderWindow.getContext(),e.prepareNodes(),e.addMissingNodes(t.renderable.getTextures()),e.addMissingNode(t.renderable.getMapper()),e.removeUnusedNodes(),t.ogltextures=null,t.activeTextures=null;for(let e=0;e<t.children.length;e++){const n=t.children[e];n.isA(&quot;vtkOpenGLTexture&quot;)?(t.ogltextures||(t.ogltextures=[]),t.ogltextures.push(n)):t.oglmapper=n}}},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;n.incrementOverlayActorCount()}},e.traverseOpaquePass=n=>{t.oglmapper&&t.renderable&&t.renderable.getNestedVisibility()&&t.renderable.getIsOpaque()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.traverseTranslucentPass=n=>{t.oglmapper&&t.renderable&&t.renderable.getNestedVisibility()&&!t.renderable.getIsOpaque()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.traverseOverlayPass=n=>{t.oglmapper&&t.renderable&&t.renderable.getNestedVisibility()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable)&&(e.apply(n,!0),t.oglmapper.traverse(n),e.apply(n,!1))},e.activateTextures=()=>{if(t.ogltextures){t.activeTextures=[];for(let e=0;e<t.ogltextures.length;e++){const n=t.ogltextures[e];n.render(),n.getHandle()&&t.activeTextures.push(n)}}},e.opaquePass=(n,r)=>{if(n)t.context.depthMask(!0),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()},e.translucentPass=(n,r)=>{if(n)t.context.depthMask(!1),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()},e.overlayPass=(n,r)=>{if(n)t.context.depthMask(!0),e.activateTextures();else if(t.activeTextures)for(let e=0;e<t.activeTextures.length;e++)t.activeTextures[e].deactivate()}}(e,t)}));function fn(){var e=new s(3);return s!=Float32Array&&(e[0]=0,e[1]=0,e[2]=0),e}function gn(e){var t=e[0],n=e[1],r=e[2];return Math.hypot(t,n,r)}function mn(e,t,n){var r=new s(3);return r[0]=e,r[1]=t,r[2]=n,r}function hn(e,t,n,r){return e[0]=t,e[1]=n,e[2]=r,e}function vn(e,t,n){return e[0]=t[0]+n[0],e[1]=t[1]+n[1],e[2]=t[2]+n[2],e}function Tn(e,t,n){return e[0]=t[0]-n[0],e[1]=t[1]-n[1],e[2]=t[2]-n[2],e}function yn(e,t,n){return e[0]=t[0]*n[0],e[1]=t[1]*n[1],e[2]=t[2]*n[2],e}function bn(e,t,n){return e[0]=t[0]*n,e[1]=t[1]*n,e[2]=t[2]*n,e}function xn(e,t){return e[0]=1/t[0],e[1]=1/t[1],e[2]=1/t[2],e}function Cn(e,t){var n=t[0],r=t[1],o=t[2],a=n*n+r*r+o*o;return a>0&&(a=1/Math.sqrt(a)),e[0]=t[0]*a,e[1]=t[1]*a,e[2]=t[2]*a,e}function Sn(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function An(e,t,n){var r=t[0],o=t[1],a=t[2],i=n[0],s=n[1],l=n[2];return e[0]=o*l-a*s,e[1]=a*i-r*l,e[2]=r*s-o*i,e}function In(e,t,n){var r=t[0],o=t[1],a=t[2],i=n[3]*r+n[7]*o+n[11]*a+n[15];return i=i||1,e[0]=(n[0]*r+n[4]*o+n[8]*a+n[12])/i,e[1]=(n[1]*r+n[5]*o+n[9]*a+n[13])/i,e[2]=(n[2]*r+n[6]*o+n[10]*a+n[14])/i,e}function wn(e,t,n){var r=t[0],o=t[1],a=t[2];return e[0]=r*n[0]+o*n[3]+a*n[6],e[1]=r*n[1]+o*n[4]+a*n[7],e[2]=r*n[2]+o*n[5]+a*n[8],e}function On(e,t){return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]}function Pn(e,t){var n=e[0],r=e[1],o=e[2],a=t[0],s=t[1],l=t[2];return Math.abs(n-a)<=i*Math.max(1,Math.abs(n),Math.abs(a))&&Math.abs(r-s)<=i*Math.max(1,Math.abs(r),Math.abs(s))&&Math.abs(o-l)<=i*Math.max(1,Math.abs(o),Math.abs(l))}Jt(&quot;vtkActor2D&quot;,pn);var Rn=Tn,Mn=yn,En=(fn(),Math.sqrt(50)),Vn=Math.sqrt(10),Dn=Math.sqrt(2);function Ln(e,t,n){var r=(t-e)/Math.max(0,n),o=Math.floor(Math.log(r)/Math.LN10),a=r/Math.pow(10,o);return o>=0?(a>=En?10:a>=Vn?5:a>=Dn?2:1)*Math.pow(10,o):-Math.pow(10,-o)/(a>=En?10:a>=Vn?5:a>=Dn?2:1)}function Bn(e,t){return null==e||null==t?NaN:e<t?-1:e>t?1:e>=t?0:NaN}function Nn(e){let t=e,n=e,r=e;function o(e,t,o=0,a=e.length){if(o<a){if(0!==n(t,t))return a;do{const n=o+a>>>1;r(e[n],t)<0?o=n+1:a=n}while(o<a)}return o}return 1===e.length&&(t=(t,n)=>e(t)-n,n=Bn,r=(t,n)=>Bn(e(t),n)),{left:o,center:function(e,n,r=0,a=e.length){const i=o(e,n,r,a-1);return i>r&&t(e[i-1],n)>-t(e[i],n)?i-1:i},right:function(e,t,o=0,a=e.length){if(o<a){if(0!==n(t,t))return a;do{const n=o+a>>>1;r(e[n],t)<=0?o=n+1:a=n}while(o<a)}return o}}}const Fn=Nn(Bn),_n=Fn.right;Fn.left,Nn((function(e){return null===e?NaN:+e})).center;var kn=_n;function Gn(e,t,n){e.prototype=t.prototype=n,n.constructor=e}function Un(e,t){var n=Object.create(e.prototype);for(var r in t)n[r]=t[r];return n}function zn(){}var Wn=.7,Hn=1/Wn,jn=&quot;\\\\s*([+-]?\\\\d+)\\\\s*&quot;,Kn=&quot;\\\\s*([+-]?(?:\\\\d*\\\\.)?\\\\d+(?:[eE][+-]?\\\\d+)?)\\\\s*&quot;,$n=&quot;\\\\s*([+-]?(?:\\\\d*\\\\.)?\\\\d+(?:[eE][+-]?\\\\d+)?)%\\\\s*&quot;,qn=/^#([0-9a-f]{3,8})$/,Xn=new RegExp(`^rgb\\\\(${jn},${jn},${jn}\\\\)$`),Yn=new RegExp(`^rgb\\\\(${$n},${$n},${$n}\\\\)$`),Zn=new RegExp(`^rgba\\\\(${jn},${jn},${jn},${Kn}\\\\)$`),Qn=new RegExp(`^rgba\\\\(${$n},${$n},${$n},${Kn}\\\\)$`),Jn=new RegExp(`^hsl\\\\(${Kn},${$n},${$n}\\\\)$`),er=new RegExp(`^hsla\\\\(${Kn},${$n},${$n},${Kn}\\\\)$`),tr={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function nr(){return this.rgb().formatHex()}function rr(){return this.rgb().formatRgb()}function or(e){var t,n;return e=(e+&quot;&quot;).trim().toLowerCase(),(t=qn.exec(e))?(n=t[1].length,t=parseInt(t[1],16),6===n?ar(t):3===n?new lr(t>>8&15|t>>4&240,t>>4&15|240&t,(15&t)<<4|15&t,1):8===n?ir(t>>24&255,t>>16&255,t>>8&255,(255&t)/255):4===n?ir(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|240&t,((15&t)<<4|15&t)/255):null):(t=Xn.exec(e))?new lr(t[1],t[2],t[3],1):(t=Yn.exec(e))?new lr(255*t[1]/100,255*t[2]/100,255*t[3]/100,1):(t=Zn.exec(e))?ir(t[1],t[2],t[3],t[4]):(t=Qn.exec(e))?ir(255*t[1]/100,255*t[2]/100,255*t[3]/100,t[4]):(t=Jn.exec(e))?gr(t[1],t[2]/100,t[3]/100,1):(t=er.exec(e))?gr(t[1],t[2]/100,t[3]/100,t[4]):tr.hasOwnProperty(e)?ar(tr[e]):&quot;transparent&quot;===e?new lr(NaN,NaN,NaN,0):null}function ar(e){return new lr(e>>16&255,e>>8&255,255&e,1)}function ir(e,t,n,r){return r<=0&&(e=t=n=NaN),new lr(e,t,n,r)}function sr(e,t,n,r){return 1===arguments.length?((o=e)instanceof zn||(o=or(o)),o?new lr((o=o.rgb()).r,o.g,o.b,o.opacity):new lr):new lr(e,t,n,null==r?1:r);var o}function lr(e,t,n,r){this.r=+e,this.g=+t,this.b=+n,this.opacity=+r}function cr(){return`#${fr(this.r)}${fr(this.g)}${fr(this.b)}`}function ur(){const e=dr(this.opacity);return`${1===e?&quot;rgb(&quot;:&quot;rgba(&quot;}${pr(this.r)}, ${pr(this.g)}, ${pr(this.b)}${1===e?&quot;)&quot;:`, ${e})`}`}function dr(e){return isNaN(e)?1:Math.max(0,Math.min(1,e))}function pr(e){return Math.max(0,Math.min(255,Math.round(e)||0))}function fr(e){return((e=pr(e))<16?&quot;0&quot;:&quot;&quot;)+e.toString(16)}function gr(e,t,n,r){return r<=0?e=t=n=NaN:n<=0||n>=1?e=t=NaN:t<=0&&(e=NaN),new hr(e,t,n,r)}function mr(e){if(e instanceof hr)return new hr(e.h,e.s,e.l,e.opacity);if(e instanceof zn||(e=or(e)),!e)return new hr;if(e instanceof hr)return e;var t=(e=e.rgb()).r/255,n=e.g/255,r=e.b/255,o=Math.min(t,n,r),a=Math.max(t,n,r),i=NaN,s=a-o,l=(a+o)/2;return s?(i=t===a?(n-r)/s+6*(n<r):n===a?(r-t)/s+2:(t-n)/s+4,s/=l<.5?a+o:2-a-o,i*=60):s=l>0&&l<1?0:i,new hr(i,s,l,e.opacity)}function hr(e,t,n,r){this.h=+e,this.s=+t,this.l=+n,this.opacity=+r}function vr(e){return(e=(e||0)%360)<0?e+360:e}function Tr(e){return Math.max(0,Math.min(1,e||0))}function yr(e,t,n){return 255*(e<60?t+(n-t)*e/60:e<180?n:e<240?t+(n-t)*(240-e)/60:t)}function br(e,t,n,r,o){var a=e*e,i=a*e;return((1-3*e+3*a-i)*t+(4-6*a+3*i)*n+(1+3*e+3*a-3*i)*r+i*o)/6}Gn(zn,or,{copy(e){return Object.assign(new this.constructor,this,e)},displayable(){return this.rgb().displayable()},hex:nr,formatHex:nr,formatHex8:function(){return this.rgb().formatHex8()},formatHsl:function(){return mr(this).formatHsl()},formatRgb:rr,toString:rr}),Gn(lr,sr,Un(zn,{brighter(e){return e=null==e?Hn:Math.pow(Hn,e),new lr(this.r*e,this.g*e,this.b*e,this.opacity)},darker(e){return e=null==e?Wn:Math.pow(Wn,e),new lr(this.r*e,this.g*e,this.b*e,this.opacity)},rgb(){return this},clamp(){return new lr(pr(this.r),pr(this.g),pr(this.b),dr(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:cr,formatHex:cr,formatHex8:function(){return`#${fr(this.r)}${fr(this.g)}${fr(this.b)}${fr(255*(isNaN(this.opacity)?1:this.opacity))}`},formatRgb:ur,toString:ur})),Gn(hr,(function(e,t,n,r){return 1===arguments.length?mr(e):new hr(e,t,n,null==r?1:r)}),Un(zn,{brighter(e){return e=null==e?Hn:Math.pow(Hn,e),new hr(this.h,this.s,this.l*e,this.opacity)},darker(e){return e=null==e?Wn:Math.pow(Wn,e),new hr(this.h,this.s,this.l*e,this.opacity)},rgb(){var e=this.h%360+360*(this.h<0),t=isNaN(e)||isNaN(this.s)?0:this.s,n=this.l,r=n+(n<.5?n:1-n)*t,o=2*n-r;return new lr(yr(e>=240?e-240:e+120,o,r),yr(e,o,r),yr(e<120?e+240:e-120,o,r),this.opacity)},clamp(){return new hr(vr(this.h),Tr(this.s),Tr(this.l),dr(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){const e=dr(this.opacity);return`${1===e?&quot;hsl(&quot;:&quot;hsla(&quot;}${vr(this.h)}, ${100*Tr(this.s)}%, ${100*Tr(this.l)}%${1===e?&quot;)&quot;:`, ${e})`}`}}));var xr=e=>()=>e;function Cr(e,t){var n=t-e;return n?function(e,t){return function(n){return e+n*t}}(e,n):xr(isNaN(e)?t:e)}var Sr=function e(t){var n=function(e){return 1==(e=+e)?Cr:function(t,n){return n-t?function(e,t,n){return e=Math.pow(e,n),t=Math.pow(t,n)-e,n=1/n,function(r){return Math.pow(e+r*t,n)}}(t,n,e):xr(isNaN(t)?n:t)}}(t);function r(e,t){var r=n((e=sr(e)).r,(t=sr(t)).r),o=n(e.g,t.g),a=n(e.b,t.b),i=Cr(e.opacity,t.opacity);return function(t){return e.r=r(t),e.g=o(t),e.b=a(t),e.opacity=i(t),e+&quot;&quot;}}return r.gamma=e,r}(1);function Ar(e){return function(t){var n,r,o=t.length,a=new Array(o),i=new Array(o),s=new Array(o);for(n=0;n<o;++n)r=sr(t[n]),a[n]=r.r||0,i[n]=r.g||0,s[n]=r.b||0;return a=e(a),i=e(i),s=e(s),r.opacity=1,function(e){return r.r=a(e),r.g=i(e),r.b=s(e),r+&quot;&quot;}}}function Ir(e,t){var n,r=t?t.length:0,o=e?Math.min(r,e.length):0,a=new Array(o),i=new Array(r);for(n=0;n<o;++n)a[n]=Dr(e[n],t[n]);for(;n<r;++n)i[n]=t[n];return function(e){for(n=0;n<o;++n)i[n]=a[n](e);return i}}function wr(e,t){var n=new Date;return e=+e,t=+t,function(r){return n.setTime(e*(1-r)+t*r),n}}function Or(e,t){return e=+e,t=+t,function(n){return e*(1-n)+t*n}}function Pr(e,t){var n,r={},o={};for(n in null!==e&&&quot;object&quot;==typeof e||(e={}),null!==t&&&quot;object&quot;==typeof t||(t={}),t)n in e?r[n]=Dr(e[n],t[n]):o[n]=t[n];return function(e){for(n in r)o[n]=r[n](e);return o}}Ar((function(e){var t=e.length-1;return function(n){var r=n<=0?n=0:n>=1?(n=1,t-1):Math.floor(n*t),o=e[r],a=e[r+1],i=r>0?e[r-1]:2*o-a,s=r<t-1?e[r+2]:2*a-o;return br((n-r/t)*t,i,o,a,s)}})),Ar((function(e){var t=e.length;return function(n){var r=Math.floor(((n%=1)<0?++n:n)*t),o=e[(r+t-1)%t],a=e[r%t],i=e[(r+1)%t],s=e[(r+2)%t];return br((n-r/t)*t,o,a,i,s)}}));var Rr=/[-+]?(?:\\d+\\.?\\d*|\\.?\\d+)(?:[eE][-+]?\\d+)?/g,Mr=new RegExp(Rr.source,&quot;g&quot;);function Er(e,t){var n,r,o,a=Rr.lastIndex=Mr.lastIndex=0,i=-1,s=[],l=[];for(e+=&quot;&quot;,t+=&quot;&quot;;(n=Rr.exec(e))&&(r=Mr.exec(t));)(o=r.index)>a&&(o=t.slice(a,o),s[i]?s[i]+=o:s[++i]=o),(n=n[0])===(r=r[0])?s[i]?s[i]+=r:s[++i]=r:(s[++i]=null,l.push({i:i,x:Or(n,r)})),a=Mr.lastIndex;return a<t.length&&(o=t.slice(a),s[i]?s[i]+=o:s[++i]=o),s.length<2?l[0]?function(e){return function(t){return e(t)+&quot;&quot;}}(l[0].x):function(e){return function(){return e}}(t):(t=l.length,function(e){for(var n,r=0;r<t;++r)s[(n=l[r]).i]=n.x(e);return s.join(&quot;&quot;)})}function Vr(e,t){t||(t=[]);var n,r=e?Math.min(t.length,e.length):0,o=t.slice();return function(a){for(n=0;n<r;++n)o[n]=e[n]*(1-a)+t[n]*a;return o}}function Dr(e,t){var n,r=typeof t;return null==t||&quot;boolean&quot;===r?xr(t):(&quot;number&quot;===r?Or:&quot;string&quot;===r?(n=or(t))?(t=n,Sr):Er:t instanceof or?Sr:t instanceof Date?wr:function(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}(t)?Vr:Array.isArray(t)?Ir:&quot;function&quot;!=typeof t.valueOf&&&quot;function&quot;!=typeof t.toString||isNaN(t)?Pr:Or)(e,t)}function Lr(e,t){return e=+e,t=+t,function(n){return Math.round(e*(1-n)+t*n)}}function Br(e){return+e}var Nr=[0,1];function Fr(e){return e}function _r(e,t){return(t-=e=+e)?function(n){return(n-e)/t}:function(e){return function(){return e}}(isNaN(t)?NaN:.5)}function kr(e,t,n){var r=e[0],o=e[1],a=t[0],i=t[1];return o<r?(r=_r(o,r),a=n(i,a)):(r=_r(r,o),a=n(a,i)),function(e){return a(r(e))}}function Gr(e,t,n){var r=Math.min(e.length,t.length)-1,o=new Array(r),a=new Array(r),i=-1;for(e[r]<e[0]&&(e=e.slice().reverse(),t=t.slice().reverse());++i<r;)o[i]=_r(e[i],e[i+1]),a[i]=n(t[i],t[i+1]);return function(t){var n=kn(e,t,1,r)-1;return a[n](o[n](t))}}function Ur(e,t){switch(arguments.length){case 0:break;case 1:this.range(e);break;default:this.range(t).domain(e)}return this}var zr,Wr=/^(?:(.)?([<>=^]))?([+\\-( ])?([$#])?(0)?(\\d+)?(,)?(\\.\\d+)?(~)?([a-z%])?$/i;function Hr(e){if(!(t=Wr.exec(e)))throw new Error(&quot;invalid format: &quot;+e);var t;return new jr({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}function jr(e){this.fill=void 0===e.fill?&quot; &quot;:e.fill+&quot;&quot;,this.align=void 0===e.align?&quot;>&quot;:e.align+&quot;&quot;,this.sign=void 0===e.sign?&quot;-&quot;:e.sign+&quot;&quot;,this.symbol=void 0===e.symbol?&quot;&quot;:e.symbol+&quot;&quot;,this.zero=!!e.zero,this.width=void 0===e.width?void 0:+e.width,this.comma=!!e.comma,this.precision=void 0===e.precision?void 0:+e.precision,this.trim=!!e.trim,this.type=void 0===e.type?&quot;&quot;:e.type+&quot;&quot;}function Kr(e,t){if((n=(e=t?e.toExponential(t-1):e.toExponential()).indexOf(&quot;e&quot;))<0)return null;var n,r=e.slice(0,n);return[r.length>1?r[0]+r.slice(2):r,+e.slice(n+1)]}function $r(e){return(e=Kr(Math.abs(e)))?e[1]:NaN}function qr(e,t){var n=Kr(e,t);if(!n)return e+&quot;&quot;;var r=n[0],o=n[1];return o<0?&quot;0.&quot;+new Array(-o).join(&quot;0&quot;)+r:r.length>o+1?r.slice(0,o+1)+&quot;.&quot;+r.slice(o+1):r+new Array(o-r.length+2).join(&quot;0&quot;)}Hr.prototype=jr.prototype,jr.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?&quot;0&quot;:&quot;&quot;)+(void 0===this.width?&quot;&quot;:Math.max(1,0|this.width))+(this.comma?&quot;,&quot;:&quot;&quot;)+(void 0===this.precision?&quot;&quot;:&quot;.&quot;+Math.max(0,0|this.precision))+(this.trim?&quot;~&quot;:&quot;&quot;)+this.type};var Xr={&quot;%&quot;:(e,t)=>(100*e).toFixed(t),b:e=>Math.round(e).toString(2),c:e=>e+&quot;&quot;,d:function(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString(&quot;en&quot;).replace(/,/g,&quot;&quot;):e.toString(10)},e:(e,t)=>e.toExponential(t),f:(e,t)=>e.toFixed(t),g:(e,t)=>e.toPrecision(t),o:e=>Math.round(e).toString(8),p:(e,t)=>qr(100*e,t),r:qr,s:function(e,t){var n=Kr(e,t);if(!n)return e+&quot;&quot;;var r=n[0],o=n[1],a=o-(zr=3*Math.max(-8,Math.min(8,Math.floor(o/3))))+1,i=r.length;return a===i?r:a>i?r+new Array(a-i+1).join(&quot;0&quot;):a>0?r.slice(0,a)+&quot;.&quot;+r.slice(a):&quot;0.&quot;+new Array(1-a).join(&quot;0&quot;)+Kr(e,Math.max(0,t+a-1))[0]},X:e=>Math.round(e).toString(16).toUpperCase(),x:e=>Math.round(e).toString(16)};function Yr(e){return e}var Zr,Qr,Jr,eo=Array.prototype.map,to=[&quot;y&quot;,&quot;z&quot;,&quot;a&quot;,&quot;f&quot;,&quot;p&quot;,&quot;n&quot;,&quot;µ&quot;,&quot;m&quot;,&quot;&quot;,&quot;k&quot;,&quot;M&quot;,&quot;G&quot;,&quot;T&quot;,&quot;P&quot;,&quot;E&quot;,&quot;Z&quot;,&quot;Y&quot;];function no(e){var t=e.domain;return e.ticks=function(e){var n=t();return function(e,t,n){var r,o,a,i,s=-1;if(n=+n,(e=+e)==(t=+t)&&n>0)return[e];if((r=t<e)&&(o=e,e=t,t=o),0===(i=Ln(e,t,n))||!isFinite(i))return[];if(i>0){let n=Math.round(e/i),r=Math.round(t/i);for(n*i<e&&++n,r*i>t&&--r,a=new Array(o=r-n+1);++s<o;)a[s]=(n+s)*i}else{i=-i;let n=Math.round(e*i),r=Math.round(t*i);for(n/i<e&&++n,r/i>t&&--r,a=new Array(o=r-n+1);++s<o;)a[s]=(n+s)/i}return r&&a.reverse(),a}(n[0],n[n.length-1],null==e?10:e)},e.tickFormat=function(e,n){var r=t();return function(e,t,n,r){var o,a=function(e,t,n){var r=Math.abs(t-e)/Math.max(0,n),o=Math.pow(10,Math.floor(Math.log(r)/Math.LN10)),a=r/o;return a>=En?o*=10:a>=Vn?o*=5:a>=Dn&&(o*=2),t<e?-o:o}(e,t,n);switch((r=Hr(null==r?&quot;,f&quot;:r)).type){case&quot;s&quot;:var i=Math.max(Math.abs(e),Math.abs(t));return null!=r.precision||isNaN(o=function(e,t){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor($r(t)/3)))-$r(Math.abs(e)))}(a,i))||(r.precision=o),Jr(r,i);case&quot;&quot;:case&quot;e&quot;:case&quot;g&quot;:case&quot;p&quot;:case&quot;r&quot;:null!=r.precision||isNaN(o=function(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,$r(t)-$r(e))+1}(a,Math.max(Math.abs(e),Math.abs(t))))||(r.precision=o-(&quot;e&quot;===r.type));break;case&quot;f&quot;:case&quot;%&quot;:null!=r.precision||isNaN(o=function(e){return Math.max(0,-$r(Math.abs(e)))}(a))||(r.precision=o-2*(&quot;%&quot;===r.type))}return Qr(r)}(r[0],r[r.length-1],null==e?10:e,n)},e.nice=function(n){null==n&&(n=10);var r,o,a=t(),i=0,s=a.length-1,l=a[i],c=a[s],u=10;for(c<l&&(o=l,l=c,c=o,o=i,i=s,s=o);u-- >0;){if((o=Ln(l,c,n))===r)return a[i]=l,a[s]=c,t(a);if(o>0)l=Math.floor(l/o)*o,c=Math.ceil(c/o)*o;else{if(!(o<0))break;l=Math.ceil(l*o)/o,c=Math.floor(c*o)/o}r=o}return e},e}function ro(){var e=function(){var e,t,n,r,o,a,i=Nr,s=Nr,l=Dr,c=Fr;function u(){var e,t,n,l=Math.min(i.length,s.length);return c!==Fr&&(e=i[0],t=i[l-1],e>t&&(n=e,e=t,t=n),c=function(n){return Math.max(e,Math.min(t,n))}),r=l>2?Gr:kr,o=a=null,d}function d(t){return null==t||isNaN(t=+t)?n:(o||(o=r(i.map(e),s,l)))(e(c(t)))}return d.invert=function(n){return c(t((a||(a=r(s,i.map(e),Or)))(n)))},d.domain=function(e){return arguments.length?(i=Array.from(e,Br),u()):i.slice()},d.range=function(e){return arguments.length?(s=Array.from(e),u()):s.slice()},d.rangeRound=function(e){return s=Array.from(e),l=Lr,u()},d.clamp=function(e){return arguments.length?(c=!!e||Fr,u()):c!==Fr},d.interpolate=function(e){return arguments.length?(l=e,u()):l},d.unknown=function(e){return arguments.length?(n=e,d):n},function(n,r){return e=n,t=r,u()}}()(Fr,Fr);return e.copy=function(){return t=e,ro().domain(t.domain()).range(t.range()).interpolate(t.interpolate()).clamp(t.clamp()).unknown(t.unknown());var t},Ur.apply(e,arguments),no(e)}Zr=function(e){var t,n,r=void 0===e.grouping||void 0===e.thousands?Yr:(t=eo.call(e.grouping,Number),n=e.thousands+&quot;&quot;,function(e,r){for(var o=e.length,a=[],i=0,s=t[0],l=0;o>0&&s>0&&(l+s+1>r&&(s=Math.max(1,r-l)),a.push(e.substring(o-=s,o+s)),!((l+=s+1)>r));)s=t[i=(i+1)%t.length];return a.reverse().join(n)}),o=void 0===e.currency?&quot;&quot;:e.currency[0]+&quot;&quot;,a=void 0===e.currency?&quot;&quot;:e.currency[1]+&quot;&quot;,i=void 0===e.decimal?&quot;.&quot;:e.decimal+&quot;&quot;,s=void 0===e.numerals?Yr:function(e){return function(t){return t.replace(/[0-9]/g,(function(t){return e[+t]}))}}(eo.call(e.numerals,String)),l=void 0===e.percent?&quot;%&quot;:e.percent+&quot;&quot;,c=void 0===e.minus?&quot;−&quot;:e.minus+&quot;&quot;,u=void 0===e.nan?&quot;NaN&quot;:e.nan+&quot;&quot;;function d(e){var t=(e=Hr(e)).fill,n=e.align,d=e.sign,p=e.symbol,f=e.zero,g=e.width,m=e.comma,h=e.precision,v=e.trim,T=e.type;&quot;n&quot;===T?(m=!0,T=&quot;g&quot;):Xr[T]||(void 0===h&&(h=12),v=!0,T=&quot;g&quot;),(f||&quot;0&quot;===t&&&quot;=&quot;===n)&&(f=!0,t=&quot;0&quot;,n=&quot;=&quot;);var y=&quot;$&quot;===p?o:&quot;#&quot;===p&&/[boxX]/.test(T)?&quot;0&quot;+T.toLowerCase():&quot;&quot;,b=&quot;$&quot;===p?a:/[%p]/.test(T)?l:&quot;&quot;,x=Xr[T],C=/[defgprs%]/.test(T);function S(e){var o,a,l,p=y,S=b;if(&quot;c&quot;===T)S=x(e)+S,e=&quot;&quot;;else{var A=(e=+e)<0||1/e<0;if(e=isNaN(e)?u:x(Math.abs(e),h),v&&(e=function(e){e:for(var t,n=e.length,r=1,o=-1;r<n;++r)switch(e[r]){case&quot;.&quot;:o=t=r;break;case&quot;0&quot;:0===o&&(o=r),t=r;break;default:if(!+e[r])break e;o>0&&(o=0)}return o>0?e.slice(0,o)+e.slice(t+1):e}(e)),A&&0==+e&&&quot;+&quot;!==d&&(A=!1),p=(A?&quot;(&quot;===d?d:c:&quot;-&quot;===d||&quot;(&quot;===d?&quot;&quot;:d)+p,S=(&quot;s&quot;===T?to[8+zr/3]:&quot;&quot;)+S+(A&&&quot;(&quot;===d?&quot;)&quot;:&quot;&quot;),C)for(o=-1,a=e.length;++o<a;)if(48>(l=e.charCodeAt(o))||l>57){S=(46===l?i+e.slice(o+1):e.slice(o))+S,e=e.slice(0,o);break}}m&&!f&&(e=r(e,1/0));var I=p.length+e.length+S.length,w=I<g?new Array(g-I+1).join(t):&quot;&quot;;switch(m&&f&&(e=r(w+e,w.length?g-S.length:1/0),w=&quot;&quot;),n){case&quot;<&quot;:e=p+e+S+w;break;case&quot;=&quot;:e=p+w+e+S;break;case&quot;^&quot;:e=w.slice(0,I=w.length>>1)+p+e+S+w.slice(I);break;default:e=w+p+e+S}return s(e)}return h=void 0===h?6:/[gprs]/.test(T)?Math.max(1,Math.min(21,h)):Math.max(0,Math.min(20,h)),S.toString=function(){return e+&quot;&quot;},S}return{format:d,formatPrefix:function(e,t){var n=d(((e=Hr(e)).type=&quot;f&quot;,e)),r=3*Math.max(-8,Math.min(8,Math.floor($r(t)/3))),o=Math.pow(10,-r),a=to[8+r/3];return function(e){return n(o*e)+a}}}}({thousands:&quot;,&quot;,grouping:[3],currency:[&quot;$&quot;,&quot;&quot;]}),Qr=Zr.format,Jr=Zr.formatPrefix;var oo=n(318);const ao=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],io=[1,0,0,0,1,0,0,0,1],so=1e-6,lo=1e-12,{vtkErrorMacro:co,vtkWarningMacro:uo}=Wt;let po=0;function fo(e){return()=>co(`vtkMath::${e} - NOT IMPLEMENTED`)}function go(e,t,n,r){let o;for(let a=0;a<t;a++)o=e[n*t+a],e[n*t+a]=e[r*t+a],e[r*t+a]=o}function mo(e,t,n,r){let o;for(let a=0;a<t;a++)o=e[a*t+n],e[a*t+n]=e[a*t+r],e[a*t+r]=o}function ho(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:3;const t=Array(e);for(let n=0;n<e;++n)t[n]=0;return t}function vo(e){return e/180*Math.PI}function To(e){return 180*e/Math.PI}const{round:yo,floor:bo,ceil:xo,min:Co,max:So}=Math;const Ao=fo(&quot;ceilLog2&quot;),Io=fo(&quot;factorial&quot;);function wo(e){let t=1;for(;t<e;)t*=2;return t}function Oo(e){return e===wo(e)}const Po=fo(&quot;gaussian&quot;);function Ro(e,t,n){return n[0]=e[0]+t[0],n[1]=e[1]+t[1],n[2]=e[2]+t[2],n}function Mo(e,t,n){return n[0]=e[0]-t[0],n[1]=e[1]-t[1],n[2]=e[2]-t[2],n}function Eo(e,t){return e[0]*=t,e[1]*=t,e[2]*=t,e}function Vo(e,t){return e[0]*=t,e[1]*=t,e}function Do(e,t,n,r){return r[0]=e[0]+t[0]*n,r[1]=e[1]+t[1]*n,r[2]=e[2]+t[2]*n,r}function Lo(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function Bo(e,t,n){const r=e[1]*t[2]-e[2]*t[1],o=e[2]*t[0]-e[0]*t[2],a=e[0]*t[1]-e[1]*t[0];return n[0]=r,n[1]=o,n[2]=a,n}function No(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:3;switch(t){case 1:return Math.abs(e);case 2:return Math.sqrt(e[0]*e[0]+e[1]*e[1]);case 3:return Math.sqrt(e[0]*e[0]+e[1]*e[1]+e[2]*e[2]);default:{let n=0;for(let r=0;r<t;r++)n+=e[r]*e[r];return Math.sqrt(n)}}}function Fo(e){const t=No(e);return 0!==t&&(e[0]/=t,e[1]/=t,e[2]/=t),t}function _o(e){const t=No(e,3);return 0!==t&&(e[0]/=t,e[1]/=t,e[2]/=t,e[3]/=t),t}function ko(e,t){return e[0]*t[0]+e[1]*t[1]}function Go(e,t){return(e[0]-t[0])*(e[0]-t[0])+(e[1]-t[1])*(e[1]-t[1])+(e[2]-t[2])*(e[2]-t[2])}function Uo(e){return Math.sqrt(e[0]*e[0]+e[1]*e[1])}function zo(e){const t=Uo(e);return 0!==t&&(e[0]/=t,e[1]/=t),t}function Wo(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return 2===t.length?t[0][0]*t[1][1]-t[1][0]*t[0][1]:4===t.length?t[0]*t[3]-t[1]*t[2]:Number.NaN}function Ho(e,t,n){const r=e[0]*t[0]+e[1]*t[1]+e[2]*t[2],o=e[3]*t[0]+e[4]*t[1]+e[5]*t[2],a=e[6]*t[0]+e[7]*t[1]+e[8]*t[2];n[0]=r,n[1]=o,n[2]=a}function jo(e,t,n){const r=[...e],o=[...t];for(let e=0;e<3;e++)n[e]=r[0]*o[e]+r[1]*o[e+3]+r[2]*o[e+6],n[e+3]=r[3]*o[e]+r[4]*o[e+3]+r[5]*o[e+6],n[e+6]=r[6]*o[e]+r[7]*o[e+3]+r[8]*o[e+6]}function Ko(e,t){let n;n=e[3],t[3]=e[1],t[1]=n,n=e[6],t[6]=e[2],t[2]=n,n=e[7],t[7]=e[5],t[5]=n,t[0]=e[0],t[4]=e[4],t[8]=e[8]}function $o(e){return e[0]*e[4]*e[8]+e[3]*e[7]*e[2]+e[6]*e[1]*e[5]-e[0]*e[7]*e[5]-e[3]*e[1]*e[8]-e[6]*e[4]*e[2]}function qo(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:so;return e.length===t.length&&e.every((function(e,r){return Math.abs(e-t[r])<=n}))}const Xo=qo;function Yo(e){for(let t=0;t<3;t++)e[3*t]=e[3*t+1]=e[3*t+2]=0,e[3*t+t]=1}function Zo(e,t){for(let n=0;n<e;n++){for(let r=0;r<e;r++)t[n*e+r]=0;t[n*e+n]=1}return t}function Qo(e,t){const n=e[0]*e[0],r=e[0]*e[1],o=e[0]*e[2],a=e[0]*e[3],i=e[1]*e[1],s=e[2]*e[2],l=e[3]*e[3],c=e[1]*e[2],u=e[1]*e[3],d=e[2]*e[3],p=i+s+l;let f=1/(n+p);const g=(n-p)*f;f*=2,t[0]=i*f+g,t[3]=(c+a)*f,t[6]=(u-o)*f,t[1]=(c-a)*f,t[4]=s*f+g,t[7]=(d+r)*f,t[2]=(u+o)*f,t[5]=(d-r)*f,t[8]=l*f+g}function Jo(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;if(!`${e}`.includes(&quot;e&quot;))return+`${Math.round(`${e}e+${t}`)}e-${t}`;const n=`${e}`.split(&quot;e&quot;);let r=&quot;&quot;;return+n[1]+t>0&&(r=&quot;+&quot;),+`${Math.round(`${+n[0]}e${r}${+n[1]+t}`)}e-${t}`}function ea(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[0,0,0],n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:0;return t[0]=Jo(e[0],n),t[1]=Jo(e[1],n),t[2]=Jo(e[2],n),t}function ta(e,t,n,r){let o,a,i,s,l,c,u,d,p,f,g,m,h,v,T,y;const b=ho(t),x=ho(t),C=(e,t,n)=>{v=e[t],h=e[n],e[t]=v-m*(h+v*f),e[n]=h+m*(v-h*f)};for(Zo(t,r),l=0;l<t;l++)b[l]=n[l]=e[l+l*t],x[l]=0;for(o=0;o<20;o++){for(g=0,l=0;l<t-1;l++)for(s=l+1;s<t;s++)g+=Math.abs(e[l*t+s]);if(0===g)break;for(u=o<3?.2*g/(t*t):0,l=0;l<t-1;l++)for(s=l+1;s<t;s++)if(v=100*Math.abs(e[l*t+s]),o>3&&Math.abs(n[l])+v===Math.abs(n[l])&&Math.abs(n[s])+v===Math.abs(n[s]))e[l*t+s]=0;else if(Math.abs(e[l*t+s])>u){for(h=n[s]-n[l],Math.abs(h)+v===Math.abs(h)?p=e[l*t+s]/h:(d=.5*h/e[l*t+s],p=1/(Math.abs(d)+Math.sqrt(1+d*d)),d<0&&(p=-p)),T=1/Math.sqrt(1+p*p),m=p*T,f=m/(1+T),h=p*e[l*t+s],x[l]-=h,x[s]+=h,n[l]-=h,n[s]+=h,e[l*t+s]=0,a=0;a<=l-1;a++)C(e,a*t+l,a*t+s);for(a=l+1;a<=s-1;a++)C(e,l*t+a,a*t+s);for(a=s+1;a<t;a++)C(e,l*t+a,s*t+a);for(a=0;a<t;a++)C(r,a*t+l,a*t+s)}for(l=0;l<t;l++)b[l]+=x[l],n[l]=b[l],x[l]=0}if(o>=20)return uo(&quot;vtkMath::Jacobi: Error extracting eigenfunctions&quot;),0;for(a=0;a<t-1;a++){for(i=a,y=n[i],o=a+1;o<t;o++)(n[o]>=y||Math.abs(n[o]-y)<lo)&&(i=o,y=n[i]);i!==a&&(n[i]=n[a],n[a]=y,mo(r,t,a,i))}const S=(t>>1)+(1&t);for(c=0,o=0;o<t*t;o++)r[o]>=0&&c++;if(c<S)for(o=0;o<t;o++)r[o*t+a]*=-1;return 1}function na(e,t){const n=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];n[0]=e[0]+e[4]+e[8],n[5]=e[0]-e[4]-e[8],n[10]=-e[0]+e[4]-e[8],n[15]=-e[0]-e[4]+e[8],n[1]=n[4]=e[7]-e[5],n[2]=n[8]=e[2]-e[6],n[3]=n[12]=e[3]-e[1],n[6]=n[9]=e[3]+e[1],n[7]=n[13]=e[2]+e[6],n[11]=n[14]=e[7]+e[5];const r=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];ta([...n],4,[0,0,0,0],r),t[0]=r[0],t[1]=r[4],t[2]=r[8],t[3]=r[12]}function ra(e,t){for(let n=0;n<9;n++)t[n]=e[n];const n=ho(3),r=ho(3);let o;for(let e=0;e<3;e++){const r=Math.abs(t[3*e]),a=Math.abs(t[3*e+1]),i=Math.abs(t[3*e+2]);o=a>r?a:r,o=i>o?i:o,n[e]=1,0!==o&&(n[e]/=o)}const a=Math.abs(t[0])*n[0],i=Math.abs(t[3])*n[1],s=Math.abs(t[6])*n[2];r[0]=0,o=a,i>=o&&(o=i,r[0]=1),s>=o&&(r[0]=2),0!==r[0]&&(mo(t,3,r[0],0),n[r[0]]=n[0]);const l=Math.abs(t[4])*n[1],c=Math.abs(t[7])*n[2];r[1]=1,o=l,c>=o&&(r[1]=2,mo(t,3,1,2)),r[2]=2;let u=0;if($o(t)<0){u=1;for(let e=0;e<9;e++)t[e]=-t[e]}const d=ho(4);if(na(t,d),Qo(d,t),u)for(let e=0;e<9;e++)t[e]=-t[e];1!==r[1]&&mo(t,3,r[1],1),0!==r[0]&&mo(t,3,r[0],0)}function oa(e,t,n){let r,o,a,i,s,l;if(ta([...e],3,t,n),t[0]!==t[1]||t[0]!==t[2]){for(Ko(n,n),r=0;r<3;r++)if(t[(r+1)%3]===t[(r+2)%3]){for(l=Math.abs(n[3*r]),i=0,o=1;o<3;o++)l<(s=Math.abs(n[3*r+o]))&&(l=s,i=o);i!==r&&(s=t[i],t[i]=t[r],t[r]=s,go(n,3,r,i)),n[3*i+i]<0&&(n[3*i]=-n[3*i],n[3*i+1]=-n[3*i+1],n[3*i+2]=-n[3*i+2]),o=(i+1)%3,a=(i+2)%3,n[3*o]=0,n[3*o+1]=0,n[3*o+2]=0,n[3*o+o]=1;const e=Bo([n[3*i],n[3*i+1],n[3*i+2]],[n[3*o],n[3*o+1],n[3*o+2]],[]);Fo(e);const c=Bo(e,[n[3*i],n[3*i+1],n[3*i+2]],[]);for(let t=0;t<3;t++)n[3*a+t]=e[t],n[3*o+t]=c[t];return void Ko(n,n)}for(l=Math.abs(n[0]),i=0,r=1;r<3;r++)l<(s=Math.abs(n[3*r]))&&(l=s,i=r);if(0!==i){const e=t[i];t[i]=t[0],t[0]=e,go(n,3,i,0)}if(Math.abs(n[4])<Math.abs(n[7])){const e=t[2];t[2]=t[1],t[1]=e,go(n,3,1,2)}for(r=0;r<2;r++)n[3*r+r]<0&&(n[3*r]=-n[3*r],n[3*r+1]=-n[3*r+1],n[3*r+2]=-n[3*r+2]);$o(n)<0&&(n[6]=-n[6],n[7]=-n[7],n[8]=-n[8]),Ko(n,n)}else Yo(n)}function aa(e,t,n){let r,o,a,i,s,l,c,u=0;const d=ho(n);for(r=0;r<n;r++){for(i=0,o=0;o<n;o++)(c=Math.abs(e[r*n+o]))>i&&(i=c);if(0===i)return uo(&quot;Unable to factor linear system&quot;),0;d[r]=1/i}for(o=0;o<n;o++){for(r=0;r<o;r++){for(s=e[r*n+o],a=0;a<r;a++)s-=e[r*n+a]*e[a*n+o];e[r*n+o]=s}for(i=0,r=o;r<n;r++){for(s=e[r*n+o],a=0;a<o;a++)s-=e[r*n+a]*e[a*n+o];e[r*n+o]=s,(l=d[r]*Math.abs(s))>=i&&(i=l,u=r)}if(o!==u){for(a=0;a<n;a++)l=e[u*n+a],e[u*n+a]=e[o*n+a],e[o*n+a]=l;d[u]=d[o]}if(t[o]=u,Math.abs(e[o*n+o])<=lo)return uo(&quot;Unable to factor linear system&quot;),0;if(o!==n-1)for(l=1/e[o*n+o],r=o+1;r<n;r++)e[r*n+o]*=l}return 1}function ia(e,t,n,r){let o,a,i,s,l;for(i=-1,o=0;o<r;o++){if(s=t[o],l=n[s],n[s]=n[o],i>=0)for(a=i;a<=o-1;a++)l-=e[o*r+a]*n[a];else 0!==l&&(i=o);n[o]=l}for(o=r-1;o>=0;o--){for(l=n[o],a=o+1;a<r;a++)l-=e[o*r+a]*n[a];n[o]=l/e[o*r+o]}}function sa(e,t,n){if(2===n){const n=ho(2),r=Wo(e[0],e[1],e[2],e[3]);return 0===r?0:(n[0]=(e[3]*t[0]-e[1]*t[1])/r,n[1]=(-e[2]*t[0]+e[0]*t[1])/r,t[0]=n[0],t[1]=n[1],1)}if(1===n)return 0===e[0]?0:(t[0]/=e[0],1);const r=ho(n);return 0===aa(e,r,n)?0:(ia(e,r,t,n),1)}function la(e,t,n){let r=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null;const o=(arguments.length>3&&void 0!==arguments[3]?arguments[3]:null)||ho(n),a=r||ho(n);if(0===aa(e,o,n))return null;for(let r=0;r<n;r++){for(let e=0;e<n;e++)a[e]=0;a[r]=1,ia(e,o,a,n);for(let e=0;e<n;e++)t[e*n+r]=a[e]}return t}function ca(e,t,n,r){if(e<n)return uo(&quot;Insufficient number of samples. Underdetermined.&quot;),0;let o,a,i;const s=ho(n*n),l=ho(n),c=ho(n*n);for(i=0;i<e;i++)for(o=0;o<n;o++)for(a=o;a<n;a++)s[o*n+a]+=t[i*n+o]*t[i*n+a];for(o=0;o<n;o++)for(a=0;a<o;a++)s[o*n+a]=s[a*n+o];for(ta(s,n,l,c),o=0;o<n;o++)r[o]=c[o*n+n-1];return 1}function ua(e,t){let n,r;const[o,a,i]=e,s=1/6;let l=o,c=o;a>l?l=a:a<c&&(c=a),i>l?l=i:i<c&&(c=i);const u=l;r=u>0?(l-c)/l:0,r>0?(n=o===l?s*(a-i)/(l-c):a===l?1/3+s*(i-o)/(l-c):2/3+s*(o-a)/(l-c),n<0&&(n+=1)):n=0,t[0]=n,t[1]=r,t[2]=u}function da(e,t){const[n,r,o]=e,a=1/3,i=1/6,s=2/3,l=5/6;let c,u,d;n>i&&n<=a?(u=1,c=(a-n)/i,d=0):n>a&&n<=.5?(u=1,d=(n-a)/i,c=0):n>.5&&n<=s?(d=1,u=(s-n)/i,c=0):n>s&&n<=l?(d=1,c=(n-s)/i,u=0):n>l&&n<=1?(c=1,d=(1-n)/i,u=0):(c=1,u=n/i,d=0),c=r*c+(1-r),u=r*u+(1-r),d=r*d+(1-r),c*=o,u*=o,d*=o,t[0]=c,t[1]=u,t[2]=d}function pa(e,t){const[n,r,o]=e;let a=(n+16)/116,i=r/500+a,s=a-o/200;a**3>.008856?a**=3:a=(a-16/116)/7.787,i**3>.008856?i**=3:i=(i-16/116)/7.787,s**3>.008856?s**=3:s=(s-16/116)/7.787,t[0]=.9505*i,t[1]=1*a,t[2]=1.089*s}function fa(e,t){const[n,r,o]=e;let a=n/.9505,i=r/1,s=o/1.089;a>.008856?a**=1/3:a=7.787*a+16/116,i>.008856?i**=1/3:i=7.787*i+16/116,s>.008856?s**=1/3:s=7.787*s+16/116,t[0]=116*i-16,t[1]=500*(a-i),t[2]=200*(i-s)}function ga(e,t){const[n,r,o]=e;let a=3.2406*n+-1.5372*r+-.4986*o,i=-.9689*n+1.8758*r+.0415*o,s=.0557*n+-.204*r+1.057*o;a>.0031308?a=1.055*a**(1/2.4)-.055:a*=12.92,i>.0031308?i=1.055*i**(1/2.4)-.055:i*=12.92,s>.0031308?s=1.055*s**(1/2.4)-.055:s*=12.92;let l=a;l<i&&(l=i),l<s&&(l=s),l>1&&(a/=l,i/=l,s/=l),a<0&&(a=0),i<0&&(i=0),s<0&&(s=0),t[0]=a,t[1]=i,t[2]=s}function ma(e,t){let[n,r,o]=e;n>.04045?n=((n+.055)/1.055)**2.4:n/=12.92,r>.04045?r=((r+.055)/1.055)**2.4:r/=12.92,o>.04045?o=((o+.055)/1.055)**2.4:o/=12.92,t[0]=.4124*n+.3576*r+.1805*o,t[1]=.2126*n+.7152*r+.0722*o,t[2]=.0193*n+.1192*r+.9505*o}function ha(e,t){const n=[0,0,0];ma(e,n),fa(n,t)}function va(e,t){const n=[0,0,0];pa(e,n),ga(n,t)}function Ta(e){return e[0]=1,e[1]=-1,e[2]=1,e[3]=-1,e[4]=1,e[5]=-1,e}function ya(e){return!(e[1]-e[0]<0)}function ba(e,t,n){return e<t?t:e>n?n:e}function xa(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[0,0,0];return r[0]=ba(e[0],t[0],n[0]),r[1]=ba(e[1],t[1],n[1]),r[2]=ba(e[2],t[2],n[2]),r}const Ca=fo(&quot;GetScalarTypeFittingRange&quot;),Sa=fo(&quot;GetAdjustedScalarRange&quot;);const Aa=e=>!Number.isFinite(e),{isFinite:Ia,isNaN:wa}=Number,Oa=wa;function Pa(){return[].concat([Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE])}function Ra(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:3;const n=new Array(t),r=new Array(t);for(let e=0;e<t;++e)n[e]=e,r[e]=e;for(let o=t-1;o>0;o--){let a=-1/0,i=0,s=0;for(let l=0;l<=o;++l){const c=n[l];for(let n=0;n<=o;++n){const o=r[n],u=Math.abs(e[c+t*o]);u>a&&(a=u,i=l,s=n)}}[n[o],n[i]]=[n[i],n[o]],[r[o],r[s]]=[r[s],r[o]]}const o=new Array(t*t).fill(0);for(let a=0;a<t;++a){const i=n[a]+t*r[a];o[i]=e[i]<0?-1:1}return o}function Ma(e){const t=Math.floor(255*e);return t>15?t.toString(16):`0${t.toString(16)}`}function Ea(e){return Math.round(255*e)}var Va,Da={Pi:()=>Math.PI,ldexp:function(e,t){return t>1023?e*2**1023*2**(t-1023):t<-1074?5e-324*e*2**(t+1074):e*2**t},radiansFromDegrees:vo,degreesFromRadians:To,round:yo,floor:bo,ceil:xo,ceilLog2:Ao,min:Co,max:So,arrayMin:function(e){let t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,n=1/0;for(let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,o=e.length;r<o;r+=t)e[r]<n&&(n=e[r]);return n},arrayMax:function(e){let t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,n=-1/0;for(let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,o=e.length;r<o;r+=t)n<e[r]&&(n=e[r]);return n},arrayRange:function(e){let t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,n=1/0,r=-1/0;for(let o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,a=e.length;o<a;o+=t)e[o]<n&&(n=e[o]),r<e[o]&&(r=e[o]);return[n,r]},isPowerOfTwo:Oo,nearestPowerOfTwo:wo,factorial:Io,binomial:function(e,t){let n=1;for(let r=1;r<=t;++r)n*=(e-r+1)/r;return Math.floor(n)},beginCombination:function(e,t){if(e<t)return 0;const n=ho(t);for(let e=0;e<t;++e)n[e]=e;return n},nextCombination:function(e,t,n){let r=0;for(let o=t-1;o>=0;--o)if(n[o]<e-t+o){let e=n[o]+1;for(;o<t;)n[o++]=e++;r=1;break}return r},randomSeed:function(e){oo(`${e}`,{global:!0}),po=e},getSeed:function(){return po},random:function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return e+((arguments.length>1&&void 0!==arguments[1]?arguments[1]:1)-e)*Math.random()},gaussian:Po,add:Ro,subtract:Mo,multiplyScalar:Eo,multiplyScalar2D:Vo,multiplyAccumulate:Do,multiplyAccumulate2D:function(e,t,n,r){return r[0]=e[0]+t[0]*n,r[1]=e[1]+t[1]*n,r},dot:Lo,outer:function(e,t,n){n[0]=e[0]*t[0],n[1]=e[0]*t[1],n[2]=e[0]*t[2],n[3]=e[1]*t[0],n[4]=e[1]*t[1],n[5]=e[1]*t[2],n[6]=e[2]*t[0],n[7]=e[2]*t[1],n[8]=e[2]*t[2]},cross:Bo,norm:No,normalize:Fo,perpendiculars:function(e,t,n,r){const o=e[0]*e[0],a=e[1]*e[1],i=e[2]*e[2],s=Math.sqrt(o+a+i);let l,c,u;o>a&&o>i?(l=0,c=1,u=2):a>i?(l=1,c=2,u=0):(l=2,c=0,u=1);const d=e[l]/s,p=e[c]/s,f=e[u]/s,g=Math.sqrt(d*d+f*f);if(0!==r){const e=Math.sin(r),o=Math.cos(r);t&&(t[l]=(f*o-d*p*e)/g,t[c]=e*g,t[u]=(-d*o-p*f*e)/g),n&&(n[l]=(-f*e-d*p*o)/g,n[c]=o*g,n[u]=(d*e-p*f*o)/g)}else t&&(t[l]=f/g,t[c]=0,t[u]=-d/g),n&&(n[l]=-d*p/g,n[c]=g,n[u]=-p*f/g)},projectVector:function(e,t,n){const r=Lo(t,t);if(0===r)return n[0]=0,n[1]=0,n[2]=0,!1;const o=Lo(e,t)/r;for(let e=0;e<3;e++)n[e]=t[e];return Eo(n,o),!0},projectVector2D:function(e,t,n){const r=ko(t,t);if(0===r)return n[0]=0,n[1]=0,!1;const o=ko(e,t)/r;for(let e=0;e<2;e++)n[e]=t[e];return Vo(n,o),!0},distance2BetweenPoints:Go,angleBetweenVectors:function(e,t){const n=[0,0,0];return Bo(e,t,n),Math.atan2(No(n),Lo(e,t))},gaussianAmplitude:function(e,t,n){const r=Math.abs(e-n);return 1/Math.sqrt(2*Math.PI*t)*Math.exp(-(r**2)/(2*t))},gaussianWeight:function(e,t,n){const r=Math.abs(e-n);return Math.exp(-(r**2)/(2*t))},dot2D:ko,outer2D:function(e,t,n){n[0]=e[0]*t[0],n[1]=e[0]*t[1],n[2]=e[1]*t[0],n[3]=e[1]*t[1]},norm2D:Uo,normalize2D:zo,determinant2x2:Wo,LUFactor3x3:function(e,t){let n,r,o;const a=[0,0,0];for(let t=0;t<3;t++)o=Math.abs(e[3*t]),(r=Math.abs(e[3*t+1]))>o&&(o=r),(r=Math.abs(e[3*t+2]))>o&&(o=r),a[t]=1/o;o=a[0]*Math.abs(e[0]),n=0,(r=a[1]*Math.abs(e[3]))>=o&&(o=r,n=1),(r=a[2]*Math.abs(e[6]))>=o&&(n=2),0!==n&&(go(e,3,n,0),a[n]=a[0]),t[0]=n,e[3]/=e[0],e[6]/=e[0],e[4]-=e[3]*e[1],e[7]-=e[6]*e[1],o=a[1]*Math.abs(e[4]),n=1,(r=a[2]*Math.abs(e[7]))>=o&&(n=2,go(e,3,1,2),a[2]=a[1]),t[1]=n,e[7]/=e[4],e[5]-=e[3]*e[2],e[8]-=e[6]*e[2]+e[7]*e[5],t[2]=2},LUSolve3x3:function(e,t,n){let r=n[t[0]];n[t[0]]=n[0],n[0]=r,r=n[t[1]],n[t[1]]=n[1],n[1]=r-e[3]*n[0],r=n[t[2]],n[t[2]]=n[2],n[2]=r-e[6]*n[0]-e[7]*n[1],n[2]/=e[8],n[1]=(n[1]-e[5]*n[2])/e[4],n[0]=(n[0]-e[1]*n[1]-e[2]*n[2])/e[0]},linearSolve3x3:function(e,t,n){const r=e[0],o=e[1],a=e[2],i=e[3],s=e[4],l=e[5],c=e[6],u=e[7],d=e[8],p=+Wo(s,u,l,d),f=-Wo(i,c,l,d),g=+Wo(i,c,s,u),m=-Wo(o,u,a,d),h=+Wo(r,c,a,d),v=-Wo(r,c,o,u),T=+Wo(o,s,a,l),y=-Wo(r,i,a,l),b=+Wo(r,i,o,s),x=r*p+o*f+a*g,C=p*t[0]+m*t[1]+T*t[2],S=f*t[0]+h*t[1]+y*t[2],A=g*t[0]+v*t[1]+b*t[2];n[0]=C/x,n[1]=S/x,n[2]=A/x},multiply3x3_vect3:Ho,multiply3x3_mat3:jo,multiplyMatrix:function(e,t,n,r,o,a,i){r!==o&&co(&quot;Number of columns of A must match number of rows of B.&quot;);const s=[...e],l=[...t];for(let e=0;e<n;e++)for(let t=0;t<a;t++){i[e*a+t]=0;for(let n=0;n<r;n++)i[e*a+t]+=s[e*r+n]*l[t+a*n]}},transpose3x3:Ko,invert3x3:function(e,t){const n=e[0],r=e[1],o=e[2],a=e[3],i=e[4],s=e[5],l=e[6],c=e[7],u=e[8],d=+Wo(i,c,s,u),p=-Wo(a,l,s,u),f=+Wo(a,l,i,c),g=-Wo(r,c,o,u),m=+Wo(n,l,o,u),h=-Wo(n,l,r,c),v=+Wo(r,i,o,s),T=-Wo(n,a,o,s),y=+Wo(n,a,r,i),b=n*d+r*p+o*f;0===b&&uo(&quot;Matrix has 0 determinant&quot;),t[0]=d/b,t[3]=p/b,t[6]=f/b,t[1]=g/b,t[4]=m/b,t[7]=h/b,t[2]=v/b,t[5]=T/b,t[8]=y/b},identity3x3:Yo,identity:Zo,isIdentity:function(e){return Xo(e,ao,arguments.length>1&&void 0!==arguments[1]?arguments[1]:so)},isIdentity3x3:function(e){return Xo(e,io,arguments.length>1&&void 0!==arguments[1]?arguments[1]:so)},determinant3x3:$o,quaternionToMatrix3x3:Qo,areEquals:qo,areMatricesEqual:Xo,roundNumber:Jo,roundVector:ea,matrix3x3ToQuaternion:na,multiplyQuaternion:function(e,t,n){const r=e[0]*t[0],o=e[0]*t[1],a=e[0]*t[2],i=e[0]*t[3],s=e[1]*t[0],l=e[1]*t[1],c=e[1]*t[2],u=e[1]*t[3],d=e[2]*t[0],p=e[2]*t[1],f=e[2]*t[2],g=e[2]*t[3],m=e[3]*t[0],h=e[3]*t[1],v=e[3]*t[2],T=e[3]*t[3];n[0]=r-l-f-T,n[1]=o+s+g-v,n[2]=a-u+d+h,n[3]=i+c-p+m},orthogonalize3x3:ra,diagonalize3x3:oa,singularValueDecomposition3x3:function(e,t,n,r){let o;const a=[...e],i=$o(a);if(i<0)for(o=0;o<9;o++)a[o]=-a[o];ra(a,t),Ko(a,a),jo(a,t,r),oa(r,n,r),jo(t,r,t),Ko(r,r),i<0&&(n[0]=-n[0],n[1]=-n[1],n[2]=-n[2])},solveLinearSystem:sa,invertMatrix:la,luFactorLinearSystem:aa,luSolveLinearSystem:ia,estimateMatrixCondition:function(e,t){let n=+Number.MAX_VALUE,r=-Number.MAX_VALUE;for(let n=0;n<t;n++)for(let o=n;o<t;o++)Math.abs(e[n*t+o])>r&&(r=Math.abs(e[n*t+o]));for(let r=0;r<t;r++)Math.abs(e[r*t+r])<n&&(n=Math.abs(e[r*t+r]));return 0===n?Number.MAX_VALUE:r/n},jacobi:function(e,t,n){return ta(e,3,t,n)},jacobiN:ta,solveHomogeneousLeastSquares:ca,solveLeastSquares:function(e,t,n,r,o,a){let i=!(arguments.length>6&&void 0!==arguments[6])||arguments[6];if(e<n||e<o)return uo(&quot;Insufficient number of samples. Underdetermined.&quot;),0;const s=ho(o);let l,c,u,d,p=1,f=0,g=0;if(i){for(u=0;u<o;u++)s[u]=1;for(c=0;c<e;c++)for(u=0;u<o;u++)Math.abs(r[c*o+u])>lo&&(p=0,s[u]=0);if(p&&1===o)return uo(&quot;Detected homogeneous system (Y=0), calling SolveHomogeneousLeastSquares()&quot;),ca(e,t,n,a);if(p)g=1;else for(u=0;u<o;u++)s[u]&&(g=1)}g&&(l=ho(n),f=ca(e,t,n,l));const m=ho(n*n),h=ho(n*n),v=ho(n*o);for(d=0;d<e;d++)for(c=0;c<n;c++){for(u=c;u<n;u++)m[c*n+u]+=t[d*n+c]*t[d*n+u];for(u=0;u<o;u++)v[c*o+u]+=t[d*n+c]*r[d*o+u]}for(c=0;c<n;c++)for(u=0;u<c;u++)m[c*n+u]=m[u*n+c];const T=la(m,h,n);if(T)for(c=0;c<n;c++)for(u=0;u<o;u++)for(a[c*o+u]=0,d=0;d<n;d++)a[c*o+u]+=h[c*n+d]*v[d*o+u];if(g)for(u=0;u<o;u++)if(s[u])for(c=0;c<n;c++)a[c*o+u]=l[c*o];return g?f&&T:T},hex2float:function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[0,.5,1];switch(e.length){case 3:return t[0]=17*parseInt(e[0],16)/255,t[1]=17*parseInt(e[1],16)/255,t[2]=17*parseInt(e[2],16)/255,t;case 4:return t[0]=17*parseInt(e[1],16)/255,t[1]=17*parseInt(e[2],16)/255,t[2]=17*parseInt(e[3],16)/255,t;case 6:return t[0]=parseInt(e.substr(0,2),16)/255,t[1]=parseInt(e.substr(2,2),16)/255,t[2]=parseInt(e.substr(4,2),16)/255,t;case 7:return t[0]=parseInt(e.substr(1,2),16)/255,t[1]=parseInt(e.substr(3,2),16)/255,t[2]=parseInt(e.substr(5,2),16)/255,t;case 9:return t[0]=parseInt(e.substr(1,2),16)/255,t[1]=parseInt(e.substr(3,2),16)/255,t[2]=parseInt(e.substr(5,2),16)/255,t[3]=parseInt(e.substr(7,2),16)/255,t;default:return t}},rgb2hsv:ua,hsv2rgb:da,lab2xyz:pa,xyz2lab:fa,xyz2rgb:ga,rgb2xyz:ma,rgb2lab:ha,lab2rgb:va,uninitializeBounds:Ta,areBoundsInitialized:ya,computeBoundsFromPoints:function(e,t,n){return n[0]=Math.min(e[0],t[0]),n[1]=Math.max(e[0],t[0]),n[2]=Math.min(e[1],t[1]),n[3]=Math.max(e[1],t[1]),n[4]=Math.min(e[2],t[2]),n[5]=Math.max(e[2],t[2]),n},clampValue:ba,clampVector:xa,clampAndNormalizeValue:function(e,t){let n=0;return t[0]!==t[1]&&(n=e<t[0]?t[0]:e>t[1]?t[1]:e,n=(n-t[0])/(t[1]-t[0])),n},getScalarTypeFittingRange:Ca,getAdjustedScalarRange:Sa,extentIsWithinOtherExtent:function(e,t){if(!e||!t)return 0;for(let n=0;n<6;n+=2)if(e[n]<t[n]||e[n]>t[n+1]||e[n+1]<t[n]||e[n+1]>t[n+1])return 0;return 1},boundsIsWithinOtherBounds:function(e,t,n){if(!e||!t)return 0;for(let r=0;r<6;r+=2)if(e[r]+n[r/2]<t[r]||e[r]-n[r/2]>t[r+1]||e[r+1]+n[r/2]<t[r]||e[r+1]-n[r/2]>t[r+1])return 0;return 1},pointIsWithinBounds:function(e,t,n){if(!e||!t||!n)return 0;for(let r=0;r<3;r++)if(e[r]+n[r]<t[2*r]||e[r]-n[r]>t[2*r+1])return 0;return 1},solve3PointCircle:function(e,t,n,r){const o=ho(3),a=ho(3),i=ho(3),s=ho(3),l=ho(3),c=ho(3);for(let r=0;r<3;++r)o[r]=e[r]-t[r],a[r]=t[r]-n[r],i[r]=n[r]-e[r],s[r]=-o[r],l[r]=-a[r],c[r]=-i[r];const u=No(s),d=No(l),p=No(i),f=ho(3);Bo(o,a,f);const g=No(f),m=u*d*p/(2*g),h=2*g*g,v=d*d*Lo(o,c)/h,T=p*p*Lo(s,a)/h,y=u*u*Lo(i,l)/h;for(let o=0;o<3;++o)r[o]=v*e[o]+T*t[o]+y*n[o];return m},inf:1/0,negInf:-1/0,isInf:Aa,isNan:wa,isNaN:wa,isFinite:Ia,createUninitializedBounds:Pa,getMajorAxisIndex:function(e){let t=-1,n=-1;for(let r=0;r<e.length;r++){const o=Math.abs(e[r]);o>t&&(n=r,t=o)}return n},getSparseOrthogonalMatrix:Ra,floatToHex2:Ma,floatRGB2HexCode:function(e){return`${arguments.length>1&&void 0!==arguments[1]?arguments[1]:&quot;#&quot;}${e.map(Ma).join(&quot;&quot;)}`},float2CssRGBA:function(e){return 3===e.length?`rgb(${e.map(Ea).join(&quot;, &quot;)})`:`rgba(${Ea(e[0]||0)}, ${Ea(e[1]||0)}, ${Ea(e[2]||0)}, ${e[3]||0})`}};function La(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3];return e[0]=n[0]*r+n[4]*o+n[8]*a+n[12]*i,e[1]=n[1]*r+n[5]*o+n[9]*a+n[13]*i,e[2]=n[2]*r+n[6]*o+n[10]*a+n[14]*i,e[3]=n[3]*r+n[7]*o+n[11]*a+n[15]*i,e}function Ba(){var e=new s(4);return s!=Float32Array&&(e[0]=0,e[1]=0,e[2]=0),e[3]=1,e}function Na(e,t,n){n*=.5;var r=Math.sin(n);return e[0]=r*t[0],e[1]=r*t[1],e[2]=r*t[2],e[3]=Math.cos(n),e}function Fa(e,t,n){var r=t[0],o=t[1],a=t[2],i=t[3],s=n[0],l=n[1],c=n[2],u=n[3];return e[0]=r*u+i*s+o*c-a*l,e[1]=o*u+i*l+a*s-r*c,e[2]=a*u+i*c+r*l-o*s,e[3]=i*u-r*s-o*l-a*c,e}Va=new s(4),s!=Float32Array&&(Va[0]=0,Va[1]=0,Va[2]=0,Va[3]=0);var _a=function(e,t,n,r){var o=new s(4);return o[0]=e,o[1]=t,o[2]=n,o[3]=r,o};fn(),mn(1,0,0),mn(0,1,0),Ba(),Ba(),se();const ka={};function Ga(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ka,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;transform&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkImplicitFunction&quot;),e.functionValue=n=>{if(!t.transform)return e.evaluateFunction(n);const r=[];return t.transform.transformPoint(n,r),e.evaluateFunction(r)},e.evaluateFunction=e=>{Wt.vtkErrorMacro(&quot;not implemented&quot;)}}(e,t)}var Ua={newInstance:Wt.newInstance(Ga,&quot;vtkImplicitFunction&quot;),extend:Ga};const za=1e-6,Wa=&quot;coincide&quot;,Ha=&quot;disjoint&quot;;function ja(e,t,n){const r=n[0]*(e[0]-t[0])+n[1]*(e[1]-t[1])+n[2]*(e[2]-t[2]);return Math.abs(r)}function Ka(e,t,n,r){const o=[];Mo(e,t,o);const a=Lo(n,o);r[0]=e[0]-a*n[0],r[1]=e[1]-a*n[1],r[2]=e[2]-a*n[2]}function $a(e,t,n){const r=Lo(e,t);let o=Lo(t,t);return 0===o&&(o=1),n[0]=e[0]-r*t[0]/o,n[1]=e[1]-r*t[1]/o,n[2]=e[2]-r*t[2]/o,n}function qa(e,t,n,r){const o=[];Mo(e,t,o);const a=Lo(n,o),i=Lo(n,n);0!==i?(r[0]=e[0]-a*n[0]/i,r[1]=e[1]-a*n[1]/i,r[2]=e[2]-a*n[2]/i):(r[0]=e[0],r[1]=e[1],r[2]=e[2])}function Xa(e,t,n,r){const o={intersection:!1,betweenPoints:!1,t:Number.MAX_VALUE,x:[]},a=[],i=[];Mo(t,e,a),Mo(n,e,i);const s=Lo(r,i),l=Lo(r,a);let c,u;return c=l<0?-l:l,u=s<0?-s*za:s*za,c<=u||(o.t=s/l,o.x[0]=e[0]+o.t*a[0],o.x[1]=e[1]+o.t*a[1],o.x[2]=e[2]+o.t*a[2],o.intersection=!0,o.betweenPoints=o.t>=0&&o.t<=1),o}function Ya(e,t,n,r){const o={intersection:!1,l0:[],l1:[],error:null},a=[];Bo(t,r,a);const i=a.map((e=>Math.abs(e)));if(i[0]+i[1]+i[2]<za){const r=[];return Mo(e,n,r),0===Lo(t,r)?o.error=Wa:o.error=Ha,o}let s;s=i[0]>i[1]&&i[0]>i[2]?&quot;x&quot;:i[1]>i[2]?&quot;y&quot;:&quot;z&quot;;const l=[],c=-Lo(t,e),u=-Lo(r,n);switch(s){case&quot;x&quot;:l[0]=0,l[1]=(u*t[2]-c*r[2])/a[0],l[2]=(c*r[1]-u*t[1])/a[0];break;case&quot;y&quot;:l[0]=(c*r[2]-u*t[2])/a[1],l[1]=0,l[2]=(u*t[0]-c*r[0])/a[1];break;case&quot;z&quot;:l[0]=(u*t[1]-c*r[1])/a[2],l[1]=(c*r[0]-u*t[0])/a[2],l[2]=0}return o.l0=l,Ro(l,a,o.l1),o.intersection=!0,o}const Za={evaluate:function(e,t,n){return e[0]*(n[0]-t[0])+e[1]*(n[1]-t[1])+e[2]*(n[2]-t[2])},distanceToPlane:ja,projectPoint:Ka,projectVector:$a,generalizedProjectPoint:qa,intersectWithLine:Xa,intersectWithPlane:Ya,DISJOINT:Ha,COINCIDE:Wa},Qa={normal:[0,0,1],origin:[0,0,0]};function Ja(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Qa,n),Ua.extend(e,t,n),Wt.setGetArray(e,t,[&quot;normal&quot;,&quot;origin&quot;],3),function(e,t){t.classHierarchy.push(&quot;vtkPlane&quot;),e.distanceToPlane=e=>ja(e,t.origin,t.normal),e.projectPoint=(e,n)=>{Ka(e,t.origin,t.normal,n)},e.projectVector=(e,n)=>$a(e,t.normal,n),e.push=e=>{if(0!==e)for(let n=0;n<3;n++)t.origin[n]+=e*t.normal[n]},e.generalizedProjectPoint=(e,n)=>{qa(e,t.origin,t.normal,n)},e.evaluateFunction=(e,n,r)=>Array.isArray(e)?t.normal[0]*(e[0]-t.origin[0])+t.normal[1]*(e[1]-t.origin[1])+t.normal[2]*(e[2]-t.origin[2]):t.normal[0]*(e-t.origin[0])+t.normal[1]*(n-t.origin[1])+t.normal[2]*(r-t.origin[2]),e.evaluateGradient=e=>[t.normal[0],t.normal[1],t.normal[2]],e.intersectWithLine=(e,n)=>Xa(e,n,t.origin,t.normal),e.intersectWithPlane=(e,n)=>Ya(e,n,t.origin,t.normal)}(e,t)}var ei={newInstance:Wt.newInstance(Ja,&quot;vtkPlane&quot;),extend:Ja,...Za};const ti=[Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE];function ni(e,t){return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]&&e[3]===t[3]&&e[4]===t[4]&&e[5]===t[5]}function ri(e){return e?.length>=6&&e[0]<=e[1]&&e[2]<=e[3]&&e[4]<=e[5]}function oi(e,t){return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[4]=t[4],e[5]=t[5],e}function ai(e){return oi(e,ti)}function ii(e,t,n,r){const[o,a,i,s,l,c]=e;return e[0]=o<t?o:t,e[1]=a>t?a:t,e[2]=i<n?i:n,e[3]=s>n?s:n,e[4]=l<r?l:r,e[5]=c>r?c:r,e}function si(e,t){if(0===t.length)return e;if(Array.isArray(t[0]))for(let n=0;n<t.length;++n)ii(e,...t[n]);else for(let n=0;n<t.length;n+=3)ii(e,...t.slice(n,n+3));return e}function li(e,t,n,r,o,a,i){const[s,l,c,u,d,p]=e;return void 0===i?(e[0]=Math.min(t[0],s),e[1]=Math.max(t[1],l),e[2]=Math.min(t[2],c),e[3]=Math.max(t[3],u),e[4]=Math.min(t[4],d),e[5]=Math.max(t[5],p)):(e[0]=Math.min(t,s),e[1]=Math.max(n,l),e[2]=Math.min(r,c),e[3]=Math.max(o,u),e[4]=Math.min(a,d),e[5]=Math.max(i,p)),e}function ci(e,t,n,r){const[o,a,i,s,l,c]=e;return e[0]=t,e[1]=t>a?t:a,e[2]=n,e[3]=n>s?n:s,e[4]=r,e[5]=r>c?r:c,o!==t||i!==n||l!==r}function ui(e,t,n,r){const[o,a,i,s,l,c]=e;return e[0]=t<o?t:o,e[1]=t,e[2]=n<i?n:i,e[3]=n,e[4]=r<l?r:l,e[5]=r,a!==t||s!==n||c!==r}function di(e,t){return null==t?function(e){const t=[0,0,0];let n=-1,r=0,o=0;for(let a=0;a<3;++a)o=e[2*a+1]-e[2*a],o>r&&(r=o,n=a),t[a]=o>0?1:0;if(n<0)return di(e,.5);for(let n=0;n<3;++n)if(!t[n]){const t=.005*r;e[2*n]-=t,e[2*n+1]+=t}return e}(e):(e[0]-=t,e[1]+=t,e[2]-=t,e[3]+=t,e[4]-=t,e[5]+=t,e)}function pi(e,t,n,r){return!!ri(e)&&(t>=0?(e[0]*=t,e[1]*=t):(e[0]=t*e[1],e[1]=t*e[0]),n>=0?(e[2]*=n,e[3]*=n):(e[2]=n*e[3],e[3]=n*e[2]),r>=0?(e[4]*=r,e[5]*=r):(e[4]=r*e[5],e[5]=r*e[4]),!0)}function fi(e){return[.5*(e[0]+e[1]),.5*(e[2]+e[3]),.5*(e[4]+e[5])]}function gi(e,t){return e[2*t+1]-e[2*t]}function mi(e){return[gi(e,0),gi(e,1),gi(e,2)]}function hi(e){return e.slice(0,2)}function vi(e){return e.slice(2,4)}function Ti(e){return e.slice(4,6)}function yi(e){const t=mi(e);return t[0]>t[1]?t[0]>t[2]?t[0]:t[2]:t[1]>t[2]?t[1]:t[2]}function bi(e){if(ri(e)){const t=mi(e);return t[0]*t[0]+t[1]*t[1]+t[2]*t[2]}return null}function xi(e){const t=bi(e);return null!==t?Math.sqrt(t):null}function Ci(e){return[e[0],e[2],e[4]]}function Si(e){return[e[1],e[3],e[5]]}function Ai(e,t){return e<=0&&t>=0||e>=0&&t<=0}function Ii(e,t){return t[0]=[e[0],e[2],e[4]],t[1]=[e[0],e[2],e[5]],t[2]=[e[0],e[3],e[4]],t[3]=[e[0],e[3],e[5]],t[4]=[e[1],e[2],e[4]],t[5]=[e[1],e[2],e[5]],t[6]=[e[1],e[3],e[4]],t[7]=[e[1],e[3],e[5]],t}function wi(e,t,n){return t[0]=e[0],t[1]=e[2],t[2]=e[4],n[0]=e[1],n[1]=e[3],n[2]=e[5],t}function Oi(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[];const r=Ii(e,[]);for(let e=0;e<r.length;++e)In(r[e],r[e],t);return ai(n),si(n,r)}function Pi(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return t[0]=.5*(e[1]-e[0]),t[1]=.5*(e[3]-e[2]),t[2]=.5*(e[5]-e[4]),t}function Ri(e,t,n,r){const o=[].concat(ti),a=e.getData();for(let e=0;e<a.length;e+=3){const i=[a[e],a[e+1],a[e+2]],s=Lo(i,t);o[0]=Math.min(s,o[0]),o[1]=Math.max(s,o[1]);const l=Lo(i,n);o[2]=Math.min(l,o[2]),o[3]=Math.max(l,o[3]);const c=Lo(i,r);o[4]=Math.min(c,o[4]),o[5]=Math.max(c,o[5])}return o}function Mi(e,t,n,r,o){let a=!0;const i=[];let s=0;const l=[],c=[0,0,0];for(let n=0;n<3;n++)t[n]<e[2*n]?(i[n]=1,c[n]=e[2*n],a=!1):t[n]>e[2*n+1]?(i[n]=0,c[n]=e[2*n+1],a=!1):i[n]=2;if(a)return r[0]=t[0],r[1]=t[1],r[2]=t[2],o[0]=0,1;for(let e=0;e<3;e++)2!==i[e]&&0!==n[e]?l[e]=(c[e]-t[e])/n[e]:l[e]=-1;for(let e=0;e<3;e++)l[s]<l[e]&&(s=e);if(l[s]>1||l[s]<0)return 0;o[0]=l[s];for(let o=0;o<3;o++)if(s!==o){if(r[o]=t[o]+l[s]*n[o],r[o]<e[2*o]||r[o]>e[2*o+1])return 0}else r[o]=c[o];return 1}function Ei(e,t,n){const r=[];let o=0,a=1,i=1;for(let s=4;s<=5;++s){r[2]=e[s];for(let s=2;s<=3;++s){r[1]=e[s];for(let s=0;s<=1;++s)if(r[0]=e[s],o=ei.evaluate(n,t,r),i&&(a=o>=0?1:-1,i=0),0===o||a>0&&o<0||a<0&&o>0)return 1}}return 0}function Vi(e,t){if(!ri(e)||!ri(t))return!1;const n=[0,0,0,0,0,0];let r;for(let o=0;o<3;o++)if(r=!1,t[2*o]>=e[2*o]&&t[2*o]<=e[2*o+1]?(r=!0,n[2*o]=t[2*o]):e[2*o]>=t[2*o]&&e[2*o]<=t[2*o+1]&&(r=!0,n[2*o]=e[2*o]),t[2*o+1]>=e[2*o]&&t[2*o+1]<=e[2*o+1]?(r=!0,n[2*o+1]=t[2*o+1]):e[2*o+1]>=t[2*o]&&e[2*o+1]<=t[2*o+1]&&(r=!0,n[2*o+1]=e[2*o+1]),!r)return!1;return e[0]=n[0],e[1]=n[1],e[2]=n[2],e[3]=n[3],e[4]=n[4],e[5]=n[5],!0}function Di(e,t){if(!ri(e)||!ri(t))return!1;for(let n=0;n<3;n++)if(!(t[2*n]>=e[2*n]&&t[2*n]<=e[2*n+1]||e[2*n]>=t[2*n]&&e[2*n]<=t[2*n+1]||t[2*n+1]>=e[2*n]&&t[2*n+1]<=e[2*n+1]||e[2*n+1]>=t[2*n]&&e[2*n+1]<=t[2*n+1]))return!1;return!0}function Li(e,t,n,r){return!(t<e[0]||t>e[1]||n<e[2]||n>e[3]||r<e[4]||r>e[5])}function Bi(e,t,n){const r=[[0,1,2,3,4,5,6,7],[0,1,4,5,2,3,6,7],[0,2,4,6,1,3,5,7]],o=[0,0,0,0,0,0,0,0];let a=0;for(let r=0;r<2;r++)for(let i=2;i<4;i++)for(let s=4;s<6;s++){const l=[e[r],e[i],e[s]];o[a++]=ei.evaluate(n,t,l)}let i=2;for(;i--&&!(Ai(o[r[i][0]],o[r[i][4]])&&Ai(o[r[i][1]],o[r[i][5]])&&Ai(o[r[i][2]],o[r[i][6]])&&Ai(o[r[i][3]],o[r[i][7]])););if(i<0)return!1;const s=Math.sign(n[i]),l=Math.abs((e[2*i+1]-e[2*i])*n[i]);let c=s>0?1:0;for(let e=0;e<4;e++){if(0===l)continue;const t=Math.abs(o[r[i][e]])/l;s>0&&t<c&&(c=t),s<0&&t>c&&(c=t)}const u=(1-c)*e[2*i]+c*e[2*i+1];return s>0?e[2*i]=u:e[2*i+1]=u,!0}function Ni(e,t){for(let e=0;e<3;++e)t[e]=t[e]<1?1:t[e];let n=t[0]*t[1]*t[2];for(;n>e;){for(let e=0;e<3;++e)t[e]=t[e]>1?t[e]-1:1;n=t[0]*t[1]*t[2]}}function Fi(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[];t=t<=0?1:t;let o=0;const a=[0,0,0];let i=-1,s=0;const l=mi(e),c=l[0]+l[1]+l[2],u=c*(.001/3);for(let e=0;e<3;++e)l[e]>s&&(i=e,s=l[e]),l[e]>u?(a[e]=1,o++):a[e]=0;const d=Ci(e),p=Si(e);if(o<1)return n[0]=1,n[1]=1,n[2]=1,r[0]=d[0]-.5,r[1]=p[0]+.5,r[2]=d[1]-.5,r[3]=p[1]+.5,r[4]=d[2]-.5,r[5]=p[2]+.5,1;let f=t;f/=a[0]?l[0]/c:1,f/=a[1]?l[1]/c:1,f/=a[2]?l[2]/c:1,f**=1/o;for(let e=0;e<3;++e)n[e]=a[e]?Math.floor(f*l[e]/c):1,n[e]=n[e]<1?1:n[e];Ni(t,n);const g=.5*l[i]/n[i];for(let e=0;e<3;++e)a[e]?(r[2*e]=d[e],r[2*e+1]=p[e]):(r[2*e]=d[e]-g,r[2*e+1]=p[e]+g);return n[0]*n[1]*n[2]}function _i(e,t){if(e[0]>=t[0]&&e[0]<=t[1]&&e[1]>=t[2]&&e[1]<=t[3]&&e[2]>=t[4]&&e[2]<=t[5])return 0;const n=[0,0,0];return e[0]<t[0]?n[0]=t[0]-e[0]:e[0]>t[1]&&(n[0]=e[0]-t[1]),e[1]<t[2]?n[1]=t[2]-e[1]:e[1]>t[3]&&(n[1]=e[1]-t[3]),e[2]<t[4]?n[2]=t[4]-e[2]:e[2]>t[5]&&(n[2]=e[2]-t[5]),Lo(n,n)}class ki{constructor(e){this.bounds=e,this.bounds||(this.bounds=new Float64Array(ti))}getBounds(){return this.bounds}equals(e){return ni(this.bounds,e)}isValid(){return ri(this.bounds)}setBounds(e){return oi(this.bounds,e)}reset(){return ai(this.bounds)}addPoint(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return ii(this.bounds,...t)}addPoints(e){return si(this.bounds,e)}addBounds(e,t,n,r,o,a){return li(this.bounds,e,t,n,r,o,a)}setMinPoint(e,t,n){return ci(this.bounds,e,t,n)}setMaxPoint(e,t,n){return ui(this.bounds,e,t,n)}inflate(e){return di(this.bounds,e)}scale(e,t,n){return pi(this.bounds,e,t,n)}getCenter(){return fi(this.bounds)}getLength(e){return gi(this.bounds,e)}getLengths(){return mi(this.bounds)}getMaxLength(){return yi(this.bounds)}getDiagonalLength(){return xi(this.bounds)}getDiagonalLength2(){return bi(this.bounds)}getMinPoint(){return Ci(this.bounds)}getMaxPoint(){return Si(this.bounds)}getXRange(){return hi(this.bounds)}getYRange(){return vi(this.bounds)}getZRange(){return Ti(this.bounds)}getCorners(e){return Ii(this.bounds,e)}computeCornerPoints(e,t){return wi(this.bounds,e,t)}computeLocalBounds(e,t,n){return Ri(this.bounds,e,t,n)}transformBounds(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return Oi(this.bounds,e,t)}computeScale3(e){return Pi(this.bounds,e)}cutWithPlane(e,t){return Bi(this.bounds,e,t)}intersectBox(e,t,n,r){return Mi(this.bounds,e,t,n,r)}intersectPlane(e,t){return Ei(this.bounds,e,t)}intersect(e){return Vi(this.bounds,e)}intersects(e){return Di(this.bounds,e)}containsPoint(e,t,n){return Li(this.bounds,e,t,n)}contains(e){return Di(this.bounds,e)}computeDivisions(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[];return Fi(this.bounds,e,t,n)}distance2ToBounds(e){return _i(e,this.bounds)}}var Gi={newInstance:function(e){const t=e&&e.bounds;return new ki(t)},equals:ni,isValid:ri,setBounds:oi,reset:ai,addPoint:ii,addPoints:si,addBounds:li,setMinPoint:ci,setMaxPoint:ui,inflate:di,scale:pi,scaleAboutCenter:function(e,t,n,r){if(!ri(e))return!1;const o=fi(e);return e[0]-=o[0],e[1]-=o[0],e[2]-=o[1],e[3]-=o[1],e[4]-=o[2],e[5]-=o[2],pi(e,t,n,r),e[0]+=o[0],e[1]+=o[0],e[2]+=o[1],e[3]+=o[1],e[4]+=o[2],e[5]+=o[2],!0},getCenter:fi,getLength:gi,getLengths:mi,getMaxLength:yi,getDiagonalLength:xi,getDiagonalLength2:bi,getMinPoint:Ci,getMaxPoint:Si,getXRange:hi,getYRange:vi,getZRange:Ti,getCorners:Ii,computeCornerPoints:wi,computeLocalBounds:Ri,transformBounds:Oi,computeScale3:Pi,cutWithPlane:Bi,intersectBox:Mi,intersectPlane:Ei,intersect:Vi,intersects:Di,containsPoint:Li,contains:function(e,t){return!!Di(e,t)&&!!Li(e,...Ci(t))&&!!Li(e,...Si(t))},computeDivisions:Fi,clampDivisions:Ni,distance2ToBounds:_i,INIT_BOUNDS:ti},Ui={CoordinateSystem:{DISPLAY:0,WORLD:1}};const{CoordinateSystem:zi}=Ui;function Wi(e){return()=>Wt.vtkErrorMacro(`vtkProp::${e} - NOT IMPLEMENTED`)}const Hi={allocatedRenderTime:10,coordinateSystem:zi.WORLD,dragable:!0,estimatedRenderTime:0,paths:null,pickable:!0,renderTimeMultiplier:1,savedEstimatedRenderTime:0,textures:[],useBounds:!0,visibility:!0};function ji(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Hi,n),Wt.obj(e,t),Wt.get(e,t,[&quot;estimatedRenderTime&quot;,&quot;allocatedRenderTime&quot;]),Wt.setGet(e,t,[&quot;_parentProp&quot;,&quot;coordinateSystem&quot;,&quot;dragable&quot;,&quot;pickable&quot;,&quot;renderTimeMultiplier&quot;,&quot;useBounds&quot;,&quot;visibility&quot;]),Wt.moveToProtected(e,t,[&quot;parentProp&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkProp&quot;),e.getMTime=()=>{let e=t.mtime;for(let n=0;n<t.textures.length;++n){const r=t.textures[n].getMTime();r>e&&(e=r)}return e},e.processSelectorPixelBuffers=(e,t)=>{},e.getNestedProps=()=>null,e.getActors=()=>[],e.getActors2D=()=>[],e.getVolumes=()=>[],e.pick=Wi(&quot;pick&quot;),e.hasKey=Wi(&quot;hasKey&quot;),e.getNestedVisibility=()=>t.visibility&&(!t._parentProp||t._parentProp.getNestedVisibility()),e.getNestedPickable=()=>t.pickable&&(!t._parentProp||t._parentProp.getNestedPickable()),e.getNestedDragable=()=>t.dragable&&(!t._parentProp||t._parentProp.getNestedDragable()),e.getRedrawMTime=()=>t.mtime,e.setEstimatedRenderTime=e=>{t.estimatedRenderTime=e,t.savedEstimatedRenderTime=e},e.restoreEstimatedRenderTime=()=>{t.estimatedRenderTime=t.savedEstimatedRenderTime},e.addEstimatedRenderTime=e=>{t.estimatedRenderTime+=e},e.setAllocatedRenderTime=e=>{t.allocatedRenderTime=e,t.savedEstimatedRenderTime=t.estimatedRenderTime,t.estimatedRenderTime=0},e.getSupportsSelection=()=>!1,e.getTextures=()=>t.textures,e.hasTexture=e=>-1!==t.textures.indexOf(e),e.addTexture=n=>{n&&!e.hasTexture(n)&&(t.textures=t.textures.concat(n),e.modified())},e.removeTexture=n=>{const r=t.textures.filter((e=>e!==n));t.textures.length!==r.length&&(t.textures=r,e.modified())},e.removeAllTextures=()=>{t.textures=[],e.modified()},e.setCoordinateSystemToWorld=()=>e.setCoordinateSystem(zi.WORLD),e.setCoordinateSystemToDisplay=()=>e.setCoordinateSystem(zi.DISPLAY)}(e,t)}var Ki={newInstance:Wt.newInstance(ji,&quot;vtkProp&quot;),extend:ji,...Ui};const $i={origin:[0,0,0],position:[0,0,0],orientation:[0,0,0],rotation:null,scale:[1,1,1],bounds:[...Gi.INIT_BOUNDS],properties:[],userMatrix:null,userMatrixMTime:null,cachedProp3D:null,isIdentity:!0,matrixMTime:null};function qi(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,$i,n),Ki.extend(e,t,n),t.matrixMTime={},Wt.obj(t.matrixMTime),Wt.get(e,t,[&quot;isIdentity&quot;]),Wt.getArray(e,t,[&quot;orientation&quot;]),Wt.setGetArray(e,t,[&quot;origin&quot;,&quot;position&quot;,&quot;scale&quot;],3),Wt.setGet(e,t,[&quot;properties&quot;]),t.matrix=m(new Float64Array(16)),t.rotation=m(new Float64Array(16)),t.userMatrix=m(new Float64Array(16)),t.transform=null,function(e,t){t.classHierarchy.push(&quot;vtkProp3D&quot;),e.addPosition=n=>{t.position=t.position.map(((e,t)=>e+n[t])),e.modified()},e.getOrientationWXYZ=()=>{const e=Ba();F(e,t.rotation);const n=new Float64Array(3),r=function(e,t){var n=2*Math.acos(t[3]),r=Math.sin(n/2);return r>i?(e[0]=t[0]/r,e[1]=t[1]/r,e[2]=t[2]/r):(e[0]=1,e[1]=0,e[2]=0),n}(n,e);return[To(r),n[0],n[1],n[2]]},e.getOrientationQuaternion=function(){return F(arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],t.rotation)},e.rotateX=n=>{0!==n&&(A(t.rotation,t.rotation,vo(n)),e.modified())},e.rotateY=n=>{0!==n&&(I(t.rotation,t.rotation,vo(n)),e.modified())},e.rotateZ=n=>{0!==n&&(w(t.rotation,t.rotation,vo(n)),e.modified())},e.rotateWXYZ=(n,r,o,a)=>{if(0===n||0===r&&0===o&&0===a)return;const i=vo(n),s=Ba();Na(s,[r,o,a],i);const l=new Float64Array(16);G(l,s),b(t.rotation,t.rotation,l),e.modified()},e.rotateQuaternion=n=>{if(Math.abs(n[3])>=.999999)return;const r=G(new Float64Array(16),n);b(t.rotation,t.rotation,r),e.modified()},e.setOrientation=(n,r,o)=>(n!==t.orientation[0]||r!==t.orientation[1]||o!==t.orientation[2])&&(t.orientation=[n,r,o],m(t.rotation),e.rotateZ(o),e.rotateX(n),e.rotateY(r),e.modified(),!0),e.setOrientationFromQuaternion=n=>{const r=u();return G(r,n),!Xo(r,t.rotation)&&(t.rotation=r,e.modified(),!0)},e.setUserMatrix=n=>!Xo(t.userMatrix,n)&&(p(t.userMatrix,n),e.modified(),!0),e.getMatrix=()=>(e.computeMatrix(),t.matrix),e.computeMatrix=()=>{if(e.getMTime()>t.matrixMTime.getMTime()){m(t.matrix),t.userMatrix&&b(t.matrix,t.matrix,t.userMatrix),x(t.matrix,t.matrix,t.origin),x(t.matrix,t.matrix,t.position),b(t.matrix,t.matrix,t.rotation),C(t.matrix,t.matrix,t.scale),x(t.matrix,t.matrix,[-t.origin[0],-t.origin[1],-t.origin[2]]),h(t.matrix,t.matrix),t.isIdentity=!0;for(let e=0;e<4;++e)for(let n=0;n<4;++n)(e===n?1:0)!==t.matrix[e+4*n]&&(t.isIdentity=!1);t.matrixMTime.modified()}},e.getBoundsByReference=()=>{if(null===t.mapper)return t.bounds;const n=t.mapper.getBounds();if(!n||6!==n.length)return n;if(n[0]>n[1])return t.mapperBounds=n,t.bounds=[...Gi.INIT_BOUNDS],t.boundsMTime.modified(),n;if(!t.mapperBounds||!n.every(((e,r)=>n[r]===t.mapperBounds[r]))||e.getMTime()>t.boundsMTime.getMTime()){Wt.vtkDebugMacro(&quot;Recomputing bounds...&quot;),t.mapperBounds=n,e.computeMatrix();const r=new Float64Array(16);h(r,t.matrix),Gi.transformBounds(n,r,t.bounds),t.boundsMTime.modified()}return t.bounds},e.getBounds=()=>{const t=e.getBoundsByReference();try{return[...t]}catch{return t}},e.getCenter=()=>Gi.getCenter(t.bounds),e.getLength=()=>Gi.getLength(t.bounds),e.getXRange=()=>Gi.getXRange(t.bounds),e.getYRange=()=>Gi.getYRange(t.bounds),e.getZRange=()=>Gi.getZRange(t.bounds),e.getUserMatrix=()=>t.userMatrix,e.onModified((function(){e.computeMatrix()})),e.getProperty=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return null==t.properties[n]&&(t.properties[n]=e.makeProperty?.()),t.properties[n]},e.getProperties=()=>(0===t.properties.length&&(t.properties[0]=e.makeProperty?.()),t.properties),e.setProperty=(e,n)=>{const r=Number.isInteger(e),[o,a]=r?[e,n]:[0,e];return t.properties[o]!==a&&(t.properties[o]=a,!0)},e.getMTime=()=>{let e=t.mtime;return t.properties.forEach((t=>{if(null!==t){const n=t.getMTime();e=n>e?n:e}})),e}}(e,t)}var Xi={newInstance:Wt.newInstance(qi,&quot;vtkProp3D&quot;),extend:qi};const Yi={FLAT:0,GOURAUD:1,PHONG:2},Zi={POINTS:0,WIREFRAME:1,SURFACE:2};var Qi={Shading:Yi,Representation:Zi,Interpolation:Yi};const{Representation:Ji,Interpolation:es}=Qi;function ts(e){return()=>Wt.vtkErrorMacro(`vtkProperty::${e} - NOT IMPLEMENTED`)}const ns={color:[1,1,1],ambientColor:[1,1,1],diffuseColor:[1,1,1],specularColor:[1,1,1],edgeColor:[0,0,0],ambient:0,diffuse:1,metallic:0,roughness:.6,normalStrength:1,emission:1,baseIOR:1.45,specular:0,specularPower:1,opacity:1,interpolation:es.GOURAUD,representation:Ji.SURFACE,edgeVisibility:!1,backfaceCulling:!1,frontfaceCulling:!1,pointSize:1,lineWidth:1,lighting:!0,shading:!1,materialName:null,ORMTexture:null,RMTexture:null};function rs(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ns,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;lighting&quot;,&quot;interpolation&quot;,&quot;ambient&quot;,&quot;diffuse&quot;,&quot;metallic&quot;,&quot;roughness&quot;,&quot;normalStrength&quot;,&quot;emission&quot;,&quot;baseIOR&quot;,&quot;specular&quot;,&quot;specularPower&quot;,&quot;opacity&quot;,&quot;edgeVisibility&quot;,&quot;lineWidth&quot;,&quot;pointSize&quot;,&quot;backfaceCulling&quot;,&quot;frontfaceCulling&quot;,&quot;representation&quot;,&quot;diffuseTexture&quot;,&quot;metallicTexture&quot;,&quot;roughnessTexture&quot;,&quot;normalTexture&quot;,&quot;ambientOcclusionTexture&quot;,&quot;emissionTexture&quot;,&quot;ORMTexture&quot;,&quot;RMTexture&quot;]),Wt.setGetArray(e,t,[&quot;ambientColor&quot;,&quot;specularColor&quot;,&quot;diffuseColor&quot;,&quot;edgeColor&quot;],3),function(e,t){t.classHierarchy.push(&quot;vtkProperty&quot;),e.setColor=(n,r,o)=>{Array.isArray(n)?t.color[0]===n[0]&&t.color[1]===n[1]&&t.color[2]===n[2]||(t.color[0]=n[0],t.color[1]=n[1],t.color[2]=n[2],e.modified()):t.color[0]===n&&t.color[1]===r&&t.color[2]===o||(t.color[0]=n,t.color[1]=r,t.color[2]=o,e.modified()),e.setDiffuseColor(t.color),e.setAmbientColor(t.color),e.setSpecularColor(t.color)},e.computeCompositeColor=ts(&quot;ComputeCompositeColor&quot;),e.getColor=()=>{let e=0;t.ambient+t.diffuse+t.specular>0&&(e=1/(t.ambient+t.diffuse+t.specular));for(let n=0;n<3;n++)t.color[n]=e*(t.ambient*t.ambientColor[n]+t.diffuse*t.diffuseColor[n]+t.specular*t.specularColor[n]);return[].concat(t.color)},e.setSpecularPower=n=>{const r=1/Math.max(1,n);t.roughness===r&&t.specularPower===n||(t.specularPower=n,t.roughness=r,e.modified())},e.addShaderVariable=ts(&quot;AddShaderVariable&quot;),e.setInterpolationToFlat=()=>e.setInterpolation(es.FLAT),e.setInterpolationToGouraud=()=>e.setInterpolation(es.GOURAUD),e.setInterpolationToPhong=()=>e.setInterpolation(es.PHONG),e.getInterpolationAsString=()=>Wt.enumToString(es,t.interpolation),e.setRepresentationToWireframe=()=>e.setRepresentation(Ji.WIREFRAME),e.setRepresentationToSurface=()=>e.setRepresentation(Ji.SURFACE),e.setRepresentationToPoints=()=>e.setRepresentation(Ji.POINTS),e.getRepresentationAsString=()=>Wt.enumToString(Ji,t.representation)}(e,t)}var os={newInstance:Wt.newInstance(rs,&quot;vtkProperty&quot;),extend:rs,...Qi};const as={mapper:null,backfaceProperty:null,forceOpaque:!1,forceTranslucent:!1};function is(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,as,n),Xi.extend(e,t,n),t.boundsMTime={},Wt.obj(t.boundsMTime),Wt.setGet(e,t,[&quot;backfaceProperty&quot;,&quot;forceOpaque&quot;,&quot;forceTranslucent&quot;,&quot;mapper&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkActor&quot;);const n={...e};e.getActors=()=>[e],e.getIsOpaque=()=>{if(t.forceOpaque)return!0;if(t.forceTranslucent)return!1;t.properties[0]||e.getProperty();let n=t.properties[0].getOpacity()>=1;return n=n&&(!t.texture||!t.texture.isTranslucent()),n=n&&(!t.mapper||t.mapper.getIsOpaque()),n},e.hasTranslucentPolygonalGeometry=()=>null!==t.mapper&&(t.properties[0]||e.getProperty(),!e.getIsOpaque()),e.makeProperty=os.newInstance,e.getMTime=()=>{let e=n.getMTime();if(null!==t.backfaceProperty){const n=t.backfaceProperty.getMTime();e=n>e?n:e}return e},e.getRedrawMTime=()=>{let e=t.mtime;if(null!==t.mapper){let n=t.mapper.getMTime();e=n>e?n:e,null!==t.mapper.getInput()&&(t.mapper.getInputAlgorithm().update(),n=t.mapper.getInput().getMTime(),e=n>e?n:e)}return e},e.getSupportsSelection=()=>!!t.mapper&&t.mapper.getSupportsSelection(),e.processSelectorPixelBuffers=(e,n)=>{t.mapper&&t.mapper.processSelectorPixelBuffers&&t.mapper.processSelectorPixelBuffers(e,n)}}(e,t)}var ss={newInstance:Wt.newInstance(is,&quot;vtkActor&quot;),extend:is};const ls={Int8Array:1,Uint8Array:1,Uint8ClampedArray:1,Int16Array:2,Uint16Array:2,Int32Array:4,Uint32Array:4,Float32Array:4,Float64Array:8},cs={VOID:&quot;&quot;,CHAR:&quot;Int8Array&quot;,SIGNED_CHAR:&quot;Int8Array&quot;,UNSIGNED_CHAR:&quot;Uint8Array&quot;,UNSIGNED_CHAR_CLAMPED:&quot;Uint8ClampedArray&quot;,SHORT:&quot;Int16Array&quot;,UNSIGNED_SHORT:&quot;Uint16Array&quot;,INT:&quot;Int32Array&quot;,UNSIGNED_INT:&quot;Uint32Array&quot;,FLOAT:&quot;Float32Array&quot;,DOUBLE:&quot;Float64Array&quot;};var us={DefaultDataType:cs.FLOAT,DataTypeByteSize:ls,VtkDataTypes:cs};const{vtkErrorMacro:ds}=Ht,{DefaultDataType:ps}=us;function fs(e,t,n){const r=e.length;let o,a,i=Number.MAX_VALUE,s=-Number.MAX_VALUE;for(a=t;a<r;a+=n)if(!Number.isNaN(e[a])){i=e[a],s=i;break}for(;a<r;a+=n)o=e[a],o<i?i=o:o>s&&(s=o);return{min:i,max:s}}function gs(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1;if(t<0&&n>1){const t=e.length/n,r=new Float64Array(t);for(let o=0,a=0;o<t;++o){for(let t=a+n;a<t;++a)r[o]+=e[a]*e[a];r[o]**=.5}return fs(r,0,1)}return fs(e,t<0?0:t,n)}function ms(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;const n=e||[];for(;n.length<=t;)n.push(null);return n}function hs(e){return Object.prototype.toString.call(e).slice(8,-1)}const vs={computeRange:gs,createRangeHelper:function(){let e=Number.MAX_VALUE,t=-Number.MAX_VALUE,n=0,r=0;return{add(o){e>o&&(e=o),t<o&&(t=o),n++,r+=o},get(){return{min:e,max:t,count:n,sum:r,mean:r/n}},getRange(){return{min:e,max:t}}}},fastComputeRange:fs,getDataType:hs,getMaxNorm:function(e){const t=e.getNumberOfComponents();let n=0;const r=new Array(t);for(let o=0;o<e.getNumberOfTuples();++o){e.getTuple(o,r);const a=No(r,t);a>n&&(n=a)}return n}},Ts={name:&quot;&quot;,numberOfComponents:1,dataType:ps,rangeTuple:[0,0]};function ys(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};if(Object.assign(t,Ts,n),Array.isArray(n.values)&&void 0===n.dataType&&console.warn(&quot;vtkDataArray.newInstance: no dataType provided, converting to Float32Array&quot;),!t.empty&&!t.values&&!t.size)throw new TypeError(&quot;Cannot create vtkDataArray object without: size > 0, values&quot;);if(t.values?Array.isArray(t.values)&&(t.values=it(t.dataType,t.values)):t.values=at(t.dataType,t.size),t.values&&(t.size=t.size??t.values.length,t.dataType=hs(t.values)),ht(e,t),xt(e,t,[&quot;name&quot;,&quot;numberOfComponents&quot;]),t.size%t.numberOfComponents!=0)throw new RangeError(&quot;model.size is not a multiple of model.numberOfComponents&quot;);!function(e,t){function n(n){if(n<0)return!1;const r=e.getNumberOfComponents(),o=t.values.length/(r>0?r:1);if(n===o)return!0;if(n>o){const e=t.values;return t.values=at(t.dataType,(n+o)*r),t.values.set(e),!0}return t.size>n*r&&(t.size=n*r,e.dataChange()),!0}t.classHierarchy.push(&quot;vtkDataArray&quot;),e.dataChange=()=>{t.ranges=null,e.modified()},e.allocate=t=>{n(e.getNumberOfTuples()+t)},e.resize=r=>{n(r);const o=r*e.getNumberOfComponents();return t.size!==o&&(t.size=o,e.dataChange(),!0)},e.initialize=()=>(e.resize(0),e),e.getElementComponentSize=()=>t.values.BYTES_PER_ELEMENT,e.getComponent=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;return t.values[e*t.numberOfComponents+n]},e.setComponent=(n,r,o)=>{o!==t.values[n*t.numberOfComponents+r]&&(t.values[n*t.numberOfComponents+r]=o,e.dataChange())},e.getValue=n=>{const r=n/t.numberOfComponents,o=n%t.numberOfComponents;return e.getComponent(r,o)},e.setValue=(n,r)=>{const o=n/t.numberOfComponents,a=n%t.numberOfComponents;e.setComponent(o,a,r)},e.getData=()=>t.size===t.values.length?t.values:t.values.subarray(0,t.size),e.getRange=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:-1,r=n;r<0&&(r=1===t.numberOfComponents?0:t.numberOfComponents);let o=null;return t.ranges||(t.ranges=ms(t.ranges,t.numberOfComponents)),o=t.ranges[r],o?(t.rangeTuple[0]=o.min,t.rangeTuple[1]=o.max,t.rangeTuple):(o=gs(e.getData(),n,t.numberOfComponents),t.ranges[r]=o,t.rangeTuple[0]=o.min,t.rangeTuple[1]=o.max,t.rangeTuple)},e.setRange=(e,n)=>{t.ranges||(t.ranges=ms(t.ranges,t.numberOfComponents));const r={min:e.min,max:e.max};return t.ranges[n]=r,t.rangeTuple[0]=r.min,t.rangeTuple[1]=r.max,t.rangeTuple},e.getRanges=function(){if(arguments.length>0&&void 0!==arguments[0]&&!arguments[0])return structuredClone(t.ranges);const n=[];for(let r=0;r<t.numberOfComponents;r++){const[t,o]=e.getRange(r),a={min:t,max:o};n.push(a)}if(t.numberOfComponents>1){const[t,r]=e.getRange(-1),o={min:t,max:r};n.push(o)}return n},e.setTuple=(e,n)=>{const r=e*t.numberOfComponents;for(let e=0;e<t.numberOfComponents;e++)t.values[r+e]=n[e]},e.setTuples=(e,n)=>{let r=e*t.numberOfComponents;const o=Math.min(n.length,t.size-r);for(let e=0;e<o;)t.values[r++]=n[e++]},e.insertTuple=(r,o)=>(t.size<=r*t.numberOfComponents&&(t.size=(r+1)*t.numberOfComponents,n(r+1)),e.setTuple(r,o),r),e.insertTuples=(r,o)=>{const a=r+o.length/t.numberOfComponents;return t.size<a*t.numberOfComponents&&(t.size=a*t.numberOfComponents,n(a)),e.setTuples(r,o),a},e.insertNextTuple=n=>{const r=t.size/t.numberOfComponents;return e.insertTuple(r,n)},e.insertNextTuples=n=>{const r=t.size/t.numberOfComponents;return e.insertTuples(r,n)},e.findTuple=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1e-6;for(let r=0;r<t.size;r+=t.numberOfComponents)if(Math.abs(e[0]-t.values[r])<=n){let o=!0;for(let a=1;a<t.numberOfComponents;++a)if(Math.abs(e[a]-t.values[r+a])>n){o=!1;break}if(o)return r/t.numberOfComponents}return-1},e.getTuple=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];const r=t.numberOfComponents||1,o=e*r;switch(r){case 4:n[3]=t.values[o+3];case 3:n[2]=t.values[o+2];case 2:n[1]=t.values[o+1];case 1:n[0]=t.values[o];break;default:for(let e=r-1;e>=0;--e)n[e]=t.values[o+e]}return n},e.getTuples=(n,r)=>{const o=(n??0)*t.numberOfComponents,a=(r??e.getNumberOfTuples())*t.numberOfComponents,i=e.getData().subarray(o,a);return i.length>0?i:null},e.getTupleLocation=function(){return(arguments.length>0&&void 0!==arguments[0]?arguments[0]:1)*t.numberOfComponents},e.getNumberOfComponents=()=>t.numberOfComponents,e.getNumberOfValues=()=>t.size,e.getNumberOfTuples=()=>t.size/t.numberOfComponents,e.getDataType=()=>t.dataType,e.newClone=()=>bs({empty:!0,name:t.name,dataType:t.dataType,numberOfComponents:t.numberOfComponents}),e.getName=()=>(t.name||(e.modified(),t.name=`vtkDataArray${e.getMTime()}`),t.name),e.setData=(n,r)=>{t.values=n,t.size=n.length,t.dataType=hs(n),r&&(t.numberOfComponents=r),t.size%t.numberOfComponents!=0&&(t.numberOfComponents=1),e.dataChange()},e.getState=()=>{if(t.deleted)return null;const n={...t,vtkClass:e.getClassName()};n.values=Array.from(n.values),delete n.buffer,Object.keys(n).forEach((e=>{n[e]||delete n[e]}));const r={};return Object.keys(n).sort().forEach((e=>{r[e]=n[e]})),r.mtime&&delete r.mtime,r},e.deepCopy=n=>{const r=e.getDataType(),o=t.values;e.shallowCopy(n),t.ranges=structuredClone(n.getRanges()),o?.length>=n.getNumberOfValues()&&r===n.getDataType()?(o.set(n.getData()),t.values=o,e.dataChange()):e.setData(n.getData().slice())},e.interpolateTuple=(n,r,o,a,i,s)=>{const l=t.numberOfComponents||1;l===r.getNumberOfComponents()&&l===a.getNumberOfComponents()||ds(&quot;numberOfComponents must match&quot;);const c=r.getTuple(o),u=a.getTuple(i),d=[];switch(d.length=l,l){case 4:d[3]=c[3]+(u[3]-c[3])*s;case 3:d[2]=c[2]+(u[2]-c[2])*s;case 2:d[1]=c[1]+(u[1]-c[1])*s;case 1:d[0]=c[0]+(u[0]-c[0])*s;break;default:for(let e=0;e<l;e++)d[e]=c[e]+(u[e]-c[e])*s}return e.insertTuple(n,d)}}(e,t)}const bs=Mt(ys,&quot;vtkDataArray&quot;);var xs={newInstance:bs,extend:ys,...vs,...us};const Cs={clippingPlanes:[]};var Ss=function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Cs,n),Wt.obj(e,t),Wt.algo(e,t,1,0),t.clippingPlanes||(t.clippingPlanes=[]),function(e,t){t.classHierarchy.push(&quot;vtkAbstractMapper&quot;),e.update=()=>{e.getInputData()},e.addClippingPlane=n=>!!n.isA(&quot;vtkPlane&quot;)&&!t.clippingPlanes.includes(n)&&(t.clippingPlanes.push(n),e.modified(),!0),e.getNumberOfClippingPlanes=()=>t.clippingPlanes.length,e.removeAllClippingPlanes=()=>0!==t.clippingPlanes.length&&(t.clippingPlanes.length=0,e.modified(),!0),e.removeClippingPlane=n=>{const r=t.clippingPlanes.indexOf(n);return-1!==r&&(t.clippingPlanes.splice(r,1),e.modified(),!0)},e.getClippingPlanes=()=>t.clippingPlanes,e.setClippingPlanes=t=>{if(t)if(Array.isArray(t)){const n=t.length;for(let r=0;r<n&&r<6;r++)e.addClippingPlane(t[r])}else e.addClippingPlane(t)},e.getClippingPlaneInDataCoords=(e,n,r)=>{const o=t.clippingPlanes,a=e;if(o){const e=o.length;if(n>=0&&n<e){const e=o[n],t=e.getNormal(),i=e.getOrigin(),s=t[0],l=t[1],c=t[2],u=-(s*i[0]+l*i[1]+c*i[2]);return r[0]=s*a[0]+l*a[4]+c*a[8]+u*a[12],r[1]=s*a[1]+l*a[5]+c*a[9]+u*a[13],r[2]=s*a[2]+l*a[6]+c*a[10]+u*a[14],void(r[3]=s*a[3]+l*a[7]+c*a[11]+u*a[15])}}Wt.vtkErrorMacro(`Clipping plane index ${n} is out of range.`)}}(e,t)},As=function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,(e=>({bounds:[...Gi.INIT_BOUNDS],center:[0,0,0],viewSpecificProperties:{},...e}))(n)),Ss(e,t,n),Wt.setGet(e,t,[&quot;viewSpecificProperties&quot;]),function(e,t){e.getBounds=()=>(Wt.vtkErrorMacro(&quot;vtkAbstractMapper3D.getBounds - NOT IMPLEMENTED&quot;),Pa()),e.getCenter=()=>{const n=e.getBounds();return t.center=Gi.isValid(n)?Gi.getCenter(n):null,t.center?.slice()},e.getLength=()=>{const t=e.getBounds();return Gi.getDiagonalLength(t)}}(e,t)};const{vtkErrorMacro:Is,vtkWarningMacro:ws}=Wt,Os={arrays:[],copyFieldFlags:[],doCopyAllOn:!0,doCopyAllOff:!1};function Ps(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Os,n),Wt.obj(e,t),function(e,t){t.classHierarchy.push(&quot;vtkFieldData&quot;);const n=e.getState;t.arrays&&(t.arrays=t.arrays.map((e=>({data:ze(e.data)})))),e.initialize=()=>{e.initializeFields(),e.copyAllOn(),e.clearFieldFlags()},e.initializeFields=()=>{t.arrays=[],t.copyFieldFlags={},e.modified()},e.copyStructure=n=>{e.initializeFields(),t.copyFieldFlags=n.getCopyFieldFlags().map((e=>e)),t.arrays=n.getArrays().map((e=>({data:e})))},e.getNumberOfArrays=()=>t.arrays.length,e.getNumberOfActiveArrays=()=>t.arrays.length,e.addArray=n=>{const r=n.getName(),{array:o,index:a}=e.getArrayWithIndex(r);return null!=o?(t.arrays[a]={data:n},a):(t.arrays=[].concat(t.arrays,{data:n}),t.arrays.length-1)},e.removeAllArrays=()=>{t.arrays=[]},e.removeArray=n=>{const r=t.arrays.findIndex((e=>e.data.getName()===n));return e.removeArrayByIndex(r)},e.removeArrayByIndex=e=>-1!==e&&e<t.arrays.length&&(t.arrays.splice(e,1),!0),e.getArrays=()=>t.arrays.map((e=>e.data)),e.getArray=t=>&quot;number&quot;==typeof t?e.getArrayByIndex(t):e.getArrayByName(t),e.getArrayByName=e=>t.arrays.reduce(((t,n,r)=>n.data.getName()===e?n.data:t),null),e.getArrayWithIndex=e=>{const n=t.arrays.findIndex((t=>t.data.getName()===e));return{array:-1!==n?t.arrays[n].data:null,index:n}},e.getArrayByIndex=e=>e>=0&&e<t.arrays.length?t.arrays[e].data:null,e.hasArray=t=>e.getArrayWithIndex(t).index>=0,e.getArrayName=e=>{const n=t.arrays[e];return n?n.data.getName():&quot;&quot;},e.getCopyFieldFlags=()=>t.copyFieldFlags,e.getFlag=e=>t.copyFieldFlags[e],e.passData=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:-1,o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:-1;n.getArrays().forEach((a=>{const i=e.getFlag(a.getName());if(!1!==i&&(!t.doCopyAllOff||!0===i)&&a){let t=e.getArrayByName(a.getName());if(t)if(a.getNumberOfComponents()===t.getNumberOfComponents())if(r>-1&&r<a.getNumberOfTuples()){const e=o>-1?o:r;t.insertTuple(e,a.getTuple(r))}else t.insertTuples(0,a.getTuples());else Is(&quot;Unhandled case in passData&quot;);else if(r<0||r>a.getNumberOfTuples())e.addArray(a),n.getAttributes(a).forEach((t=>{e.setAttribute(a,t)}));else{const i=a.getNumberOfComponents();let s=a.getNumberOfValues();const l=o>-1?o:r;s<=l*i&&(s=(l+1)*i),t=xs.newInstance({name:a.getName(),dataType:a.getDataType(),numberOfComponents:i,values:Wt.newTypedArray(a.getDataType(),s),size:0}),t.insertTuple(l,a.getTuple(r)),e.addArray(t),n.getAttributes(a).forEach((n=>{e.setAttribute(t,n)}))}}}))},e.interpolateData=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:-1,o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:-1,a=arguments.length>3&&void 0!==arguments[3]?arguments[3]:-1,i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:.5;n.getArrays().forEach((s=>{const l=e.getFlag(s.getName());if(!1!==l&&(!t.doCopyAllOff||!0===l)&&s){let t=e.getArrayByName(s.getName());if(t)if(s.getNumberOfComponents()===t.getNumberOfComponents())if(r>-1&&r<s.getNumberOfTuples()){const e=a>-1?a:r;t.interpolateTuple(e,s,r,s,o,i),ws(&quot;Unexpected case in interpolateData&quot;)}else t.insertTuples(s.getTuples());else Is(&quot;Unhandled case in interpolateData&quot;);else if(r<0||o<0||r>s.getNumberOfTuples())e.addArray(s),n.getAttributes(s).forEach((t=>{e.setAttribute(s,t)}));else{const l=s.getNumberOfComponents();let c=s.getNumberOfValues();const u=a>-1?a:r;c<=u*l&&(c=(u+1)*l),t=xs.newInstance({name:s.getName(),dataType:s.getDataType(),numberOfComponents:l,values:Wt.newTypedArray(s.getDataType(),c),size:0}),t.interpolateTuple(u,s,r,s,o,i),e.addArray(t),n.getAttributes(s).forEach((n=>{e.setAttribute(t,n)}))}}}))},e.copyFieldOn=e=>{t.copyFieldFlags[e]=!0},e.copyFieldOff=e=>{t.copyFieldFlags[e]=!1},e.copyAllOn=()=>{t.doCopyAllOn&&!t.doCopyAllOff||(t.doCopyAllOn=!0,t.doCopyAllOff=!1,e.modified())},e.copyAllOff=()=>{!t.doCopyAllOn&&t.doCopyAllOff||(t.doCopyAllOn=!1,t.doCopyAllOff=!0,e.modified())},e.clearFieldFlags=()=>{t.copyFieldFlags={}},e.deepCopy=e=>{t.arrays=e.getArrays().map((e=>{const t=e.newClone();return t.deepCopy(e),{data:t}}))},e.copyFlags=e=>e.getCopyFieldFlags().map((e=>e)),e.reset=()=>t.arrays.forEach((e=>e.data.reset())),e.getMTime=()=>t.arrays.reduce(((e,t)=>t.data.getMTime()>e?t.data.getMTime():e),t.mtime),e.getNumberOfComponents=()=>t.arrays.reduce(((e,t)=>e+t.data.getNumberOfComponents()),0),e.getNumberOfTuples=()=>t.arrays.length>0?t.arrays[0].getNumberOfTuples():0,e.getState=()=>{const e=n();return e&&(e.arrays=t.arrays.map((e=>({data:e.data.getState()})))),e}}(e,t)}var Rs={newInstance:Wt.newInstance(Ps,&quot;vtkFieldData&quot;),extend:Ps};const Ms={DEFAULT:0,SINGLE:1,DOUBLE:2};var Es={AttributeCopyOperations:{COPYTUPLE:0,INTERPOLATE:1,PASSDATA:2,ALLCOPY:3},AttributeLimitTypes:{MAX:0,EXACT:1,NOLIMIT:2},AttributeTypes:{SCALARS:0,VECTORS:1,NORMALS:2,TCOORDS:3,TENSORS:4,GLOBALIDS:5,PEDIGREEIDS:6,EDGEFLAG:7,NUM_ATTRIBUTES:8},CellGhostTypes:{DUPLICATECELL:1,HIGHCONNECTIVITYCELL:2,LOWCONNECTIVITYCELL:4,REFINEDCELL:8,EXTERIORCELL:16,HIDDENCELL:32},DesiredOutputPrecision:Ms,PointGhostTypes:{DUPLICATEPOINT:1,HIDDENPOINT:2},ghostArrayName:&quot;vtkGhostType&quot;};const{AttributeTypes:Vs,AttributeCopyOperations:Ds}=Es,{vtkWarningMacro:Ls}=Wt,Bs={activeScalars:-1,activeVectors:-1,activeTensors:-1,activeNormals:-1,activeTCoords:-1,activeGlobalIds:-1,activePedigreeIds:-1};function Ns(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Bs,n),Rs.extend(e,t,n),Wt.setGet(e,t,[&quot;activeScalars&quot;,&quot;activeNormals&quot;,&quot;activeTCoords&quot;,&quot;activeVectors&quot;,&quot;activeTensors&quot;,&quot;activeGlobalIds&quot;,&quot;activePedigreeIds&quot;]),t.arrays||(t.arrays={}),function(e,t){const n=[&quot;Scalars&quot;,&quot;Vectors&quot;,&quot;Normals&quot;,&quot;TCoords&quot;,&quot;Tensors&quot;,&quot;GlobalIds&quot;,&quot;PedigreeIds&quot;];function r(e){let t=n.find((t=>Vs[t.toUpperCase()]===e||&quot;number&quot;!=typeof e&&t.toLowerCase()===e.toLowerCase()));return void 0===t&&(t=null),t}t.classHierarchy.push(&quot;vtkDataSetAttributes&quot;);const o={...e};e.checkNumberOfComponents=e=>!0,e.setAttribute=(n,o)=>{const a=r(o);if(n&&&quot;PEDIGREEIDS&quot;===a.toUpperCase()&&!n.isA(&quot;vtkDataArray&quot;))return Ls(`Cannot set attribute ${a}. The attribute must be a vtkDataArray.`),-1;if(n&&!e.checkNumberOfComponents(n,a))return Ls(`Cannot set attribute ${a}. Incorrect number of components.`),-1;let i=t[`active${a}`];if(i>=0&&i<t.arrays.length){if(t.arrays[i]===n)return i;e.removeArrayByIndex(i)}return n?(i=e.addArray(n),t[`active${a}`]=i):t[`active${a}`]=-1,e.modified(),t[`active${a}`]},e.getAttributes=t=>n.filter((n=>e[`get${n}`]()===t)),e.setActiveAttributeByName=(t,n)=>e.setActiveAttributeByIndex(e.getArrayWithIndex(t).index,n),e.setActiveAttributeByIndex=(n,o)=>{const a=r(o);if(n>=0&&n<t.arrays.length){if(&quot;PEDIGREEIDS&quot;!==a.toUpperCase()){const t=e.getArrayByIndex(n);if(!t.isA(&quot;vtkDataArray&quot;))return Ls(`Cannot set attribute ${a}. Only vtkDataArray subclasses can be set as active attributes.`),-1;if(!e.checkNumberOfComponents(t,a))return Ls(`Cannot set attribute ${a}. Incorrect number of components.`),-1}return t[`active${a}`]=n,e.modified(),n}return-1===n&&(t[`active${a}`]=n,e.modified()),-1},e.getActiveAttribute=t=>{const n=r(t);return e[`get${n}`]()},e.removeAllArrays=()=>{n.forEach((e=>{t[`active${e}`]=-1})),o.removeAllArrays()},e.removeArrayByIndex=e=>(-1!==e&&n.forEach((n=>{e===t[`active${n}`]?t[`active${n}`]=-1:e<t[`active${n}`]&&(t[`active${n}`]-=1)})),o.removeArrayByIndex(e)),n.forEach((n=>{const r=`active${n}`;e[`get${n}`]=()=>e.getArrayByIndex(t[r]),e[`set${n}`]=t=>e.setAttribute(t,n),e[`setActive${n}`]=t=>e.setActiveAttributeByIndex(e.getArrayWithIndex(t).index,n),e[`copy${n}Off`]=()=>{const e=n.toUpperCase();t.copyAttributeFlags[Ds.PASSDATA][Vs[e]]=!1},e[`copy${n}On`]=()=>{const e=n.toUpperCase();t.copyAttributeFlags[Ds.PASSDATA][Vs[e]]=!0}})),e.initializeAttributeCopyFlags=()=>{t.copyAttributeFlags=[],Object.keys(Ds).filter((e=>&quot;ALLCOPY&quot;!==e)).forEach((e=>{t.copyAttributeFlags[Ds[e]]=Object.keys(Vs).filter((e=>&quot;NUM_ATTRIBUTES&quot;!==e)).reduce(((e,t)=>(e[Vs[t]]=!0,e)),[])})),t.copyAttributeFlags[Ds.COPYTUPLE][Vs.GLOBALIDS]=!1,t.copyAttributeFlags[Ds.INTERPOLATE][Vs.GLOBALIDS]=!1,t.copyAttributeFlags[Ds.COPYTUPLE][Vs.PEDIGREEIDS]=!1},e.initialize=Wt.chain(e.initialize,e.initializeAttributeCopyFlags),t.dataArrays&&Object.keys(t.dataArrays).length&&Object.keys(t.dataArrays).forEach((n=>{t.dataArrays[n].ref||&quot;vtkDataArray&quot;!==t.dataArrays[n].type||e.addArray(xs.newInstance(t.dataArrays[n]))}));const a=e.shallowCopy;e.shallowCopy=(e,n)=>{a(e,n),t.arrays=e.getArrays().map((e=>{const t=e.newClone();return t.shallowCopy(e,n),{data:t}}))},e.initializeAttributeCopyFlags()}(e,t)}var Fs={newInstance:Wt.newInstance(Ns,&quot;vtkDataSetAttributes&quot;),extend:Ns,...Es};const _s=[&quot;pointData&quot;,&quot;cellData&quot;,&quot;fieldData&quot;],ks={};function Gs(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ks,n),Wt.obj(e,t),Wt.setGet(e,t,_s),Wt.getArray(e,t,[&quot;bounds&quot;],6),function(e,t){t.classHierarchy.push(&quot;vtkDataSet&quot;),_s.forEach((e=>{t[e]?t[e]=ze(t[e]):t[e]=Fs.newInstance()})),e.computeBounds=()=>{if(t.modifiedTime&&t.computeTime&&t.modifiedTime>t.computeTime||!t.computeTime){const n=e.getPoints();n?.getNumberOfPoints()?Gi.setBounds(t.bounds,n.getBoundsByReference()):t.bounds=Da.createUninitializedBounds(),t.computeTime=Wt.getCurrentGlobalMTime()}},e.getLength2=()=>{const t=e.getBoundsByReference();return t&&6===t.length?Gi.getDiagonalLength2(t):0},e.getLength=()=>Math.sqrt(e.getLength2()),e.getCenter=()=>{const t=e.getBoundsByReference();return t&&6===t.length?Gi.getCenter(t):[0,0,0]},e.getCellBounds=t=>{const n=e.getCell(t);return n?n.getBounds():Da.createUninitializedBounds()},e.getBounds=Wt.chain((()=>e.computeBounds),e.getBounds),e.getBoundsByReference=Wt.chain((()=>e.computeBounds),e.getBoundsByReference);const n=e.shallowCopy;e.shallowCopy=function(e){n(e,arguments.length>1&&void 0!==arguments[1]&&arguments[1]),_s.forEach((n=>{t[n]=Fs.newInstance(),t[n].shallowCopy(e.getReferenceByName(n))}))};const r=e.getMTime;e.getMTime=()=>_s.reduce(((e,n)=>Math.max(e,t[n]?.getMTime()??e)),r()),e.initialize=()=>(_s.forEach((e=>t[e]?.initialize())),e)}(e,t)}var Us={newInstance:Wt.newInstance(Gs,&quot;vtkDataSet&quot;),extend:Gs,FieldDataTypes:{UNIFORM:0,DATA_OBJECT_FIELD:0,COORDINATE:1,POINT_DATA:1,POINT:2,POINT_FIELD_DATA:2,CELL:3,CELL_FIELD_DATA:3,VERTEX:4,VERTEX_FIELD_DATA:4,EDGE:5,EDGE_FIELD_DATA:5,ROW:6,ROW_DATA:6},FieldAssociations:{FIELD_ASSOCIATION_POINTS:0,FIELD_ASSOCIATION_CELLS:1,FIELD_ASSOCIATION_NONE:2,FIELD_ASSOCIATION_POINTS_THEN_CELLS:3,FIELD_ASSOCIATION_VERTICES:4,FIELD_ASSOCIATION_EDGES:5,FIELD_ASSOCIATION_ROWS:6,NUMBER_OF_ASSOCIATIONS:7}};const zs={UNCHANGED:0,SINGLE_POINT:1,X_LINE:2,Y_LINE:3,Z_LINE:4,XY_PLANE:5,YZ_PLANE:6,XZ_PLANE:7,XYZ_GRID:8,EMPTY:9};var Ws={StructuredType:zs};const{StructuredType:Hs}=Ws;var js={getDataDescriptionFromExtent:function(e){let t=0;for(let n=0;n<3;++n)e[2*n]<e[2*n+1]&&t++;return e[0]>e[1]||e[2]>e[3]||e[4]>e[5]?Hs.EMPTY:3===t?Hs.XYZ_GRID:2===t?e[0]===e[1]?Hs.YZ_PLANE:e[2]===e[3]?Hs.XZ_PLANE:Hs.XY_PLANE:1===t?e[0]<e[1]?Hs.X_LINE:e[2]<e[3]?Hs.Y_LINE:Hs.Z_LINE:Hs.SINGLE_POINT},...Ws};const{vtkErrorMacro:Ks}=Wt,$s={direction:null,indexToWorld:null,worldToIndex:null,spacing:[1,1,1],origin:[0,0,0],extent:[0,-1,0,-1,0,-1],dataDescription:zs.EMPTY};function qs(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,$s,n),Us.extend(e,t,n),t.direction?Array.isArray(t.direction)&&(t.direction=new Float64Array(t.direction.slice(0,9))):t.direction=fe(new Float64Array(9)),t.indexToWorld=new Float64Array(16),t.worldToIndex=new Float64Array(16),Wt.get(e,t,[&quot;indexToWorld&quot;,&quot;worldToIndex&quot;]),Wt.setGetArray(e,t,[&quot;origin&quot;,&quot;spacing&quot;],3),Wt.setGetArray(e,t,[&quot;direction&quot;],9),Wt.getArray(e,t,[&quot;extent&quot;],6),function(e,t){t.classHierarchy.push(&quot;vtkImageData&quot;),e.setExtent=function(){if(t.deleted)return Ks(&quot;instance deleted - cannot call any method&quot;),!1;for(var n=arguments.length,r=new Array(n),o=0;o<n;o++)r[o]=arguments[o];const a=1===r.length?r[0]:r;if(6!==a.length)return!1;const i=t.extent.some(((e,t)=>e!==a[t]));return i&&(t.extent=a.slice(),t.dataDescription=js.getDataDescriptionFromExtent(t.extent),e.modified()),i},e.setDimensions=function(){let n,r,o;if(t.deleted)Ks(&quot;instance deleted - cannot call any method&quot;);else{if(1===arguments.length){const e=arguments.length<=0?void 0:arguments[0];n=e[0],r=e[1],o=e[2]}else{if(3!==arguments.length)return void Ks(&quot;Bad dimension specification&quot;);n=arguments.length<=0?void 0:arguments[0],r=arguments.length<=1?void 0:arguments[1],o=arguments.length<=2?void 0:arguments[2]}e.setExtent(0,n-1,0,r-1,0,o-1)}},e.getDimensions=()=>[t.extent[1]-t.extent[0]+1,t.extent[3]-t.extent[2]+1,t.extent[5]-t.extent[4]+1],e.getNumberOfCells=()=>{const t=e.getDimensions();let n=1;for(let e=0;e<3;e++){if(0===t[e])return 0;t[e]>1&&(n*=t[e]-1)}return n},e.getNumberOfPoints=()=>{const t=e.getDimensions();return t[0]*t[1]*t[2]},e.getPoint=n=>{const r=e.getDimensions();if(0===r[0]||0===r[1]||0===r[2])return Ks(&quot;Requesting a point from an empty image.&quot;),null;const o=new Float64Array(3);switch(t.dataDescription){case zs.EMPTY:return null;case zs.SINGLE_POINT:break;case zs.X_LINE:o[0]=n;break;case zs.Y_LINE:o[1]=n;break;case zs.Z_LINE:o[2]=n;break;case zs.XY_PLANE:o[0]=n%r[0],o[1]=n/r[0];break;case zs.YZ_PLANE:o[1]=n%r[1],o[2]=n/r[1];break;case zs.XZ_PLANE:o[0]=n%r[0],o[2]=n/r[0];break;case zs.XYZ_GRID:o[0]=n%r[0],o[1]=n/r[0]%r[1],o[2]=n/(r[0]*r[1]);break;default:Ks(&quot;Invalid dataDescription&quot;)}const a=[0,0,0];return e.indexToWorld(o,a),a},e.getBounds=()=>e.extentToBounds(e.getSpatialExtent()),e.extentToBounds=e=>Gi.transformBounds(e,t.indexToWorld),e.getSpatialExtent=()=>Gi.inflate([...t.extent],.5),e.computeTransforms=()=>{O(t.indexToWorld,t.origin),t.indexToWorld[0]=t.direction[0],t.indexToWorld[1]=t.direction[1],t.indexToWorld[2]=t.direction[2],t.indexToWorld[4]=t.direction[3],t.indexToWorld[5]=t.direction[4],t.indexToWorld[6]=t.direction[5],t.indexToWorld[8]=t.direction[6],t.indexToWorld[9]=t.direction[7],t.indexToWorld[10]=t.direction[8],C(t.indexToWorld,t.indexToWorld,t.spacing),v(t.worldToIndex,t.indexToWorld)},e.indexToWorld=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return In(n,e,t.indexToWorld),n},e.indexToWorldVec3=e.indexToWorld,e.worldToIndex=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return In(n,e,t.worldToIndex),n},e.worldToIndexVec3=e.worldToIndex,e.indexToWorldBounds=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return Gi.transformBounds(e,t.indexToWorld,n)},e.worldToIndexBounds=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return Gi.transformBounds(e,t.worldToIndex,n)},t._onOriginChanged=e.computeTransforms,t._onDirectionChanged=e.computeTransforms,t._onSpacingChanged=e.computeTransforms,e.computeTransforms(),e.getCenter=()=>Gi.getCenter(e.getBounds()),e.computeHistogram=function(t){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;const r=[0,0,0,0,0,0];e.worldToIndexBounds(t,r);const o=[0,0,0],a=[0,0,0];Gi.computeCornerPoints(r,o,a),ea(o,o),ea(a,a);const i=e.getDimensions();xa(o,[0,0,0],[i[0]-1,i[1]-1,i[2]-1],o),xa(a,[0,0,0],[i[0]-1,i[1]-1,i[2]-1],a);const s=i[0],l=i[0]*i[1],c=e.getPointData().getScalars().getData();let u=-1/0,d=1/0,p=0,f=0,g=0;for(let e=o[2];e<=a[2];e++)for(let t=o[1];t<=a[1];t++){let i=o[0]+t*s+e*l;for(let s=o[0];s<=a[0];s++){if(!n||n([s,t,e],r)){const e=c[i];e>u&&(u=e),e<d&&(d=e),p+=e*e,f+=e,g+=1}++i}}const m=g>0?f/g:0,h=g?Math.abs(p/g-m*m):0;return{minimum:d,maximum:u,average:m,variance:h,sigma:Math.sqrt(h),count:g}},e.computeIncrements=function(e){const t=[];let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;for(let r=0;r<3;++r)t[r]=n,n*=e[2*r+1]-e[2*r]+1;return t},e.computeOffsetIndex=t=>{let[n,r,o]=t;const a=e.getExtent(),i=e.getPointData().getScalars().getNumberOfComponents(),s=e.computeIncrements(a,i);return Math.floor((Math.round(n)-a[0])*s[0]+(Math.round(r)-a[2])*s[1]+(Math.round(o)-a[4])*s[2])},e.getOffsetIndexFromWorld=t=>{const n=e.getExtent(),r=e.worldToIndex(t);for(let e=0;e<3;++e)if(r[e]<n[2*e]||r[e]>n[2*e+1])return Ks(`GetScalarPointer: Pixel ${r} is not in memory. Current extent = ${n}`),NaN;return e.computeOffsetIndex(r)},e.getScalarValueFromWorld=function(t){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;const r=e.getPointData().getScalars().getNumberOfComponents();if(n<0||n>=r)return Ks(`GetScalarPointer: Scalar Component ${n} is not within bounds. Current Scalar numberOfComponents: ${r}`),NaN;const o=e.getOffsetIndexFromWorld(t);return Number.isNaN(o)?o:e.getPointData().getScalars().getComponent(o,n)};const n=e.initialize;e.initialize=()=>(e.set({direction:fe(t.direction),spacing:[1,1,1],origin:[0,0,0],extent:[0,-1,0,-1,0,-1],dataDescription:zs.EMPTY}),n())}(e,t)}var Xs={newInstance:Wt.newInstance(qs,&quot;vtkImageData&quot;),extend:qs};const Ys={LUMINANCE:1,LUMINANCE_ALPHA:2,RGB:3,RGBA:4};var Zs={VectorMode:{MAGNITUDE:0,COMPONENT:1,RGBCOLORS:2},ScalarMappingTarget:Ys,Scale:{LINEAR:0,LOG10:1}},Qs={ColorMode:{DEFAULT:0,MAP_SCALARS:1,DIRECT_SCALARS:2},GetArray:{BY_ID:0,BY_NAME:1},ScalarMode:{DEFAULT:0,USE_POINT_DATA:1,USE_CELL_DATA:2,USE_POINT_FIELD_DATA:3,USE_CELL_FIELD_DATA:4,USE_FIELD_DATA:5}};const{ScalarMappingTarget:Js,Scale:el,VectorMode:tl}=Zs,{VtkDataTypes:nl}=xs,{ColorMode:rl}=Qs,{vtkErrorMacro:ol}=Wt;function al(e){return e}function il(e){return Math.floor(255*e+.5)}const sl={alpha:1,vectorComponent:0,vectorSize:-1,vectorMode:tl.COMPONENT,mappingRange:null,annotationArray:null,annotatedValueMap:null,indexedLookup:!1,scale:el.LINEAR};function ll(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,sl,n),Wt.obj(e,t),t.mappingRange=[0,255],t.annotationArray=[],t.annotatedValueMap=[],Wt.setGet(e,t,[&quot;vectorSize&quot;,&quot;vectorComponent&quot;,&quot;vectorMode&quot;,&quot;alpha&quot;,&quot;indexedLookup&quot;]),Wt.setArray(e,t,[&quot;mappingRange&quot;],2),Wt.getArray(e,t,[&quot;mappingRange&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkScalarsToColors&quot;),e.setVectorModeToMagnitude=()=>e.setVectorMode(tl.MAGNITUDE),e.setVectorModeToComponent=()=>e.setVectorMode(tl.COMPONENT),e.setVectorModeToRGBColors=()=>e.setVectorMode(tl.RGBCOLORS),e.build=()=>{},e.isOpaque=()=>!0,e.setAnnotations=(n,r)=>{if(!(n&&!r||!n&&r))if(n&&r&&n.length!==r.length)ol(&quot;Values and annotations do not have the same number of tuples so ignoring&quot;);else{if(t.annotationArray=[],r&&n){const e=r.length;for(let o=0;o<e;o++)t.annotationArray.push({value:n[o],annotation:String(r[o])})}e.updateAnnotatedValueMap(),e.modified()}},e.setAnnotation=(n,r)=>{let o=e.checkForAnnotatedValue(n),a=!1;return o>=0?t.annotationArray[o].annotation!==r&&(t.annotationArray[o].annotation=r,a=!0):(t.annotationArray.push({value:n,annotation:r}),o=t.annotationArray.length-1,a=!0),a&&(e.updateAnnotatedValueMap(),e.modified()),o},e.getNumberOfAnnotatedValues=()=>t.annotationArray.length,e.getAnnotatedValue=e=>e<0||e>=t.annotationArray.length?null:t.annotationArray[e].value,e.getAnnotation=e=>void 0===t.annotationArray[e]?null:t.annotationArray[e].annotation,e.getAnnotatedValueIndex=n=>t.annotationArray.length?e.checkForAnnotatedValue(n):-1,e.removeAnnotation=n=>{const r=e.checkForAnnotatedValue(n),o=r>=0;return o&&(t.annotationArray.splice(r,1),e.updateAnnotatedValueMap(),e.modified()),o},e.resetAnnotations=()=>{t.annotationArray=[],t.annotatedValueMap=[],e.modified()},e.getAnnotationColor=(n,r)=>{if(t.indexedLookup){const t=e.getAnnotatedValueIndex(n);e.getIndexedColor(t,r)}else e.getColor(parseFloat(n),r),r[3]=1},e.checkForAnnotatedValue=t=>e.getAnnotatedValueIndexInternal(t),e.getAnnotatedValueIndexInternal=e=>{if(void 0!==t.annotatedValueMap[e]){const n=t.annotationArray.length;return t.annotatedValueMap[e]%n}return-1},e.getIndexedColor=(e,t)=>{t[0]=0,t[1]=0,t[2]=0,t[3]=0},e.updateAnnotatedValueMap=()=>{t.annotatedValueMap=[];const e=t.annotationArray.length;for(let n=0;n<e;n++)t.annotatedValueMap[t.annotationArray[n].value]=n},e.mapScalars=(t,n,r)=>{const o=t.getNumberOfComponents();let a=null;if(n===rl.DEFAULT&&(t.getDataType()===nl.UNSIGNED_CHAR||t.getDataType()===nl.UNSIGNED_CHAR_CLAMPED)||n===rl.DIRECT_SCALARS&&t)a=e.convertToRGBA(t,o,t.getNumberOfTuples());else{const n={type:&quot;vtkDataArray&quot;,name:&quot;temp&quot;,numberOfComponents:4,dataType:nl.UNSIGNED_CHAR},i=Wt.newTypedArray(n.dataType,4*t.getNumberOfTuples());n.values=i,n.size=i.length,a=xs.newInstance(n);let s=r;s<0&&o>1?e.mapVectorsThroughTable(t,a,Js.RGBA,-1,-1):(s<0&&(s=0),s>=o&&(s=o-1),e.mapScalarsThroughTable(t,a,Js.RGBA,s))}return a},e.mapVectorsToMagnitude=(e,t,n)=>{const r=e.getNumberOfTuples(),o=e.getNumberOfComponents(),a=t.getData(),i=e.getData();for(let e=0;e<r;e++){let t=0;for(let r=0;r<n;r++)t+=i[e*o+r]*i[e*o+r];a[e]=Math.sqrt(t)}},e.mapVectorsThroughTable=(t,n,r,o,a)=>{let i=e.getVectorMode(),s=a,l=o;const c=t.getNumberOfComponents();i===tl.COMPONENT?(-1===l&&(l=e.getVectorComponent()),l<0&&(l=0),l>=c&&(l=c-1)):(-1===s&&(s=e.getVectorSize()),s<=0?(l=0,s=c):(l<0&&(l=0),l>=c&&(l=c-1),l+s>c&&(s=c-l)),i!==tl.MAGNITUDE||1!==c&&1!==s||(i=tl.COMPONENT));let u=0;switch(l>0&&(u=l),i){case tl.COMPONENT:e.mapScalarsThroughTable(t,n,r,u);break;case tl.RGBCOLORS:break;case tl.MAGNITUDE:default:{const o=xs.newInstance({numberOfComponents:1,values:new Float32Array(t.getNumberOfTuples())});e.mapVectorsToMagnitude(t,o,s),e.mapScalarsThroughTable(o,n,r,0);break}}},e.luminanceToRGBA=(e,t,n,r)=>{const o=r(n),a=t.getData(),i=e.getData(),s=a.length;let l=0;for(let e=0;e<s;e+=1){const t=r(a[e]);i[4*l]=t,i[4*l+1]=t,i[4*l+2]=t,i[4*l+3]=o,l++}},e.luminanceAlphaToRGBA=(e,t,n,r)=>{const o=t.getData(),a=e.getData(),i=o.length;let s=0;for(let e=0;e<i;e+=2){const t=r(o[e]);a[s]=t,a[s+1]=t,a[s+2]=t,a[s+3]=r(o[e+1])*n,s+=4}},e.rGBToRGBA=(e,t,n,r)=>{const o=il(n),a=t.getData(),i=e.getData(),s=a.length;let l=0;for(let e=0;e<s;e+=3)i[4*l]=r(a[e]),i[4*l+1]=r(a[e+1]),i[4*l+2]=r(a[e+2]),i[4*l+3]=o,l++},e.rGBAToRGBA=(e,t,n,r)=>{const o=t.getData(),a=e.getData(),i=o.length;let s=0;for(let e=0;e<i;e+=4)a[4*s]=r(o[e]),a[4*s+1]=r(o[e+1]),a[4*s+2]=r(o[e+2]),a[4*s+3]=r(o[e+3])*n,s++},e.convertToRGBA=(n,r,o)=>{let{alpha:a}=t;if(4===r&&a>=1&&n.getDataType()===nl.UNSIGNED_CHAR)return n;const i=xs.newInstance({numberOfComponents:4,empty:!0,size:4*o,dataType:nl.UNSIGNED_CHAR});if(o<=0)return i;a=a>0?a:0,a=a<1?a:1;let s=al;switch(n.getDataType()!==nl.FLOAT&&n.getDataType()!==nl.DOUBLE||(s=il),r){case 1:e.luminanceToRGBA(i,n,a,s);break;case 2:e.luminanceAlphaToRGBA(i,n,s);break;case 3:e.rGBToRGBA(i,n,a,s);break;case 4:e.rGBAToRGBA(i,n,a,s);break;default:return ol(&quot;Cannot convert colors&quot;),null}return i},e.usingLogScale=()=>!1,e.getNumberOfAvailableColors=()=>16777216,e.setRange=(t,n)=>e.setMappingRange(t,n),e.getRange=()=>e.getMappingRange(),e.areScalarsOpaque=(n,r,o)=>{if(!n)return e.isOpaque();const a=n.getNumberOfComponents();return(r!==rl.DEFAULT||n.getDataType()!==nl.UNSIGNED_CHAR)&&r!==rl.DIRECT_SCALARS||(3===a||1===a?t.alpha>=1:255===n.getRange(a-1)[0])}}(e,t)}var cl={newInstance:Wt.newInstance(ll,&quot;vtkScalarsToColors&quot;),extend:ll,...Zs};const{vtkErrorMacro:ul}=Wt,dl={numberOfColors:256,hueRange:[0,.66667],saturationRange:[1,1],valueRange:[1,1],alphaRange:[1,1],nanColor:[.5,0,0,1],belowRangeColor:[0,0,0,1],aboveRangeColor:[1,1,1,1],useAboveRangeColor:!1,useBelowRangeColor:!1,alpha:1};function pl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,dl,n),cl.extend(e,t,n),t.table||(t.table=[]),t.buildTime={},Wt.obj(t.buildTime),t.opaqueFlagBuildTime={},Wt.obj(t.opaqueFlagBuildTime,{mtime:0}),t.insertTime={},Wt.obj(t.insertTime,{mtime:0}),Wt.get(e,t,[&quot;buildTime&quot;]),Wt.setGet(e,t,[&quot;numberOfColors&quot;,&quot;useAboveRangeColor&quot;,&quot;useBelowRangeColor&quot;]),Wt.setArray(e,t,[&quot;alphaRange&quot;,&quot;hueRange&quot;,&quot;saturationRange&quot;,&quot;valueRange&quot;],2),Wt.setArray(e,t,[&quot;nanColor&quot;,&quot;belowRangeColor&quot;,&quot;aboveRangeColor&quot;],4),Wt.getArray(e,t,[&quot;hueRange&quot;,&quot;saturationRange&quot;,&quot;valueRange&quot;,&quot;alphaRange&quot;,&quot;nanColor&quot;,&quot;belowRangeColor&quot;,&quot;aboveRangeColor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkLookupTable&quot;),e.isOpaque=()=>{if(t.opaqueFlagBuildTime.getMTime()<e.getMTime()){let e=!0;t.nanColor[3]<1&&(e=0),t.useBelowRangeColor&&t.belowRangeColor[3]<1&&(e=0),t.useAboveRangeColor&&t.aboveRangeColor[3]<1&&(e=0);for(let n=3;n<t.table.length&&e;n+=4)t.table[n]<255&&(e=!1);t.opaqueFlag=e,t.opaqueFlagBuildTime.modified()}return t.opaqueFlag},e.usingLogScale=()=>!1,e.getNumberOfAvailableColors=()=>t.table.length/4-3,e.linearIndexLookup=(e,t)=>{let n=0;const r=Number(e);return r<t.range[0]?n=t.maxIndex+0+1.5:r>t.range[1]?n=t.maxIndex+1+1.5:(n=(r+t.shift)*t.scale,n=n<t.maxIndex?n:t.maxIndex),Math.floor(n)},e.linearLookup=(t,n,r)=>{let o=0;o=Oa(t)?Math.floor(r.maxIndex+1.5+2):e.linearIndexLookup(t,r);const a=4*o;return n.slice(a,a+4)},e.indexedLookupFunction=(n,r,o)=>{let a=e.getAnnotatedValueIndexInternal(n);-1===a&&(a=t.numberOfColors+2);const i=4*a;return[r[i],r[i+1],r[i+2],r[i+3]]},e.lookupShiftAndScale=(e,t)=>{t.shift=-e[0],t.scale=Number.MAX_VALUE,e[1]>e[0]&&(t.scale=(t.maxIndex+1)/(e[1]-e[0]))},e.mapScalarsThroughTable=(n,r,o,a)=>{let i=e.linearLookup;t.indexedLookup&&(i=e.indexedLookupFunction);const s=e.getMappingRange(),l={maxIndex:e.getNumberOfColors()-1,range:s,shift:0,scale:0};e.lookupShiftAndScale(s,l);const c=e.getAlpha(),u=n.getNumberOfTuples(),d=n.getNumberOfComponents(),p=r.getData(),f=n.getData();if(c>=1){if(o===Ys.RGBA)for(let e=0;e<u;e++){const n=i(f[e*d+a],t.table,l);p[4*e]=n[0],p[4*e+1]=n[1],p[4*e+2]=n[2],p[4*e+3]=n[3]}}else if(o===Ys.RGBA)for(let e=0;e<u;e++){const n=i(f[e*d+a],t.table,l);p[4*e]=n[0],p[4*e+1]=n[1],p[4*e+2]=n[2],p[4*e+3]=Math.floor(n[3]*c+.5)}},e.forceBuild=()=>{let n=0,r=0,o=0,a=0;const i=t.numberOfColors-1;i&&(n=(t.hueRange[1]-t.hueRange[0])/i,r=(t.saturationRange[1]-t.saturationRange[0])/i,o=(t.valueRange[1]-t.valueRange[0])/i,a=(t.alphaRange[1]-t.alphaRange[0])/i),t.table.length=4*i+16;const s=[],l=[];for(let e=0;e<=i;e++)s[0]=t.hueRange[0]+e*n,s[1]=t.saturationRange[0]+e*r,s[2]=t.valueRange[0]+e*o,da(s,l),l[3]=t.alphaRange[0]+e*a,t.table[4*e]=255*l[0]+.5,t.table[4*e+1]=255*l[1]+.5,t.table[4*e+2]=255*l[2]+.5,t.table[4*e+3]=255*l[3]+.5;e.buildSpecialColors(),t.buildTime.modified()},e.setTable=n=>{if(Array.isArray(n)){const r=n[0].length;t.numberOfColors=n.length;const o=4-r;let a=0;for(let e=0;e<t.numberOfColors;e++)t.table[4*e]=255,t.table[4*e+1]=255,t.table[4*e+2]=255,t.table[4*e+3]=255;for(let e=0;e<n.length;e++){const i=n[e];for(let e=0;e<r;e++)t.table[a++]=i[e];a+=o}return e.buildSpecialColors(),t.insertTime.modified(),e.modified(),!0}if(4!==n.getNumberOfComponents())return ul(&quot;Expected 4 components for RGBA colors&quot;),!1;if(n.getDataType()!==cs.UNSIGNED_CHAR)return ul(&quot;Expected unsigned char values for RGBA colors&quot;),!1;t.numberOfColors=n.getNumberOfTuples();const r=n.getData();t.table.length=r.length;for(let e=0;e<r.length;e++)t.table[e]=r[e];return e.buildSpecialColors(),t.insertTime.modified(),e.modified(),!0},e.buildSpecialColors=()=>{const{numberOfColors:e}=t,n=t.table;let r=4*(e+0);t.useBelowRangeColor||0===e?(n[r]=255*t.belowRangeColor[0]+.5,n[r+1]=255*t.belowRangeColor[1]+.5,n[r+2]=255*t.belowRangeColor[2]+.5,n[r+3]=255*t.belowRangeColor[3]+.5):(n[r]=n[0],n[r+1]=n[1],n[r+2]=n[2],n[r+3]=n[3]),r=4*(e+1),t.useAboveRangeColor||0===e?(n[r]=255*t.aboveRangeColor[0]+.5,n[r+1]=255*t.aboveRangeColor[1]+.5,n[r+2]=255*t.aboveRangeColor[2]+.5,n[r+3]=255*t.aboveRangeColor[3]+.5):(n[r]=n[4*(e-1)+0],n[r+1]=n[4*(e-1)+1],n[r+2]=n[4*(e-1)+2],n[r+3]=n[4*(e-1)+3]),r=4*(e+2),n[r]=255*t.nanColor[0]+.5,n[r+1]=255*t.nanColor[1]+.5,n[r+2]=255*t.nanColor[2]+.5,n[r+3]=255*t.nanColor[3]+.5},e.build=()=>{(t.table.length<1||e.getMTime()>t.buildTime.getMTime()&&t.insertTime.getMTime()<=t.buildTime.getMTime())&&e.forceBuild()},t.table.length>0&&(e.buildSpecialColors(),t.insertTime.modified())}(e,t)}var fl={newInstance:Wt.newInstance(pl,&quot;vtkLookupTable&quot;),extend:pl};const gl={Off:0,PolygonOffset:1};let ml=gl.PolygonOffset,hl=gl.Off;const vl=[&quot;VTK_RESOLVE_OFF&quot;,&quot;VTK_RESOLVE_POLYGON_OFFSET&quot;];function Tl(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;const t=hl===e;return hl=e,t}var yl={Resolve:gl,getResolveCoincidentTopologyAsString:function(){return vl[hl]},getResolveCoincidentTopologyPolygonOffsetFaces:function(){return ml},getResolveCoincidentTopology:function(){return hl},setResolveCoincidentTopology:Tl,setResolveCoincidentTopologyPolygonOffsetFaces:function(e){const t=ml===e;return ml=e,t},setResolveCoincidentTopologyToDefault:function(){return Tl(gl.Off)},setResolveCoincidentTopologyToOff:function(){return Tl(gl.Off)},setResolveCoincidentTopologyToPolygonOffset:function(){return Tl(gl.PolygonOffset)}};function bl(e,t,n){n.forEach((n=>{e[`get${n.method}`]=()=>t[n.key],e[`set${n.method}`]=Wt.objectSetterMap.object(e,t,{name:n.key,params:[&quot;factor&quot;,&quot;offset&quot;]})}))}const xl=[&quot;Polygon&quot;,&quot;Line&quot;,&quot;Point&quot;],Cl={modified:()=>{}};bl(Cl,{Polygon:{factor:2,offset:0},Line:{factor:1,offset:-1},Point:{factor:0,offset:-2}},xl.map((e=>({key:e,method:`ResolveCoincidentTopology${e}OffsetParameters`}))));var Sl={implementCoincidentTopologyMethods:function(e,t){void 0===t.resolveCoincidentTopology&&(t.resolveCoincidentTopology=!1),Wt.setGet(e,t,[&quot;resolveCoincidentTopology&quot;]),t.topologyOffset={Polygon:{factor:0,offset:0},Line:{factor:0,offset:0},Point:{factor:0,offset:0}},Object.keys(yl).forEach((t=>{e[t]=yl[t]})),Object.keys(Cl).filter((e=>&quot;modified&quot;!==e)).forEach((t=>{e[t]=Cl[t]})),bl(e,t.topologyOffset,xl.map((e=>({key:e,method:`RelativeCoincidentTopology${e}OffsetParameters`})))),e.getCoincidentTopologyPolygonOffsetParameters=()=>{const t=Cl.getResolveCoincidentTopologyPolygonOffsetParameters(),n=e.getRelativeCoincidentTopologyPolygonOffsetParameters();return{factor:t.factor+n.factor,offset:t.offset+n.offset}},e.getCoincidentTopologyLineOffsetParameters=()=>{const t=Cl.getResolveCoincidentTopologyLineOffsetParameters(),n=e.getRelativeCoincidentTopologyLineOffsetParameters();return{factor:t.factor+n.factor,offset:t.offset+n.offset}},e.getCoincidentTopologyPointOffsetParameter=()=>{const t=Cl.getResolveCoincidentTopologyPointOffsetParameters(),n=e.getRelativeCoincidentTopologyPointOffsetParameters();return{factor:t.factor+n.factor,offset:t.offset+n.offset}}},staticOffsetAPI:Cl,otherStaticMethods:yl,CATEGORIES:xl,Resolve:gl};const Al={MIN_KNOWN_PASS:0,ACTOR_PASS:0,COMPOSITE_INDEX_PASS:1,ID_LOW24:2,ID_HIGH24:3,MAX_KNOWN_PASS:3};var Il={PassTypes:Al};const{FieldAssociations:wl}=Us,{staticOffsetAPI:Ol,otherStaticMethods:Pl}=Sl,{ColorMode:Rl,ScalarMode:Ml,GetArray:El}=Qs,{VectorMode:Vl}=Zs,{VtkDataTypes:Dl}=xs;function Ll(e){return()=>Wt.vtkErrorMacro(`vtkMapper::${e} - NOT IMPLEMENTED`)}function Bl(e,t){const n=e[1]%2==0?1:-1;if(e[0]+=n,e[0]>=t[0]||e[0]<0){const r=e[2]%2==0?1:-1;e[0]-=n,e[1]+=r,(e[1]>=t[1]||e[1]<0)&&(e[1]-=r,e[2]++)}}function Nl(e,t,n){const r=Math.floor(t),o=r%(2*n[0]);let a,i;o<n[0]?(e[0]=o,a=1,i=e[0]===n[0]-1):(e[0]=2*n[0]-1-o,a=-1,i=0===e[0]);const s=Math.floor(r/n[0]),l=s%(2*n[1]);let c,u;l<n[1]?(e[1]=l,c=1,u=e[1]===n[1]-1):(e[1]=2*n[1]-1-l,c=-1,u=0===e[1]),e[2]=Math.floor(s/n[1]);const d=t-r;i?u?e[2]+=d:e[1]+=c*d:e[0]+=a*d,e[0]=(e[0]+.5)/n[0],e[1]=(e[1]+.5)/n[1],e[2]=(e[2]+.5)/n[2]}const Fl=new WeakMap;const _l={colorMapColors:null,areScalarsMappedFromCells:!1,static:!1,lookupTable:null,scalarVisibility:!0,scalarRange:[0,1],useLookupTableScalarRange:!1,colorMode:0,scalarMode:0,arrayAccessMode:1,renderTime:0,colorByArrayName:null,fieldDataTupleId:-1,populateSelectionSettings:!0,selectionWebGLIdsToVTKIds:null,interpolateScalarsBeforeMapping:!1,colorCoordinates:null,colorTextureMap:null,numberOfColorsInRange:0,forceCompileOnly:0,useInvertibleColors:!1,invertibleScalars:null,customShaderAttributes:[]};function kl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,_l,n),As(e,t,n),Wt.get(e,t,[&quot;areScalarsMappedFromCells&quot;,&quot;colorCoordinates&quot;,&quot;colorMapColors&quot;,&quot;colorTextureMap&quot;,&quot;numberOfColorsInRange&quot;,&quot;selectionWebGLIdsToVTKIds&quot;]),Wt.setGet(e,t,[&quot;colorByArrayName&quot;,&quot;arrayAccessMode&quot;,&quot;colorMode&quot;,&quot;fieldDataTupleId&quot;,&quot;interpolateScalarsBeforeMapping&quot;,&quot;lookupTable&quot;,&quot;populateSelectionSettings&quot;,&quot;renderTime&quot;,&quot;scalarMode&quot;,&quot;scalarVisibility&quot;,&quot;static&quot;,&quot;useLookupTableScalarRange&quot;,&quot;customShaderAttributes&quot;]),Wt.setGetArray(e,t,[&quot;scalarRange&quot;],2),Sl.implementCoincidentTopologyMethods(e,t),function(e,t){t.classHierarchy.push(&quot;vtkMapper&quot;),e.getBounds=()=>{const n=e.getInputData();return n?(t.static||e.update(),t.bounds=n.getBounds()):t.bounds=Pa(),t.bounds},e.setForceCompileOnly=e=>{t.forceCompileOnly=e},e.setSelectionWebGLIdsToVTKIds=e=>{t.selectionWebGLIdsToVTKIds=e},e.createDefaultLookupTable=()=>{t.lookupTable=fl.newInstance()},e.getColorModeAsString=()=>Wt.enumToString(Rl,t.colorMode),e.setColorModeToDefault=()=>e.setColorMode(0),e.setColorModeToMapScalars=()=>e.setColorMode(1),e.setColorModeToDirectScalars=()=>e.setColorMode(2),e.getScalarModeAsString=()=>Wt.enumToString(Ml,t.scalarMode),e.setScalarModeToDefault=()=>e.setScalarMode(0),e.setScalarModeToUsePointData=()=>e.setScalarMode(1),e.setScalarModeToUseCellData=()=>e.setScalarMode(2),e.setScalarModeToUsePointFieldData=()=>e.setScalarMode(3),e.setScalarModeToUseCellFieldData=()=>e.setScalarMode(4),e.setScalarModeToUseFieldData=()=>e.setScalarMode(5),e.getAbstractScalars=(e,n,r,o,a)=>{if(!e||!t.scalarVisibility)return{scalars:null,cellFlag:!1};let i=null,s=!1;if(n===Ml.DEFAULT)i=e.getPointData().getScalars(),i||(i=e.getCellData().getScalars(),s=!0);else if(n===Ml.USE_POINT_DATA)i=e.getPointData().getScalars();else if(n===Ml.USE_CELL_DATA)i=e.getCellData().getScalars(),s=!0;else if(n===Ml.USE_POINT_FIELD_DATA){const t=e.getPointData();i=r===El.BY_ID?t.getArrayByIndex(o):t.getArrayByName(a)}else if(n===Ml.USE_CELL_FIELD_DATA){const t=e.getCellData();s=!0,i=r===El.BY_ID?t.getArrayByIndex(o):t.getArrayByName(a)}else if(n===Ml.USE_FIELD_DATA){const t=e.getFieldData();i=r===El.BY_ID?t.getArrayByIndex(o):t.getArrayByName(a)}return{scalars:i,cellFlag:s}},e.mapScalars=(n,r)=>{const{scalars:o,cellFlag:a}=e.getAbstractScalars(n,t.scalarMode,t.arrayAccessMode,t.arrayId,t.colorByArrayName);if(t.areScalarsMappedFromCells=a,!o)return t.colorCoordinates=null,t.colorTextureMap=null,void(t.colorMapColors=null);const i=`${e.getMTime()}${o.getMTime()}${r}`;if(t.colorBuildString!==i){if(t.useLookupTableScalarRange||e.getLookupTable().setRange(t.scalarRange[0],t.scalarRange[1]),e.canUseTextureMapForColoring(o,a))t.mapScalarsToTexture(o,a,r);else{t.colorCoordinates=null,t.colorTextureMap=null;const n=e.getLookupTable();n&&(n.build(),t.colorMapColors=n.mapScalars(o,t.colorMode,t.fieldDataTupleId))}t.colorBuildString=`${e.getMTime()}${o.getMTime()}${r}`}},t.mapScalarsToTexture=(n,r,o)=>{const a=t.lookupTable.getRange(),i=t.lookupTable.usingLogScale(),s=t.lookupTable.getAlpha(),l=i?[Math.log10(a[0]),Math.log10(a[1])]:a;if(t.colorMapColors=null,null==t.colorTextureMap||e.getMTime()>t.colorTextureMap.getMTime()||t.lookupTable.getMTime()>t.colorTextureMap.getMTime()||t.lookupTable.getAlpha()!==o){t.lookupTable.setAlpha(o),t.colorTextureMap=null,t.lookupTable.build();const e=t.lookupTable.getNumberOfAvailableColors(),n=2048,a=2,d=r?n**3-3:4094;t.numberOfColorsInRange=Math.min(Math.max(e,a),d);const p=t.numberOfColorsInRange+3,f=t.numberOfColorsInRange+2,g=r?[Math.min(Math.ceil(p/n**0),n),Math.min(Math.ceil(p/n**1),n),Math.min(Math.ceil(p/n**2),n)]:[f,2,1],m=g[0]*g[1]*g[2],h=new Float64Array(m);h.fill(NaN);const v=t.numberOfColorsInRange,T=v+2,y=[0,0,0],b=l[0],x=l[1]-l[0];for(let e=0;e<T;++e){const t=b+x*(e-1)/(v-1),n=i?10**t:t;h[(u=g,(c=y)[0]+u[0]*(c[1]+u[1]*c[2]))]=n,Bl(y,g)}const C=xs.newInstance({numberOfComponents:1,values:h}),S=t.lookupTable.mapScalars(C,t.colorMode,0);t.colorTextureMap=Xs.newInstance(),t.colorTextureMap.setDimensions(g),t.colorTextureMap.getPointData().setScalars(S),t.lookupTable.setAlpha(s)}var c,u;const d=t.lookupTable.getVectorMode()===Vl.MAGNITUDE&&n.getNumberOfComponents()>1?-1:t.lookupTable.getVectorComponent();t.colorCoordinates=function(e,t,n,r,o,a,i){const s=new Array(arguments.length);for(let e=0;e<arguments.length;++e){const t=arguments[e];s[e]=t.getMTime?.()??t}const l=s.join(&quot;/&quot;),c=Fl.get(e);if(c&&c.stringHash===l)return c.textureCoordinates;const u=(n[1]-n[0])/(o-1),[d,p]=[n[0]-u,n[1]+u],f=d-.5*u,g=1/(p-d+u),m=d,h=(o+1)/(p-d),v=e.getData(),T=e.getNumberOfTuples(),y=e.getNumberOfComponents(),b=t<0||t>=y,x=a[2]<=1?2:3,C=xs.newInstance({numberOfComponents:x,values:new Float32Array(T*x)}),S=C.getData(),A=[0,0,0];Nl(A,o+2,a);let I=0,w=0;const O=[.5,.5,.5];for(let e=0;e<T;++e){let e;if(b){let t=0;for(let e=0;e<y;++e){const n=Number(v[I+e]);t+=n*n}e=Math.sqrt(t)}else e=Number(v[I+t]);if(r&&(e=Math.log10(e)),I+=y,Oa(e))O[0]=A[0],O[1]=A[1],O[2]=A[2];else if(i){let t=(e-m)*h;t<1?t=0:t>o&&(t=o+1),Nl(O,t,a)}else{O[1]=.49;const t=(e-f)*g;O[0]=t>1e3?1e3:t<-1e3?-1e3:t}for(let e=0;e<x;++e)S[w++]=O[e]}return Fl.set(e,{stringHash:l,textureCoordinates:C}),C}(n,d,l,i,t.numberOfColorsInRange,t.colorTextureMap.getDimensions(),r)},e.getIsOpaque=()=>{const n=e.getInputData(),r=e.getAbstractScalars(n,t.scalarMode,t.arrayAccessMode,t.arrayId,t.colorByArrayName).scalars;if(!t.scalarVisibility||null==r)return!0;const o=e.getLookupTable();return!o||(o.build(),o.areScalarsOpaque(r,t.colorMode,-1))},e.canUseTextureMapForColoring=(e,n)=>!((!n||t.colorMode===Rl.DIRECT_SCALARS)&&(!t.interpolateScalarsBeforeMapping||t.lookupTable&&t.lookupTable.getIndexedLookup()||!e||t.colorMode===Rl.DEFAULT&&e.getDataType()===Dl.UNSIGNED_CHAR||t.colorMode===Rl.DIRECT_SCALARS)),e.clearColorArrays=()=>{t.colorMapColors=null,t.colorCoordinates=null,t.colorTextureMap=null},e.getLookupTable=()=>(t.lookupTable||e.createDefaultLookupTable(),t.lookupTable),e.getMTime=()=>{let e=t.mtime;if(null!==t.lookupTable){const n=t.lookupTable.getMTime();e=n>e?n:e}return e},e.getPrimitiveCount=()=>{const t=e.getInputData();return{points:t.getPoints().getNumberOfValues()/3,verts:t.getVerts().getNumberOfValues()-t.getVerts().getNumberOfCells(),lines:t.getLines().getNumberOfValues()-2*t.getLines().getNumberOfCells(),triangles:t.getPolys().getNumberOfValues()-3*t.getPolys().getNumberOfCells()}},e.acquireInvertibleLookupTable=Ll(&quot;AcquireInvertibleLookupTable&quot;),e.valueToColor=Ll(&quot;ValueToColor&quot;),e.colorToValue=Ll(&quot;ColorToValue&quot;),e.useInvertibleColorFor=Ll(&quot;UseInvertibleColorFor&quot;),e.clearInvertibleColor=Ll(&quot;ClearInvertibleColor&quot;),e.processSelectorPixelBuffers=(e,n)=>{if(!e||!t.selectionWebGLIdsToVTKIds||!t.populateSelectionSettings)return;const r=e.getRawPixelBuffer(Al.ID_LOW24),o=e.getRawPixelBuffer(Al.ID_HIGH24),a=e.getCurrentPass(),i=e.getFieldAssociation();let s=null;i===wl.FIELD_ASSOCIATION_POINTS?s=t.selectionWebGLIdsToVTKIds.points:i===wl.FIELD_ASSOCIATION_CELLS&&(s=t.selectionWebGLIdsToVTKIds.cells),s&&n.forEach((t=>{if(a===Al.ID_LOW24){let n=0;o&&(n+=o[t],n*=256),n+=r[t+2],n*=256,n+=r[t+1],n*=256,n+=r[t];const a=s[n],i=e.getPixelBuffer(Al.ID_LOW24);i[t]=255&a,i[t+1]=(65280&a)>>8,i[t+2]=(16711680&a)>>16}else if(a===Al.ID_HIGH24&&o){let n=0;n+=o[t],n*=256,n+=r[t+2],n*=256,n+=r[t+1],n*=256,n+=r[t];const a=s[n];e.getPixelBuffer(Al.ID_HIGH24)[t]=(4278190080&a)>>24}}))}}(e,t)}var Gl={newInstance:Wt.newInstance(kl,&quot;vtkMapper&quot;),extend:kl,...Ol,...Pl,...Qs};const{isVtkObject:Ul}=Wt;function zl(e){let t=0;return e.filter(((e,n)=>n===t&&(t+=e+1,!0)))}function Wl(e){let t=0;for(let n=0;n<e.length;)n+=e[n]+1,t++;return t}const Hl={extractCellSizes:zl,getNumberOfCells:Wl};function jl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};xs.extend(e,t,function(e){return{empty:!0,numberOfComponents:1,dataType:cs.UNSIGNED_INT,...e}}(n)),function(e,t){t.classHierarchy.push(&quot;vtkCellArray&quot;);const n={...e};e.getNumberOfCells=n=>void 0===t.numberOfCells||n?(t.cellSizes?t.numberOfCells=t.cellSizes.length:t.numberOfCells=Wl(e.getData()),t.numberOfCells):t.numberOfCells,e.getCellSizes=n=>void 0===t.cellSizes||n?(t.cellSizes=zl(e.getData()),t.cellSizes):t.cellSizes,e.resize=r=>{const o=e.getNumberOfTuples();n.resize(r);const a=e.getNumberOfTuples();a<o&&(0===a?(t.numberOfCells=0,t.cellSizes=[]):(t.numberOfCells=void 0,t.cellSizes=void 0))},e.setData=e=>{n.setData(e,1),t.numberOfCells=void 0,t.cellSizes=void 0},e.getCell=e=>{let n=e;const r=t.values[n++];return t.values.subarray(n,n+r)},e.insertNextCell=n=>{let r;r=Ul(n)?n.getPointsIds():n;const o=e.getNumberOfCells();return e.insertNextTuples([r.length,...r]),++t.numberOfCells,null!=t.cellSizes&&t.cellSizes.push(r.length),o},e.getMaxCellSize=()=>e.getCellSizes().reduce(((e,t)=>Math.max(e,t)),0)}(e,t)}var Kl={newInstance:Wt.newInstance(jl,&quot;vtkCellArray&quot;),extend:jl,...Hl};const{vtkErrorMacro:$l}=Wt,ql={empty:!0,numberOfComponents:3,dataType:cs.FLOAT,bounds:[1,-1,1,-1,1,-1]};function Xl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ql,n),xs.extend(e,t,n),Wt.getArray(e,t,[&quot;bounds&quot;],6),function(e,t){let n=0;t.classHierarchy.push(&quot;vtkPoints&quot;),e.getNumberOfPoints=e.getNumberOfTuples,e.setNumberOfPoints=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:3;e.getNumberOfPoints()!==n&&(t.size=n*r,t.values=Wt.newTypedArray(t.dataType,t.size),e.setNumberOfComponents(r),e.modified())},e.setPoint=function(t){for(var n=arguments.length,r=new Array(n>1?n-1:0),o=1;o<n;o++)r[o-1]=arguments[o];e.setTuple(t,r)},e.getPoint=e.getTuple,e.findPoint=e.findTuple,e.insertNextPoint=(t,n,r)=>e.insertNextTuple([t,n,r]),e.insertPoint=(t,n)=>e.insertTuple(t,n);const r=e.getBounds;e.getBounds=()=>(n<t.mtime&&e.computeBounds(),r());const o=e.getBoundsByReference;e.getBoundsByReference=()=>(n<t.mtime&&e.computeBounds(),o()),e.computeBounds=()=>{if(3===e.getNumberOfComponents()){const n=e.getRange(0);t.bounds[0]=n[0],t.bounds[1]=n[1];const r=e.getRange(1);t.bounds[2]=r[0],t.bounds[3]=r[1];const o=e.getRange(2);t.bounds[4]=o[0],t.bounds[5]=o[1]}else if(2===e.getNumberOfComponents()){const n=e.getRange(0);t.bounds[0]=n[0],t.bounds[1]=n[1];const r=e.getRange(1);t.bounds[2]=r[0],t.bounds[3]=r[1],t.bounds[4]=0,t.bounds[5]=0}else $l(`getBounds called on an array with components of ${e.getNumberOfComponents()}`),Ta(t.bounds);n=Wt.getCurrentGlobalMTime()},e.setNumberOfComponents(t.numberOfComponents<2?3:t.numberOfComponents)}(e,t)}var Yl={newInstance:Wt.newInstance(Xl,&quot;vtkPoints&quot;),extend:Xl};const Zl={bounds:[-1,-1,-1,-1,-1,-1],pointsIds:[]};function Ql(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Zl,n),Wt.obj(e,t),t.points||(t.points=Yl.newInstance()),Wt.get(e,t,[&quot;points&quot;,&quot;pointsIds&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkCell&quot;),e.initialize=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(n){t.pointsIds=n;let r=t.points.getData();r.length!==3*t.pointsIds.length&&(r=Wt.newTypedArray(e.getDataType(),3*t.pointsIds.length));const o=e.getData();t.pointsIds.forEach(((e,t)=>{let n=3*e,a=3*t;r[a]=o[n],r[++a]=o[++n],r[++a]=o[++n]})),t.points.setData(r)}else{t.points=e,t.pointsIds=new Array(e.getNumberOfPoints());for(let n=e.getNumberOfPoints()-1;n>=0;--n)t.pointsIds[n]=n}},e.getBounds=()=>t.points.getBounds(),e.getLength2=()=>{const t=Gi.getLengths(e.getBounds());return t[0]*t[0]+t[1]*t[1]+t[2]*t[2]},e.getParametricDistance=e=>{let t,n=0;for(let r=0;r<3;r++)t=e[r]<0?-e[r]:e[r]>1?e[r]-1:0,t>n&&(n=t);return n},e.getNumberOfPoints=()=>t.points.getNumberOfPoints(),e.deepCopy=e=>{e.initialize(t.points,t.pointsIds)},e.getCellDimension=()=>{},e.intersectWithLine=(e,t,n,r,o,a,i)=>{},e.evaluatePosition=(e,t,n,r,o,a)=>{Wt.vtkErrorMacro(&quot;vtkCell.evaluatePosition is not implemented.&quot;)}}(e,t)}var Jl={newInstance:Wt.newInstance(Ql,&quot;vtkCell&quot;),extend:Ql};const ec={array:null,maxId:0,extend:0};function tc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ec,n),Wt.obj(e,t),function(e,t){t.classHierarchy.push(&quot;vtkCellLinks&quot;),e.buildLinks=n=>{const r=n.getPoints().getNumberOfPoints(),o=n.getNumberOfCells(),a=new Uint32Array(r);if(n.isA(&quot;vtkPolyData&quot;)){for(let t=0;t<o;++t){const{cellPointIds:r}=n.getCellPoints(t);r.forEach((t=>{e.incrementLinkCount(t)}))}e.allocateLinks(r),t.maxId=r-1;for(let t=0;t<o;++t){const{cellPointIds:r}=n.getCellPoints(t);r.forEach((n=>{e.insertCellReference(n,a[n]++,t)}))}}else{for(let t=0;t<o;t++)Jl.newInstance().getPointsIds().forEach((t=>{e.incrementLinkCount(t)}));e.allocateLinks(r),t.maxId=r-1;for(let t=0;t<o;++t)Jl.newInstance().getPointsIds().forEach((n=>{e.insertCellReference(n,a[n]++,t)}))}},e.allocate=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1e3;t.array=Array(e).fill().map((()=>({ncells:0,cells:null}))),t.extend=n,t.maxId=-1},e.initialize=()=>{t.array=null},e.getLink=e=>t.array[e],e.getNcells=e=>t.array[e].ncells,e.getCells=e=>t.array[e].cells,e.insertNextPoint=e=>{t.array.push({ncells:e,cells:Array(e)}),++t.maxId},e.insertNextCellReference=(e,n)=>{t.array[e].cells[t.array[e].ncells++]=n},e.deletePoint=e=>{t.array[e].ncells=0,t.array[e].cells=null},e.removeCellReference=(e,n)=>{t.array[n].cells=t.array[n].cells.filter((t=>t!==e)),t.array[n].ncells=t.array[n].cells.length},e.addCellReference=(e,n)=>{t.array[n].cells[t.array[n].ncells++]=e},e.resizeCellList=(e,n)=>{t.array[e].cells.length=n},e.squeeze=()=>{!function(e,t){let n=t;for(t>=e.array.length&&(n+=e.array.length);n>e.array.length;)e.array.push({ncells:0,cells:null});e.array.length=n}(t,t.maxId+1)},e.reset=()=>{t.maxId=-1},e.deepCopy=e=>{t.array=[...e.array],t.extend=e.extend,t.maxId=e.maxId},e.incrementLinkCount=e=>{++t.array[e].ncells},e.allocateLinks=e=>{for(let n=0;n<e;++n)t.array[n].cells=new Array(t.array[n].ncells)},e.insertCellReference=(e,n,r)=>{t.array[e].cells[n]=r}}(e,t)}var nc={newInstance:Wt.newInstance(tc,&quot;vtkCellLinks&quot;),extend:tc};const rc=0,oc=1,ac=2,ic=3,sc=4,lc=5,cc=6,uc=7,dc=9,pc=21,fc=41,gc=42,mc=[&quot;vtkEmptyCell&quot;,&quot;vtkVertex&quot;,&quot;vtkPolyVertex&quot;,&quot;vtkLine&quot;,&quot;vtkPolyLine&quot;,&quot;vtkTriangle&quot;,&quot;vtkTriangleStrip&quot;,&quot;vtkPolygon&quot;,&quot;vtkPixel&quot;,&quot;vtkQuad&quot;,&quot;vtkTetra&quot;,&quot;vtkVoxel&quot;,&quot;vtkHexahedron&quot;,&quot;vtkWedge&quot;,&quot;vtkPyramid&quot;,&quot;vtkPentagonalPrism&quot;,&quot;vtkHexagonalPrism&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;vtkQuadraticEdge&quot;,&quot;vtkQuadraticTriangle&quot;,&quot;vtkQuadraticQuad&quot;,&quot;vtkQuadraticTetra&quot;,&quot;vtkQuadraticHexahedron&quot;,&quot;vtkQuadraticWedge&quot;,&quot;vtkQuadraticPyramid&quot;,&quot;vtkBiQuadraticQuad&quot;,&quot;vtkTriQuadraticHexahedron&quot;,&quot;vtkQuadraticLinearQuad&quot;,&quot;vtkQuadraticLinearWedge&quot;,&quot;vtkBiQuadraticQuadraticWedge&quot;,&quot;vtkBiQuadraticQuadraticHexahedron&quot;,&quot;vtkBiQuadraticTriangle&quot;,&quot;vtkCubicLine&quot;,&quot;vtkQuadraticPolygon&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;vtkConvexPointSet&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;vtkParametricCurve&quot;,&quot;vtkParametricSurface&quot;,&quot;vtkParametricTriSurface&quot;,&quot;vtkParametricQuadSurface&quot;,&quot;vtkParametricTetraRegion&quot;,&quot;vtkParametricHexRegion&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;UnknownClass&quot;,&quot;vtkHigherOrderEdge&quot;,&quot;vtkHigherOrderTriangle&quot;,&quot;vtkHigherOrderQuad&quot;,&quot;vtkHigherOrderPolygon&quot;,&quot;vtkHigherOrderTetrahedron&quot;,&quot;vtkHigherOrderWedge&quot;,&quot;vtkHigherOrderPyramid&quot;,&quot;vtkHigherOrderHexahedron&quot;],hc={getClassNameFromTypeId:function(e){return e<mc.length?mc[e]:&quot;UnknownClass&quot;},getTypeIdFromClassName:function(e){return mc.findIndex(e)},isLinear:function(e){return e<pc||e===fc||e===gc},hasSubCells:function(e){return e===cc||e===sc||e===ac}},vc={size:0,maxId:-1,extend:1e3};function Tc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,vc,n),Wt.obj(e,t),Wt.get(e,t,[&quot;size&quot;,&quot;maxId&quot;,&quot;extend&quot;]),Wt.getArray(e,t,[&quot;typeArray&quot;,&quot;locationArray&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkCellTypes&quot;),e.allocate=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:512,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1e3;t.size=e>0?e:1,t.extend=n>0?n:1,t.maxId=-1,t.typeArray=new Uint8Array(e),t.locationArray=new Uint32Array(e)},e.insertCell=(e,n,r)=>{t.typeArray[e]=n,t.locationArray[e]=r,e>t.maxId&&(t.maxId=e)},e.insertNextCell=(n,r)=>(e.insertCell(++t.maxId,n,r),t.maxId),e.setCellTypes=(e,n,r)=>{t.size=e,t.typeArray=n,t.locationArray=r,t.maxId=e-1},e.getCellLocation=e=>t.locationArray[e],e.deleteCell=e=>{t.typeArray[e]=rc},e.getNumberOfTypes=()=>t.maxId+1,e.isType=t=>{const n=e.getNumberOfTypes();for(let r=0;r<n;++r)if(t===e.getCellType(r))return!0;return!1},e.insertNextType=t=>e.insertNextCell(t,-1),e.getCellType=e=>t.typeArray[e],e.reset=()=>{t.maxId=-1},e.deepCopy=n=>{e.allocate(n.getSize(),n.getExtend()),t.typeArray.set(n.getTypeArray()),t.locationArray.set(n.getLocationArray()),t.maxId=n.getMaxId()}}(e,t)}var yc={newInstance:Wt.newInstance(Tc,&quot;vtkCellTypes&quot;),extend:Tc,...hc};const bc={NO_INTERSECTION:0,YES_INTERSECTION:1,ON_LINE:2};var xc={IntersectionState:bc};const{IntersectionState:Cc}=xc;function Sc(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:null;const o={t:Number.MIN_VALUE,distance:0},a=[];let i;a[0]=n[0]-t[0],a[1]=n[1]-t[1],a[2]=n[2]-t[2];const s=a[0]*(e[0]-t[0])+a[1]*(e[1]-t[1])+a[2]*(e[2]-t[2]),l=Lo(a,a);let c=1e-5*s;return 0!==l&&(o.t=s/l),c<0&&(c=-c),-c<l&&l<c||l<=0||o.t<0?i=t:o.t>1?i=n:(i=a,a[0]=t[0]+o.t*a[0],a[1]=t[1]+o.t*a[1],a[2]=t[2]+o.t*a[2]),r&&(r[0]=i[0],r[1]=i[1],r[2]=i[2]),o.distance=Go(i,e),o}function Ac(e,t,n,r,o,a){const i=[],s=[],l=[];o[0]=0,a[0]=0,Mo(t,e,i),Mo(r,n,s),Mo(n,e,l);const c=[Lo(i,i),-Lo(i,s),-Lo(i,s),Lo(s,s)],u=[];if(u[0]=Lo(i,l),u[1]=-Lo(s,l),0===sa(c,u,2)){let i=Number.MAX_VALUE;const s=[e,t,n,r],l=[n,n,e,e],c=[r,r,t,t];let u;a[0],a[0],o[0],o[0],o[0],o[0],a[0],a[0];for(let e=0;e<4;e++)u=Sc(s[e],l[e],c[e]),u.distance<i&&(i=u.distance,u.t);return Cc.ON_LINE}return o[0]=u[0],a[0]=u[1],o[0]>=0&&o[0]<=1&&a[0]>=0&&a[0]<=1?Cc.YES_INTERSECTION:Cc.NO_INTERSECTION}const Ic={distanceToLine:Sc,intersection:Ac},wc={orientations:null};function Oc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,wc,n),Jl.extend(e,t,n),Wt.setGet(e,t,[&quot;orientations&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkLine&quot;),e.getCellDimension=()=>1,e.intersectWithLine=(e,n,r,o,a)=>{const i={intersect:0,t:Number.MAX_VALUE,subId:0,betweenPoints:null};a[1]=0,a[2]=0;const s=[],l=[],c=[];t.points.getPoint(0,l),t.points.getPoint(1,c);const u=[],d=[],p=Ac(e,n,l,c,u,d);var f;if(i.t=u[0],i.betweenPoints=(f=i.t)>=0&&f<=1,a[0]=d[0],p===Cc.YES_INTERSECTION){for(let t=0;t<3;t++)o[t]=l[t]+a[0]*(c[t]-l[t]),s[t]=e[t]+i.t*(n[t]-e[t]);if(Go(o,s)<=r*r)return i.intersect=1,i}else{let t;if(i.t<0)return t=Sc(e,l,c,o),t.distance<=r*r?(i.t=0,i.intersect=1,i.betweenPoints=!0,i):i;if(i.t>1)return t=Sc(n,l,c,o),t.distance<=r*r?(i.t=1,i.intersect=1,i.betweenPoints=!0,i):i;if(a[0]<0)return a[0]=0,t=Sc(l,e,n,o),i.t=t.t,t.distance<=r*r?(i.intersect=1,i):i;if(a[0]>1)return a[0]=1,t=Sc(c,e,n,o),i.t=t.t,t.distance<=r*r?(i.intersect=1,i):i}return i},e.evaluateLocation=(e,n,r)=>{const o=[],a=[];t.points.getPoint(0,o),t.points.getPoint(1,a);for(let t=0;t<3;t++)n[t]=o[t]+e[0]*(a[t]-o[t]);r[0]=1-e[0],r[1]=e[0]},e.evaluateOrientation=(e,n,r)=>!!t.orientations&&(function(e,t,n,r){var o,a,s,l,c,u=t[0],d=t[1],p=t[2],f=t[3],g=n[0],m=n[1],h=n[2],v=n[3];(a=u*g+d*m+p*h+f*v)<0&&(a=-a,g=-g,m=-m,h=-h,v=-v),1-a>i?(o=Math.acos(a),s=Math.sin(o),l=Math.sin((1-r)*o)/s,c=Math.sin(r*o)/s):(l=1-r,c=r),e[0]=l*u+c*g,e[1]=l*d+c*m,e[2]=l*p+c*h,e[3]=l*f+c*v}(n,t.orientations[0],t.orientations[1],e[0]),r[0]=1-e[0],r[1]=e[0],!0)}(e,t)}var Pc={newInstance:Wt.newInstance(Oc,&quot;vtkLine&quot;),extend:Oc,...Ic,...xc};const Rc={};function Mc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Rc,n),Us.extend(e,t,n),Wt.setGet(e,t,[&quot;points&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkPointSet&quot;),t.points?t.points=ze(t.points):t.points=Yl.newInstance(),e.getNumberOfPoints=()=>t.points.getNumberOfPoints(),e.getBounds=()=>t.points.getBounds(),e.computeBounds=()=>{e.getBounds()};const n=e.shallowCopy;e.shallowCopy=function(e){n(e,arguments.length>1&&void 0!==arguments[1]&&arguments[1]),t.points=Yl.newInstance(),t.points.shallowCopy(e.getPoints())};const r=e.getMTime;e.getMTime=()=>{const e=r();return Math.max(e,t.points?.getMTime()??e)};const o=e.initialize;e.initialize=()=>(t.points?.initialize(),o())}(e,t)}var Ec={newInstance:Wt.newInstance(Mc,&quot;vtkPointSet&quot;),extend:Mc};const Vc={orientations:null,distanceFunction:function(e,t){var n=t[0]-e[0],r=t[1]-e[1],o=t[2]-e[2];return Math.hypot(n,r,o)}};function Dc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Vc,n),Jl.extend(e,t,n),Wt.setGet(e,t,[&quot;orientations&quot;,&quot;distanceFunction&quot;]),t.distancesTime={},Wt.obj(t.distancesTime,{mtime:0}),function(e,t){t.classHierarchy.push(&quot;vtkPolyLine&quot;);const n=Pc.newInstance();n.getPoints().setNumberOfPoints(2),e.getCellDimension=()=>1,e.intersectWithLine=(r,o,a,i,s,l,c)=>{const u={intersect:0,t:Number.MAX_VALUE,subId:0,betweenPoints:null},d=e.getNumberOfPoints()-1;let p=Number.MAX_VALUE;for(let e=0;e<d;e++){const d=[0,0,0];n.getPoints().getData().set(t.points.getData().subarray(3*e,3*(e+2)));const f=n.intersectWithLine(a,i,s,l,c);if(1===f.intersect&&f.t<=u.t+s&&f.t>=r&&f.t<=o){u.intersect=1;const t=n.getParametricDistance(d);if(t<p||t===p&&f.t<u.t){u.subId=e,u.t=f.t,p=t;for(let e=0;e<3;e++)l[e],d[e]}}}return u},e.evaluateLocation=(e,r,o,a)=>(n.getPoints().getData().set(t.points.getData().subarray(3*e,3*(e+2))),n.evaluateLocation(r,o,a)),e.evaluateOrientation=(e,r,o,a)=>(t.orientations?n.setOrientations([t.orientations[e],t.orientations[e+1]]):n.setOrientations(null),n.evaluateOrientation(r,o,a)),e.getDistancesToFirstPoint=()=>{const n=t.distancesTime.getMTime();if(n<t.points.getMTime()||n<e.getMTime()){const n=e.getNumberOfPoints();if(t.distances?t.distances.length=n:t.distances=new Array(n),n>0){const e=new Array(3),a=new Array(3);let i=0;t.distances[0]=i,t.points.getPoint(0,e);for(let s=1;s<n;++s)t.points.getPoint(s,a),i+=t.distanceFunction(e,a),t.distances[s]=i,o=a,(r=e)[0]=o[0],r[1]=o[1],r[2]=o[2]}t.distancesTime.modified()}var r,o;return t.distances},e.findPointIdAtDistanceFromFirstPoint=t=>{const n=e.getDistancesToFirstPoint();if(n.length<2)return-1;let r=0,o=n.length-1;if(t<n[r]||t>n[o]||0===n[o])return-1;for(;o-r>1;){const e=Math.floor((r+o)/2);n[e]<=t?r=e:o=e}return r}}(e,t)}var Lc={newInstance:Wt.newInstance(Dc,&quot;vtkPolyLine&quot;),extend:Dc};const Bc={elements:[]};function Nc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Bc,n),Wt.obj(e,t),function(e,t){t.classHierarchy.push(&quot;vtkPriorityQueue&quot;),e.push=(e,n)=>{const r=t.elements.findIndex((t=>t.priority>e));t.elements.splice(r,0,{priority:e,element:n})},e.pop=()=>t.elements.length>0?t.elements.shift().element:null,e.deleteById=e=>{t.elements=t.elements.filter((t=>{let{element:n}=t;return n.id!==e}))},e.length=()=>t.elements.length}(e,t)}var Fc={newInstance:Wt.newInstance(Nc,&quot;vtkPriorityQueue&quot;),extend:Nc};const _c=1e-6,kc=1.1920929e-7,Gc={FAILURE:-1,OUTSIDE:0,INSIDE:1,INTERSECTION:2,ON_LINE:3};function Uc(e,t,n,r,o){return(r[e]-n[e])*(o[t]-n[t])-(o[e]-n[e])*(r[t]-n[t])}const zc={PolygonWithPointIntersectionState:Gc,pointInPolygon:function(e,t,n,r){if(e[0]<n[0]||e[0]>n[1]||e[1]<n[2]||e[1]>n[3]||e[2]<n[4]||e[2]>n[5])return Gc.OUTSIDE;if(Fo(r)<=kc)return Gc.FAILURE;let o=1e-8*((n[1]-n[0])*(n[1]-n[0])+(n[3]-n[2])*(n[3]-n[2])+(n[5]-n[4])*(n[5]-n[4]));o*=o,o=0===o?kc:o;const a=[],i=[];for(let n=0;n<t.length;){if(a[0]=t[n++],a[1]=t[n++],a[2]=t[n++],Go(e,a)<=o)return Gc.INSIDE;const{distance:r,t:s}=Pc.distanceToLine(e,a,i);if(r<=o&&s>0&&s<1)return Gc.INSIDE}let s,l;Math.abs(r[0])>Math.abs(r[1])?Math.abs(r[0])>Math.abs(r[2])?(s=1,l=2):(s=0,l=1):Math.abs(r[1])>Math.abs(r[2])?(s=0,l=2):(s=0,l=1);let c=0;for(let n=0;n<t.length;)a[0]=t[n++],a[1]=t[n++],a[2]=t[n++],n<t.length?(i[0]=t[n],i[1]=t[n+1],i[2]=t[n+2]):(i[0]=t[0],i[1]=t[1],i[2]=t[2]),a[l]<=e[l]?i[l]>e[l]&&Uc(s,l,a,i,e)>0&&++c:i[l]<=e[l]&&Uc(s,l,a,i,e)<0&&--c;return 0===c?Gc.OUTSIDE:Gc.INSIDE},getBounds:function(e,t,n){const r=e.length,o=[];t.getPoint(e[0],o),n[0]=o[0],n[1]=o[0],n[2]=o[1],n[3]=o[1],n[4]=o[2],n[5]=o[2];for(let a=1;a<r;a++)t.getPoint(e[a],o),Gi.addPoint(n,...o);const a=Gi.getLengths(n);return Lo(a,a)},getNormal:function(e,t,n){n.length=3,n[0]=0,n[1]=0,n[2]=0;const r=[];let o=[],a=[];const i=[],s=[];t.getPoint(e[0],r),t.getPoint(e[1],o);for(let l=2;l<e.length;l++){t.getPoint(e[l],a),Mo(a,o,i),Mo(r,o,s);const c=[0,0,0];Bo(i,s,c),Ro(n,c,n),[o,a]=[a,o]}return Fo(n)},computeCentroid:function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[0,0,0];n[0]=0,n[1]=0,n[2]=0;const r=e.length,o=[];for(let a=0;a<r;a++)t.getPoint(e[a],o),n[0]+=o[0],n[1]+=o[1],n[2]+=o[2];return n[0]/=r,n[1]/=r,n[2]/=r,n}};function Wc(e,t){function n(e){const n=[0,0,0],r=[0,0,0],o=[0,0,0],a=[0,0,0];Mo(e.point,e.previous.point,n),Mo(e.next.point,e.point,r),Mo(e.previous.point,e.next.point,o),Bo(n,r,a);const i=Lo(a,t.normal);if(i<=0)return-1;const s=No(n)+No(r)+No(o);return s*s/i}function r(e){if(t.pointCount<=3)return!0;const n=e.previous,r=e.next,o=[0,0,0];Mo(r.point,n.point,o);const a=[0,0,0];if(Bo(o,t.normal,a),Fo(a),0===No(a))return!1;let i=ei.evaluate(a,n.point,r.next.point),s=i>_c?1:i<-1e-6?-1:0,l=s<0?1:0;for(let e=r.next.next;e.id!==n.id;e=e.next){const t=e.previous;i=ei.evaluate(a,n.point,e.point);const o=i>_c?1:i<-1e-6?-1:0;if(o!==s){if(l||(l=o<=0?1:0),Pc.intersection(n.point,r.point,e.point,t.point,[0],[0])===bc.YES_INTERSECTION)return!1;s=o}}return 1===l}function o(e,r){t.pointCount-=1;const o=e.previous,a=e.next;t.tris=t.tris.concat(e.point),t.tris=t.tris.concat(a.point),t.tris=t.tris.concat(o.point),o.next=a,a.previous=o,r.deleteById(o.id),r.deleteById(a.id);const i=n(o);i>0&&r.push(i,o);const s=n(a);s>0&&r.push(s,a),e.id===t.firstPoint.id&&(t.firstPoint=a)}t.classHierarchy.push(&quot;vtkPolygon&quot;),e.triangulate=()=>t.firstPoint?function(){!function(){const e=[0,0,0],n=[0,0,0];t.normal=[0,0,0];const r=[...t.firstPoint.point];let o=t.firstPoint;for(let a=0;a<t.pointCount;a++){Mo(o.point,r,e),Mo(o.next.point,r,n);const a=[0,0,0];Bo(e,n,a),Ro(t.normal,a,t.normal),o=o.next}Fo(t.normal)}();const e=Fc.newInstance();let a=t.firstPoint;for(let r=0;r<t.pointCount;r++){const t=n(a);t>0&&e.push(t,a),a=a.next}for(;t.pointCount>2&&e.length()>0;)if(t.pointCount===e.length())o(e.pop(),e);else{const t=e.pop();r(t)&&o(t,e)}return t.pointCount<=2}():null,e.setPoints=e=>{t.pointCount=e.length,t.firstPoint={id:0,point:e[0],next:null,previous:null};let n=t.firstPoint;for(let r=1;r<t.pointCount;r++)n.next={id:r,point:e[r],next:null,previous:n},n=n.next;t.firstPoint.previous=n,n.next=t.firstPoint},e.getPointArray=()=>t.tris}const Hc={firstPoint:null,pointCount:0,tris:[]};function jc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Hc,n),Wt.obj(e,t),Wc(e,t)}var Kc={newInstance:Wt.newInstance(jc,&quot;vtkPolygon&quot;),extend:jc,...zc};function $c(e,t,n,r){const o=n[0]-t[0],a=n[1]-t[1],i=n[2]-t[2],s=e[0]-t[0],l=e[1]-t[1],c=e[2]-t[2];r[0]=a*c-i*l,r[1]=i*s-o*c,r[2]=o*l-a*s}function qc(e,t,n,r){$c(e,t,n,r);const o=Math.sqrt(r[0]*r[0]+r[1]*r[1]+r[2]*r[2]);0!==o&&(r[0]/=o,r[1]/=o,r[2]/=o)}function Xc(e){e[0]=-1,e[1]=1,e[2]=0,e[3]=-1,e[4]=0,e[5]=1}const Yc={computeNormalDirection:$c,computeNormal:qc,interpolationDerivs:Xc,intersectWithTriangle:function(e,t,n,r,o,a){let i=arguments.length>6&&void 0!==arguments[6]?arguments[6]:1e-6,s=!1;const l=[],c=[],u=[],d=[],p=[];qc(e,t,n,d),qc(r,o,a,p);const f=-Lo(d,e),g=-Lo(p,r),m=[Lo(p,e)+g,Lo(p,t)+g,Lo(p,n)+g];if(m[0]*m[1]>i&&m[0]*m[2]>i)return{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};const h=[Lo(d,r)+f,Lo(d,o)+f,Lo(d,a)+f];if(h[0]*h[1]>i&&h[0]*h[2]>i)return{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};if(Math.abs(d[0]-p[0])<1e-9&&Math.abs(d[1]-p[1])<1e-9&&Math.abs(d[2]-p[2])<1e-9&&Math.abs(f-g)<1e-9)return s=!0,{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};const v=[e,t,n],T=[r,o,a],y=Lo(d,p),b=(f-g*y)/(y*y-1),x=(g-f*y)/(y*y-1),C=[b*d[0]+x*p[0],b*d[1]+x*p[1],b*d[2]+x*p[2]],S=Bo(d,p,[]);Fo(S);let A=0,I=0;const w=[],O=[];let P,R,M=50,E=50;for(let t=0;t<3;t++){const n=t,o=(t+1)%3,a=ei.intersectWithLine(v[n],v[o],r,p);a.intersection&&a.t>0-i&&a.t<1+i&&(a.t<1+i&&a.t>1-i&&(M=A),w[A++]=Lo(a.x,S)-Lo(C,S));const s=ei.intersectWithLine(T[n],T[o],e,d);s.intersection&&s.t>0-i&&s.t<1+i&&(s.t<1+i&&s.t>1-i&&(E=I),O[I++]=Lo(s.x,S)-Lo(C,S))}if(A>2){A--;const e=w[2];w[2]=w[M],w[M]=e}if(I>2){I--;const e=O[2];O[2]=O[E],O[E]=e}if(2!==A||2!==I)return{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};if(Number.isNaN(w[0])||Number.isNaN(w[1])||Number.isNaN(O[0])||Number.isNaN(O[1]))return{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u};if(w[0]>w[1]){const e=w[1];w[1]=w[0],w[0]=e}if(O[0]>O[1]){const e=O[1];O[1]=O[0],O[0]=e}return w[1]<O[0]||O[1]<w[0]?{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u}:(w[0]<O[0]?w[1]<O[1]?(u[0]=2,u[1]=1,P=O[0],R=w[1]):(u[0]=2,u[1]=2,P=O[0],R=O[1]):w[1]<O[1]?(u[0]=1,u[1]=1,P=w[0],R=w[1]):(u[0]=1,u[1]=2,P=w[0],R=O[1]),Do(C,S,P,l),Do(C,S,R,c),{intersect:!0,coplanar:s,pt1:l,pt2:c,surfaceId:u})}},Zc={};function Qc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Zc,n),Jl.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkTriangle&quot;),e.getCellDimension=()=>2,e.intersectWithLine=(n,r,o,a,i)=>{const s={subId:0,t:Number.MAX_VALUE,intersect:0,betweenPoints:!1};i[2]=0;const l=[],c=o*o,u=[],d=[],p=[];t.points.getPoint(0,u),t.points.getPoint(1,d),t.points.getPoint(2,p);const f=[],g=[];if(qc(u,d,p,f),0!==f[0]||0!==f[1]||0!==f[2]){const t=ei.intersectWithLine(n,r,u,f);if(s.betweenPoints=t.betweenPoints,s.t=t.t,a[0]=t.x[0],a[1]=t.x[1],a[2]=t.x[2],!t.intersection)return i[0]=0,i[1]=0,s.intersect=0,s;const o=e.evaluatePosition(a,l,i,g);if(o.evaluation>=0)return o.dist2<=c?(s.intersect=1,s):(s.intersect=o.evaluation,s)}const m=Go(u,d),h=Go(d,p),v=Go(p,u);t.line||(t.line=Pc.newInstance()),m>h&&m>v?(t.line.getPoints().setPoint(0,u),t.line.getPoints().setPoint(1,d)):h>v&&h>m?(t.line.getPoints().setPoint(0,d),t.line.getPoints().setPoint(1,p)):(t.line.getPoints().setPoint(0,p),t.line.getPoints().setPoint(1,u));const T=t.line.intersectWithLine(n,r,o,a,i);if(s.betweenPoints=T.betweenPoints,s.t=T.t,T.intersect){const e=[],t=[],n=[];for(let r=0;r<3;r++)e[r]=u[r]-p[r],t[r]=d[r]-p[r],n[r]=a[r]-p[r];return i[0]=Lo(n,e)/v,i[1]=Lo(n,t)/h,s.intersect=1,s}return i[0]=0,i[1]=0,s.intersect=0,s},e.evaluatePosition=(e,n,r,o)=>{const a={subId:0,dist2:0,evaluation:-1};let i,s;const l=[],c=[],u=[],d=[];let p;const f=[],g=[],m=[];let h=0,v=0;const T=[];let y,b,x,C=[];const S=[],A=[],I=[];a.subId=0,r[2]=0,t.points.getPoint(1,l),t.points.getPoint(2,c),t.points.getPoint(0,u),$c(l,c,u,d),ei.generalizedProjectPoint(e,l,d,I);let w=0;for(i=0;i<3;i++)p=d[i]<0?-d[i]:d[i],p>w&&(w=p,v=i);for(s=0,i=0;i<3;i++)i!==v&&(T[s++]=i);for(i=0;i<2;i++)f[i]=I[T[i]]-u[T[i]],g[i]=l[T[i]]-u[T[i]],m[i]=c[T[i]]-u[T[i]];if(h=Wo(g,m),0===h)return r[0]=0,r[1]=0,a.evaluation=-1,a;if(r[0]=Wo(f,m)/h,r[1]=Wo(g,f)/h,o[0]=1-(r[0]+r[1]),o[1]=r[0],o[2]=r[1],o[0]>=0&&o[0]<=1&&o[1]>=0&&o[1]<=1&&o[2]>=0&&o[2]<=1)n&&(a.dist2=Go(I,e),n[0]=I[0],n[1]=I[1],n[2]=I[2]),a.evaluation=1;else{let t;if(n)if(o[1]<0&&o[2]<0)for(y=Go(e,u),b=Pc.distanceToLine(e,l,u,t,S),x=Pc.distanceToLine(e,u,c,t,A),y<b?(a.dist2=y,C=u):(a.dist2=b,C=S),x<a.dist2&&(a.dist2=x,C=A),i=0;i<3;i++)n[i]=C[i];else if(o[2]<0&&o[0]<0)for(y=Go(e,l),b=Pc.distanceToLine(e,l,u,t,S),x=Pc.distanceToLine(e,l,c,t,A),y<b?(a.dist2=y,C=l):(a.dist2=b,C=S),x<a.dist2&&(a.dist2=x,C=A),i=0;i<3;i++)n[i]=C[i];else if(o[1]<0&&o[0]<0)for(y=Go(e,c),b=Pc.distanceToLine(e,c,u,t,S),x=Pc.distanceToLine(e,l,c,t,A),y<b?(a.dist2=y,C=c):(a.dist2=b,C=S),x<a.dist2&&(a.dist2=x,C=A),i=0;i<3;i++)n[i]=C[i];else if(o[0]<0){const t=Pc.distanceToLine(e,l,c,n);a.dist2=t.distance}else if(o[1]<0){const t=Pc.distanceToLine(e,c,u,n);a.dist2=t.distance}else if(o[2]<0){const t=Pc.distanceToLine(e,l,u,n);a.dist2=t.distance}a.evaluation=0}return a},e.evaluateLocation=(e,n,r)=>{const o=[],a=[],i=[];t.points.getPoint(0,o),t.points.getPoint(1,a),t.points.getPoint(2,i);const s=1-e[0]-e[1];for(let t=0;t<3;t++)n[t]=o[t]*s+a[t]*e[0]+i[t]*e[1];r[0]=s,r[1]=e[0],r[2]=e[1]},e.getParametricDistance=e=>{let t,n=0;const r=[];r[0]=e[0],r[1]=e[1],r[2]=1-e[0]-e[1];for(let e=0;e<3;e++)t=r[e]<0?-r[e]:r[e]>1?r[e]-1:0,t>n&&(n=t);return n},e.derivatives=(e,n,r,o,a)=>{const i=t.points.getPoint(0),s=t.points.getPoint(1),l=t.points.getPoint(2),c=[],u=[],d=[],p=[];qc(i,s,l,c),Mo(s,i,u),Mo(l,i,p),Bo(c,u,d);const f=Fo(u);if(f<=0||Fo(d)<=0){for(let e=0;e<o;e++)for(let t=0;t<3;t++)a[e*o+t]=0;return}const g=[0,0],m=[f,0],h=[Lo(p,u),Lo(p,d)],v=new Array(6);Xc(v);const T=[m[0]-g[0],m[1]-g[1],h[0]-g[0],h[1]-g[1]],y=Wt.newTypedArray(ot.Float64Array,4);la(T,y,2);for(let e=0;e<o;e++){let t=0,n=0;for(let a=0;a<3;a++)t+=v[a]*r[o*a+e],n+=v[3+a]*r[o*a+e];const i=t*y[0]+n*y[1],s=t*y[2]+n*y[3];a[3*e]=i*u[0]+s*d[0],a[3*e+1]=i*u[1]+s*d[1],a[3*e+2]=i*u[2]+s*d[2]}},e.cellBoundary=(e,n,r)=>{const o=n[0]-n[1],a=.5*(1-n[0])-n[1],i=2*n[0]+n[1]-1;return o>=0&&a>=0?(r[0]=t.pointsIds[0],r[1]=t.pointsIds[1]):a<0&&i>=0?(r[0]=t.pointsIds[1],r[1]=t.pointsIds[2]):(r[0]=t.pointsIds[2],r[1]=t.pointsIds[0]),!(n[0]<0||n[1]<0||n[0]>1||n[1]>1||1-n[0]-n[1]<0)}}(e,t)}var Jc={newInstance:Wt.newInstance(Qc,&quot;vtkTriangle&quot;),extend:Qc,...Yc};const eu={};function tu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,eu,n),Jl.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkQuad&quot;),e.getCellDimension=()=>2,e.getCellType=()=>dc,e.getNumberOfEdges=()=>4,e.getNumberOfFaces=()=>0,e.intersectWithLine=(e,n,r,o,a)=>{let i,s={subId:0,t:Number.MAX_VALUE,intersect:0,betweenPoints:!1};const l=t.points.getPoint(0,[]),c=t.points.getPoint(1,[]),u=t.points.getPoint(2,[]),d=t.points.getPoint(3,[]),p=Go(l,u),f=Go(c,d);if(p===f){let e,n=0,r=0;for(let o=0;o<4;o++)e=t.pointsIds[o],e>n&&(n=e,r=o);i=0===r||2===r?0:1}else i=p<f?0:1;let g,m=null;t.triangle?m=t.triangle.getPoints():(t.triangle=Jc.newInstance(),m=Yl.newInstance(),m.setNumberOfPoints(3),t.triangle.initialize(m));const h=[0,0,0],v=[0,0,0];let T;const y=[0,0,0],b=[0,0,0];let x,C;switch(i){case 0:m.setPoint(0,...l),m.setPoint(1,...c),m.setPoint(2,...u),g=t.triangle.intersectWithLine(e,n,r,h,v),m.setPoint(0,...u),m.setPoint(1,...d),m.setPoint(2,...l),T=t.triangle.intersectWithLine(e,n,r,y,b),x=g.intersect&&T.intersect?g.t<=T.t:g.intersect,C=g.intersect&&T.intersect?T.t<g.t:T.intersect,x?(s=g,o[0]=h[0],o[1]=h[1],o[2]=h[2],a[0]=v[0]+v[1],a[1]=v[1],a[2]=v[2]):C&&(s=T,o[0]=y[0],o[1]=y[1],o[2]=y[2],a[0]=1-(b[0]+b[1]),a[1]=1-b[1],a[2]=b[2]);break;case 1:m.setPoint(0,...l),m.setPoint(1,...c),m.setPoint(2,...d),g=t.triangle.intersectWithLine(e,n,r,h,v),m.setPoint(0,...u),m.setPoint(1,...d),m.setPoint(2,...c),T=t.triangle.intersectWithLine(e,n,r,y,b),x=g.intersect&&T.intersect?g.t<=T.t:g.intersect,C=g.intersect&&T.intersect?T.t<g.t:T.intersect,x?(s=g,o[0]=h[0],o[1]=h[1],o[2]=h[2],a[0]=v[0],a[1]=v[1],a[2]=v[2]):C&&(s=T,o[0]=y[0],o[1]=y[1],o[2]=y[2],a[0]=1-b[0],a[1]=1-b[1],a[2]=b[2])}return s},e.interpolationFunctions=(e,t)=>{const n=1-e[0],r=1-e[1];t[0]=n*r,t[1]=e[0]*r,t[2]=e[0]*e[1],t[3]=n*e[1]},e.evaluateLocation=(n,r,o)=>{const a=[];e.interpolationFunctions(n,o),r[0]=0,r[1]=0,r[2]=0;for(let e=0;e<4;e++){t.points.getPoint(e,a);for(let t=0;t<3;t++)r[t]+=a[t]*o[e]}}}(e,t)}var nu={newInstance:Wt.newInstance(tu,&quot;vtkQuad&quot;),extend:tu};const{vtkErrorMacro:ru}=Wt;function ou(e){return()=>ru(`vtkTriangleStrip.${e} - NOT IMPLEMENTED`)}const au={decomposeStrip:function(e,t){if(!Array.isArray(e)||e.length<3)return void ru(&quot;decomposeStrip - Invalid points array&quot;);let n=e[0],r=e[1];for(let o=0;o<e.length-2;o++){const a=e[o+2];o%2?t.insertNextCell([r,n,a]):t.insertNextCell([n,r,a]),n=r,r=a}}},iu={line:null,triangle:null,tris:null};function su(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,iu,n),Jl.extend(e,t,n),t.line||(t.line=Pc.newInstance()),t.triangle||(t.triangle=Jc.newInstance()),function(e,t){t.classHierarchy.push(&quot;vtkTriangleStrip&quot;);const n=e.initialize;e.initialize=(e,r)=>{t.triangle.initialize(e,r),n(e,r)},e.getCellType=()=>cc,e.getCellDimension=()=>2,e.getNumberOfEdges=()=>t.pointsIds.length,e.getNumberOfFaces=()=>0,e.evaluatePosition=(e,n,r,o,a)=>{const i=[0,0,0];let s=Number.MAX_VALUE,l=0;const c=[],u=[],d=[];r[2]=0,u[0]=0,u[1]=0,u[2]=0;const p=t.triangle.getPoints();p.setNumberOfPoints(3);const f=t.triangle.getPointsIds().length;for(let e=0;e<f;e++)a[e]=0;for(let o=0;o<f-2;o++){const a=[];p.getPoint(o,a);const f=[];p.getPoint(o+1,f);const g=[];p.getPoint(o+2,g),p.setData(Float32Array.from([...a,...f,...g]),3);const m=t.triangle.evaluatePosition(e,d,i,c),h=m.dist2;m.evaluation>=0&&(h<s||h===s&&0===l)&&(l=m,n&&(n[0]=d[0],n[1]=d[1],n[2]=d[2]),r[0]=i[0],r[1]=i[1],s=h,u[0]=c[0],u[1]=c[1],u[2]=c[2])}return o[0]=s,a[0]=u[0],a[1]=u[1],a[2]=u[2],l},e.evaluateLocation=(e,n,r,o)=>{const a=[[0,1,2],[1,0,2]],i=e%2,s=t.pointsIds.length;for(let e=0;e<s;e++)o[e]=0;const l=1-n[0]-n[1];o[e]=l,o[e+1]=n[0],o[e+2]=n[1];const c=[];t.points.getPoint(e+a[i][0],c);const u=[];t.points.getPoint(e+a[i][1],u);const d=[];t.points.getPoint(e+a[i][2],d);for(let t=0;t<3;t++)r[t]=c[t]*o[e]+u[t]*o[e+1]+d[t]*o[e+2]},e.cellBoundary=(e,n,r)=>{const o=[[0,1,2],[1,0,2]],a=e%2,i=t.triangle.getPointsIds();return i[0]=t.pointsIds[o[a][0]],i[1]=t.pointsIds[o[a][1]],i[2]=t.pointsIds[o[a][2]],t.triangle.cellBoundary(0,n,r)},e.getEdge=e=>{let n,r;const o=t.pointsIds.length;return 0===e?(n=0,r=1):e===o-1?(n=e-1,r=e):(n=e-1,r=e+1),t.line.getPointsIds()[0]=t.pointsIds[n],t.line.getPointsIds()[1]=t.pointsIds[r],t.line.getPoints().setPoint(0,t.points.getPoint(n)),t.line.getPoints().setPoint(1,t.points.getPoint(r)),t.line},e.intersectWithLine=(e,n,r,o,a)=>{const i=t.pointsIds.length-2,s=t.triangle.getPoints();s.setNumberOfPoints(3);for(let l=0;l<i;l++){const i=[];t.points.getPoint(t.pointsIds[l],i);const c=[];t.points.getPoint(t.pointsIds[l+1],c);const u=[];t.points.getPoint(t.pointsIds[l+2],u),s.setData(Float32Array.from([...i,...c,...u]),3);const d=t.triangle.intersectWithLine(e,n,r,o,a);if(d.intersect)return d}return!1},e.triangulate=()=>{const e=t.points.getNumberOfPoints()-2;t.tris=new Array(3*e);const n=[[0,1,2],[1,0,2]];for(let r=0;r<e;r++){const e=r%2;for(let o=0;o<3;o++)t.tris[3*r+o]=r+n[e][o]}return!0},e.getPointArray=()=>t.tris,e.derivatives=(e,n,r,o,a)=>{const i=[];t.points.getPoint(e,i);const s=[];t.points.getPoint(e+1,s);const l=[];t.points.getPoint(e+2,l);const c=t.triangle.getPoints();c.setPoint(0,...i),c.setPoint(1,...s),c.setPoint(2,...l),t.triangle.derivatives(0,n,r,o,a)},e.getParametricCenter=e=>(e[0]=.333333,e[1]=.333333,e[2]=0,Math.floor((t.pointsIds.length-2)/2)),e.contour=(e,t,n,r,o,a,i,s,l,c,u)=>ou(&quot;contour&quot;)(),e.clip=(e,t,n,r,o,a,i,s,l,c)=>ou(&quot;clip&quot;)()}(e,t)}var lu={newInstance:Wt.newInstance(su,&quot;vtkTriangleStrip&quot;),extend:su,...au};const cu=[&quot;verts&quot;,&quot;lines&quot;,&quot;polys&quot;,&quot;strips&quot;],{vtkWarningMacro:uu}=Wt,du={[ic]:Pc,[dc]:nu,[sc]:Pc,[lc]:Jc,[cc]:lu,[sc]:Lc,[uc]:Kc},pu={};function fu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,pu,n),Ec.extend(e,t,n),Wt.get(e,t,[&quot;cells&quot;,&quot;links&quot;]),Wt.setGet(e,t,[&quot;verts&quot;,&quot;lines&quot;,&quot;polys&quot;,&quot;strips&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkPolyData&quot;),cu.forEach((n=>{e[`getNumberOf${function(e){return e.replace(/(?:^\\w|[A-Z]|\\b\\w)/g,(e=>e.toUpperCase())).replace(/\\s+/g,&quot;&quot;)}(n)}`]=()=>t[n].getNumberOfCells(),t[n]?t[n]=ze(t[n]):t[n]=Kl.newInstance()})),e.getNumberOfCells=()=>cu.reduce(((e,n)=>e+t[n].getNumberOfCells()),0);const n=e.shallowCopy;e.shallowCopy=function(e){n(e,arguments.length>1&&void 0!==arguments[1]&&arguments[1]),cu.forEach((n=>{t[n]=Kl.newInstance(),t[n].shallowCopy(e.getReferenceByName(n))}))};const r=e.getMTime;e.getMTime=()=>cu.reduce(((e,n)=>Math.max(e,t[n]?.getMTime()??e)),r());const o=e.initialize;e.initialize=()=>(cu.forEach((e=>t[e]?.initialize())),o()),e.buildCells=()=>{const n=e.getNumberOfVerts(),r=e.getNumberOfLines(),o=e.getNumberOfPolys(),a=e.getNumberOfStrips(),i=n+r+o+a,s=new Uint8Array(i);let l=s;const c=new Uint32Array(i);let u=c;if(n){let e=0;t.verts.getCellSizes().forEach(((t,n)=>{u[n]=e,l[n]=t>1?ac:oc,e+=t+1})),u=u.subarray(n),l=l.subarray(n)}if(r){let e=0;t.lines.getCellSizes().forEach(((t,n)=>{u[n]=e,l[n]=t>2?sc:ic,1===t&&uu(&quot;Building VTK_LINE &quot;,n,&quot; with only one point, but VTK_LINE needs at least two points. Check the input.&quot;),e+=t+1})),u=u.subarray(r),l=l.subarray(r)}if(o){let e=0;t.polys.getCellSizes().forEach(((t,n)=>{switch(u[n]=e,t){case 3:l[n]=lc;break;case 4:l[n]=dc;break;default:l[n]=uc}t<3&&uu(&quot;Building VTK_TRIANGLE &quot;,n,&quot; with less than three points, but VTK_TRIANGLE needs at least three points. Check the input.&quot;),e+=t+1})),u+=u.subarray(o),l+=l.subarray(o)}if(a){let e=0;l.fill(cc,0,a),t.strips.getCellSizes().forEach(((t,n)=>{u[n]=e,e+=t+1}))}t.cells=yc.newInstance(),t.cells.setCellTypes(i,s,c)},e.buildLinks=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;void 0===t.cells&&e.buildCells(),t.links=nc.newInstance(),n>0?t.links.allocate(n):t.links.allocate(e.getPoints().getNumberOfPoints()),t.links.buildLinks(e)},e.getCellType=e=>t.cells.getCellType(e),e.getCellPoints=n=>{const r=e.getCellType(n);let o=null;switch(r){case oc:case ac:o=t.verts;break;case ic:case sc:o=t.lines;break;case lc:case dc:case uc:o=t.polys;break;case cc:o=t.strips;break;default:return o=null,{type:0,cellPointIds:null}}const a=t.cells.getCellLocation(n);return{cellType:r,cellPointIds:o.getCell(a)}},e.getPointCells=e=>t.links.getCells(e),e.getCellEdgeNeighbors=(e,n,r)=>{const o=t.links.getLink(n),a=t.links.getLink(r);return o.cells.filter((t=>t!==e&&-1!==a.cells.indexOf(t)))},e.getCell=function(t){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;const r=e.getCellPoints(t),o=n||du[r.cellType].newInstance();return o.initialize(e.getPoints(),r.cellPointIds),o},e.getMaxCellSize=()=>cu.reduce(((e,n)=>Math.max(e,t[n]?.getMaxCellSize?.()??0)),0)}(e,t)}var gu={newInstance:Wt.newInstance(fu,&quot;vtkPolyData&quot;),extend:fu};const mu={image:null,canvas:null,jsImageData:null,imageBitmap:null,imageLoaded:!1,repeat:!1,interpolate:!1,edgeClamp:!1,mipLevel:0,resizable:!1};function hu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,mu,n),Wt.obj(e,t),Wt.algo(e,t,6,0),Wt.get(e,t,[&quot;canvas&quot;,&quot;image&quot;,&quot;jsImageData&quot;,&quot;imageBitmap&quot;,&quot;imageLoaded&quot;,&quot;resizable&quot;]),Wt.setGet(e,t,[&quot;repeat&quot;,&quot;edgeClamp&quot;,&quot;interpolate&quot;,&quot;mipLevel&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkTexture&quot;),e.imageLoaded=()=>{t.image.removeEventListener(&quot;load&quot;,e.imageLoaded),t.imageLoaded=!0,e.modified()},e.setJsImageData=n=>{t.jsImageData!==n&&(null!==n&&(e.setInputData(null),e.setInputConnection(null),t.image=null,t.canvas=null,t.imageBitmap=null),t.jsImageData=n,t.imageLoaded=!0,e.modified())},e.setImageBitmap=n=>{t.imageBitmap!==n&&(null!==n&&(e.setInputData(null),e.setInputConnection(null),t.image=null,t.canvas=null,t.jsImageData=null),t.imageBitmap=n,t.imageLoaded=!0,e.modified())},e.setCanvas=n=>{t.canvas!==n&&(null!==n&&(e.setInputData(null),e.setInputConnection(null),t.image=null,t.imageBitmap=null,t.jsImageData=null),t.canvas=n,e.modified())},e.setImage=n=>{t.image!==n&&(null!==n&&(e.setInputData(null),e.setInputConnection(null),t.canvas=null,t.jsImageData=null,t.imageBitmap=null),t.image=n,t.imageLoaded=!1,n.complete?e.imageLoaded():n.addEventListener(&quot;load&quot;,e.imageLoaded),e.modified())},e.getDimensionality=()=>{let n=0,r=0,o=1;if(e.getInputData()){const t=e.getInputData();n=t.getDimensions()[0],r=t.getDimensions()[1],o=t.getDimensions()[2]}return t.jsImageData&&(n=t.jsImageData.width,r=t.jsImageData.height),t.canvas&&(n=t.canvas.width,r=t.canvas.height),t.image&&(n=t.image.width,r=t.image.height),t.imageBitmap&&(n=t.imageBitmap.width,r=t.imageBitmap.height),(n>1)+(r>1)+(o>1)},e.getInputAsJsImageData=()=>{if(!t.imageLoaded||e.getInputData())return null;if(t.jsImageData)return t.jsImageData;if(t.imageBitmap)return t.imageBitmap;if(t.canvas)return t.canvas.getContext(&quot;2d&quot;).getImageData(0,0,t.canvas.width,t.canvas.height);if(t.image){const e=t.image.width,n=t.image.height,r=new OffscreenCanvas(e,n).getContext(&quot;2d&quot;);return r.translate(0,n),r.scale(1,-1),r.drawImage(t.image,0,0,e,n),r.getImageData(0,0,e,n)}return null}}(e,t)}var vu={newInstance:Wt.newInstance(hu,&quot;vtkTexture&quot;),extend:hu,generateMipmaps:(e,t,n)=>{const r=e.createShaderModule({code:&quot;\\n    @group(0) @binding(0) var inputTexture: texture_2d<f32>;\\n    @group(0) @binding(1) var outputTexture: texture_storage_2d<rgba8unorm, write>;\\n\\n    @compute @workgroup_size(8, 8)\\n    fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {\\n      let texelCoord = vec2<i32>(global_id.xy);\\n      let outputSize = textureDimensions(outputTexture);\\n\\n      if (texelCoord.x >= i32(outputSize.x) || texelCoord.y >= i32(outputSize.y)) {\\n        return;\\n      }\\n\\n      let inputSize = textureDimensions(inputTexture);\\n      let scale = vec2<f32>(inputSize) / vec2<f32>(outputSize);\\n\\n      // Compute the floating-point source coordinate\\n      let srcCoord = (vec2<f32>(texelCoord) + 0.5) * scale - 0.5;\\n\\n      // Get integer coordinates for the four surrounding texels\\n      let x0 = i32(floor(srcCoord.x));\\n      let x1 = min(x0 + 1, i32(inputSize.x) - 1);\\n      let y0 = i32(floor(srcCoord.y));\\n      let y1 = min(y0 + 1, i32(inputSize.y) - 1);\\n\\n      // Compute the weights\\n      let wx = srcCoord.x - f32(x0);\\n      let wy = srcCoord.y - f32(y0);\\n\\n      // Fetch the four texels\\n      let c00 = textureLoad(inputTexture, vec2<i32>(x0, y0), 0);\\n      let c10 = textureLoad(inputTexture, vec2<i32>(x1, y0), 0);\\n      let c01 = textureLoad(inputTexture, vec2<i32>(x0, y1), 0);\\n      let c11 = textureLoad(inputTexture, vec2<i32>(x1, y1), 0);\\n\\n      // Bilinear interpolation\\n      let color = mix(\\n        mix(c00, c10, wx),\\n        mix(c01, c11, wx),\\n        wy\\n      );\\n\\n      textureStore(outputTexture, texelCoord, color);\\n    }\\n  &quot;}),o=e.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.COMPUTE,texture:{sampleType:&quot;float&quot;}},{binding:1,visibility:GPUShaderStage.COMPUTE,storageTexture:{format:&quot;rgba8unorm&quot;,access:&quot;write-only&quot;}},{binding:2,visibility:GPUShaderStage.COMPUTE,sampler:{type:&quot;filtering&quot;}}]}),a=e.createPipelineLayout({bindGroupLayouts:[o]}),i=e.createComputePipeline({label:&quot;ComputeMipmapPipeline&quot;,layout:a,compute:{module:r,entryPoint:&quot;main&quot;}}),s=e.createSampler({magFilter:&quot;linear&quot;,minFilter:&quot;linear&quot;});for(let r=1;r<n;r++){const n=t.createView({baseMipLevel:r-1,mipLevelCount:1}),o=t.createView({baseMipLevel:r,mipLevelCount:1}),a=e.createBindGroup({layout:i.getBindGroupLayout(0),entries:[{binding:0,resource:n},{binding:1,resource:o},{binding:2,resource:s}]}),l=e.createCommandEncoder({label:&quot;MipmapGenerateCommandEncoder&quot;}),c=l.beginComputePass();c.setPipeline(i),c.setBindGroup(0,a);const u=Math.max(1,t.width>>r),d=Math.max(1,t.height>>r),p=Math.ceil(u/8),f=Math.ceil(d/8);c.dispatchWorkgroups(p,f),c.end(),e.queue.submit([l.finish()])}}};const Tu=[[-1,0,0],[1,0,0],[0,-1,0],[0,1,0],[0,0,-1],[0,0,1]],yu=[[8,7,11,3],[9,1,10,5],[4,9,0,8],[2,11,6,10],[0,3,2,1],[4,5,6,7]],bu=[[0,1],[1,3],[2,3],[0,2],[4,5],[5,7],[6,7],[4,6],[0,4],[1,5],[3,7],[2,6]],xu=[0,1,0,1,0,1,0,1,2,2,2,2],Cu=[[1,2],[1,2],[0,2],[0,2],[0,1],[0,1]],Su=new Float64Array(3),Au=new Float64Array(3),Iu=new Float64Array(3),wu=new Float64Array(3),Ou=new Float64Array(3),Pu=new Float64Array(3),Ru=new Float64Array(16);function Mu(e,t){e.strokeStyle=t.strokeColor,e.lineWidth=t.strokeSize,e.fillStyle=t.fontColor,e.font=`${t.fontStyle} ${t.fontSize}px ${t.fontFamily}`}function Eu(e){const t=[],n=[];for(let r=0;r<3;r++){const o=ro().domain([e[2*r],e[2*r+1]]);t[r]=o.ticks(5);const a=o.tickFormat(5);n[r]=t[r].map(a)}return{ticks:t,tickStrings:n}}const Vu=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{renderable:null};Object.assign(t,{},n),Wt.obj(e,t),t.tmPolyData=gu.newInstance(),t.tmMapper=Gl.newInstance(),t.tmMapper.setInputData(t.tmPolyData),t.tmActor=ss.newInstance({parentProp:e}),t.tmActor.setMapper(t.tmMapper),Wt.setGet(e,t,[&quot;renderable&quot;]),Wt.get(e,t,[&quot;lastSize&quot;,&quot;lastAspectRatio&quot;,&quot;axisTextStyle&quot;,&quot;tickTextStyle&quot;,&quot;tmActor&quot;,&quot;ticks&quot;]),t.forceUpdate=!1,t.lastRedrawTime={},Wt.obj(t.lastRedrawTime,{mtime:0}),t.lastRebuildTime={},Wt.obj(t.lastRebuildTime,{mtime:0}),t.lastSize=[-1,-1],t.lastTickBounds=[],function(e,t){t.classHierarchy.push(&quot;vtkCubeAxesActorHelper&quot;),e.setRenderable=n=>{t.renderable!==n&&(t.renderable=n,t.tmActor.addTexture(t.renderable.getTmTexture()),t.tmActor.setProperty(n.getProperty()),t.tmActor.setParentProp(n),e.modified())},e.createPolyDataForOneLabel=(e,n,r,o,a,i,s)=>{const l=t.renderable.get_tmAtlas().get(e);if(!l)return;const c=t.renderable.getTextPolyData().getPoints().getData(),u=t.lastSize;Su[0]=c[3*n],Su[1]=c[3*n+1],Su[2]=c[3*n+2],In(Iu,Su,r),Iu[0]+=.1,In(Au,Iu,o),Tn(Ou,Au,Su),Iu[0]-=.1,Iu[1]+=.1,In(Au,Iu,o),Tn(Pu,Au,Su);for(let e=0;e<3;e++)Ou[e]/=.05*u[0],Pu[e]/=.05*u[1];let d=s.ptIdx,p=s.cellIdx;Su[0]=c[3*n],Su[1]=c[3*n+1],Su[2]=c[3*n+2],a[0]<-.5?bn(Iu,Ou,a[0]*i-l.width):a[0]>.5?bn(Iu,Ou,a[0]*i):bn(Iu,Ou,a[0]*i-l.width/2),vn(Su,Su,Iu),bn(Iu,Pu,a[1]*i-l.height/2),vn(Su,Su,Iu),s.points[3*d]=Su[0],s.points[3*d+1]=Su[1],s.points[3*d+2]=Su[2],s.tcoords[2*d]=l.tcoords[0],s.tcoords[2*d+1]=l.tcoords[1],d++,bn(Iu,Ou,l.width),vn(Su,Su,Iu),s.points[3*d]=Su[0],s.points[3*d+1]=Su[1],s.points[3*d+2]=Su[2],s.tcoords[2*d]=l.tcoords[2],s.tcoords[2*d+1]=l.tcoords[3],d++,bn(Iu,Pu,l.height),vn(Su,Su,Iu),s.points[3*d]=Su[0],s.points[3*d+1]=Su[1],s.points[3*d+2]=Su[2],s.tcoords[2*d]=l.tcoords[4],s.tcoords[2*d+1]=l.tcoords[5],d++,bn(Iu,Ou,l.width),Tn(Su,Su,Iu),s.points[3*d]=Su[0],s.points[3*d+1]=Su[1],s.points[3*d+2]=Su[2],s.tcoords[2*d]=l.tcoords[6],s.tcoords[2*d+1]=l.tcoords[7],d++,s.polys[4*p]=3,s.polys[4*p+1]=d-4,s.polys[4*p+2]=d-3,s.polys[4*p+3]=d-2,p++,s.polys[4*p]=3,s.polys[4*p+1]=d-4,s.polys[4*p+2]=d-2,s.polys[4*p+3]=d-1,s.ptIdx+=4,s.cellIdx+=2},e.updateTexturePolyData=()=>{const n=t.camera.getCompositeProjectionMatrix(t.lastAspectRatio,-1,1);h(n,n);const r=t.renderable.getTextValues().length,o=4*r,a=2*r,i=new Float64Array(3*o),s=new Uint16Array(4*a),l=new Float32Array(2*o);v(Ru,n);const c={ptIdx:0,cellIdx:0,polys:s,points:i,tcoords:l};let u=0,d=0,p=0;const f=t.renderable.getTextPolyData().getPoints().getData(),g=t.renderable.getTextValues();for(;u<f.length/3;){Su[0]=f[3*u],Su[1]=f[3*u+1],Su[2]=f[3*u+2],In(Iu,Su,n),Su[0]=f[3*u+3],Su[1]=f[3*u+4],Su[2]=f[3*u+5],In(wu,Su,n),Tn(Iu,Iu,wu);const r=[Iu[0],Iu[1]];zo(r),e.createPolyDataForOneLabel(g[d],u,n,Ru,r,t.renderable.getAxisTitlePixelOffset(),c),u+=2,d++;for(let o=0;o<t.renderable.getTickCounts()[p];o++)e.createPolyDataForOneLabel(g[d],u,n,Ru,r,t.renderable.getTickLabelPixelOffset(),c),u++,d++;p++}const m=xs.newInstance({numberOfComponents:2,values:l,name:&quot;TextureCoordinates&quot;});t.tmPolyData.getPointData().setTCoords(m),t.tmPolyData.getPoints().setData(i,3),t.tmPolyData.getPoints().modified(),t.tmPolyData.getPolys().setData(s,1),t.tmPolyData.getPolys().modified(),t.tmPolyData.modified()},e.updateAPISpecificData=(n,r,o)=>{t.lastSize[0]===n[0]&&t.lastSize[1]===n[1]||(t.lastSize[0]=n[0],t.lastSize[1]=n[1],t.lastAspectRatio=n[0]/n[1],t.forceUpdate=!0),t.camera=r,e.updateTexturePolyData()}}(e,t)}),&quot;vtkCubeAxesActorHelper&quot;);function Du(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};ss.extend(e,t,function(e,t,n){return{boundsScaleFactor:1.3,camera:null,dataBounds:[...Gi.INIT_BOUNDS],faceVisibilityAngle:8,gridLines:!0,axisLabels:null,axisTitlePixelOffset:35,tickLabelPixelOffset:12,generateTicks:Eu,...n,axisTextStyle:{fontColor:&quot;white&quot;,fontStyle:&quot;normal&quot;,fontSize:18,fontFamily:&quot;serif&quot;,...n?.axisTextStyle},tickTextStyle:{fontColor:&quot;white&quot;,fontStyle:&quot;normal&quot;,fontSize:14,fontFamily:&quot;serif&quot;,...n?.tickTextStyle}}}(0,0,n)),t.lastFacesToDraw=[!1,!1,!1,!1,!1,!1],t.axisLabels=[&quot;X-Axis&quot;,&quot;Y-Axis&quot;,&quot;Z-Axis&quot;],t.tickCounts=[],t.textValues=[],t.lastTickBounds=[],t.tmCanvas=document.createElement(&quot;canvas&quot;),t.tmContext=t.tmCanvas.getContext(&quot;2d&quot;),t._tmAtlas=new Map,t.tmTexture=vu.newInstance({resizable:!0}),t.tmTexture.setInterpolate(!1),e.getProperty().setDiffuse(0),e.getProperty().setAmbient(1),t.gridMapper=Gl.newInstance(),t.polyData=gu.newInstance(),t.gridMapper.setInputData(t.polyData),t.gridActor=ss.newInstance(),t.gridActor.setMapper(t.gridMapper),t.gridActor.setProperty(e.getProperty()),t.gridActor.setParentProp(e),t.textPolyData=gu.newInstance(),Wt.setGet(e,t,[&quot;axisTitlePixelOffset&quot;,&quot;boundsScaleFactor&quot;,&quot;faceVisibilityAngle&quot;,&quot;gridLines&quot;,&quot;tickLabelPixelOffset&quot;,&quot;generateTicks&quot;]),Wt.setGetArray(e,t,[&quot;dataBounds&quot;],6),Wt.setGetArray(e,t,[&quot;axisLabels&quot;],3),Wt.get(e,t,[&quot;axisTextStyle&quot;,&quot;tickTextStyle&quot;,&quot;camera&quot;,&quot;tmTexture&quot;,&quot;textValues&quot;,&quot;textPolyData&quot;,&quot;tickCounts&quot;,&quot;gridActor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkCubeAxesActor&quot;),e.setCamera=n=>{t.camera!==n&&(t.cameraModifiedSub&&(t.cameraModifiedSub.unsubscribe(),t.cameraModifiedSub=null),t.camera=n,n&&(t.cameraModifiedSub=n.onModified(e.update)),e.update(),e.modified())},e.computeFacesToDraw=()=>{const e=t.camera.getViewMatrix();h(e,e);let n=!1;const r=Gi.getDiagonalLength(t.dataBounds),o=Math.sin(t.faceVisibilityAngle*Math.PI/180);for(let a=0;a<6;a++){let i=!1;const s=Math.floor(a/2),l=(s+1)%3,c=(s+2)%3;t.dataBounds[2*l]!==t.dataBounds[2*l+1]&&t.dataBounds[2*c]!==t.dataBounds[2*c+1]&&(Su[s]=t.dataBounds[a]-.1*r*Tu[a][s],Su[l]=.5*(t.dataBounds[2*l]+t.dataBounds[2*l+1]),Su[c]=.5*(t.dataBounds[2*c]+t.dataBounds[2*c+1]),In(Iu,Su,e),Su[s]=t.dataBounds[a],In(wu,Su,e),Tn(Iu,wu,Iu),Cn(Iu,Iu),i=Iu[2]>o,t.camera.getParallelProjection()||(Cn(wu,wu),i=Sn(wu,Iu)>o)),i!==t.lastFacesToDraw[a]&&(t.lastFacesToDraw[a]=i,n=!0)}return n},e.updatePolyData=(e,n,r)=>{let o=0,a=0;o+=8;let i=0;for(let e=0;e<12;e++)n[e]>0&&i++;if(a+=i,t.gridLines)for(let t=0;t<6;t++)e[t]&&(o+=2*r[Cu[t][0]].length+2*r[Cu[t][1]].length,a+=r[Cu[t][0]].length+r[Cu[t][1]].length);const s=new Float64Array(3*o),l=new Uint32Array(3*a);let c=0,u=0;for(let e=0;e<2;e++)for(let n=0;n<2;n++)for(let r=0;r<2;r++)s[3*c]=t.dataBounds[r],s[3*c+1]=t.dataBounds[2+n],s[3*c+2]=t.dataBounds[4+e],c++;for(let e=0;e<12;e++)n[e]>0&&(l[3*u]=2,l[3*u+1]=bu[e][0],l[3*u+2]=bu[e][1],u++);if(t.gridLines)for(let n=0;n<6;n++)if(e[n]){const e=Math.floor(n/2);let o=r[Cu[n][0]];for(let r=0;r<o.length;r++)s[3*c+e]=t.dataBounds[n],s[3*c+Cu[n][0]]=o[r],s[3*c+Cu[n][1]]=t.dataBounds[2*Cu[n][1]],c++,s[3*c+e]=t.dataBounds[n],s[3*c+Cu[n][0]]=o[r],s[3*c+Cu[n][1]]=t.dataBounds[2*Cu[n][1]+1],c++,l[3*u]=2,l[3*u+1]=c-2,l[3*u+2]=c-1,u++;o=r[Cu[n][1]];for(let r=0;r<o.length;r++)s[3*c+e]=t.dataBounds[n],s[3*c+Cu[n][1]]=o[r],s[3*c+Cu[n][0]]=t.dataBounds[2*Cu[n][0]],c++,s[3*c+e]=t.dataBounds[n],s[3*c+Cu[n][1]]=o[r],s[3*c+Cu[n][0]]=t.dataBounds[2*Cu[n][0]+1],c++,l[3*u]=2,l[3*u+1]=c-2,l[3*u+2]=c-1,u++}t.polyData.getPoints().setData(s,3),t.polyData.getPoints().modified(),t.polyData.getLines().setData(l,1),t.polyData.getLines().modified(),t.polyData.modified()},e.updateTextData=(e,n,r,o)=>{let a=0;for(let e=0;e<12;e++)1===n[e]&&(a+=2,a+=r[xu[e]].length);const i=t.polyData.getPoints().getData(),s=new Float64Array(3*a);let l=0,c=0,u=0;for(let a=0;a<6;a++)if(e[a])for(let e=0;e<4;e++){const d=yu[a][e];if(1===n[d]){const e=xu[d],n=3*bu[d][0],p=3*bu[d][1];s[3*l]=.5*(i[n]+i[p]),s[3*l+1]=.5*(i[n+1]+i[p+1]),s[3*l+2]=.5*(i[n+2]+i[p+2]),l++,s[3*l+Math.floor(a/2)]=t.dataBounds[a],s[3*l+Cu[a][0]]=.5*(t.dataBounds[2*Cu[a][0]]+t.dataBounds[2*Cu[a][0]+1]),s[3*l+Cu[a][1]]=.5*(t.dataBounds[2*Cu[a][1]]+t.dataBounds[2*Cu[a][1]+1]),l++,t.textValues[c]=t.axisLabels[e],c++;const f=(e+1)%3,g=(e+2)%3,m=r[e],h=o[e];t.tickCounts[u]=m.length;for(let r=0;r<m.length;r++)s[3*l+e]=m[r],s[3*l+f]=i[n+f],s[3*l+g]=i[n+g],l++,t.textValues[c]=h[r],c++;u++}}t.textPolyData.getPoints().setData(s,3),t.textPolyData.modified()},e.update=()=>{if(!t.camera)return;const n=e.computeFacesToDraw(),r=t.lastFacesToDraw;let o=!1;for(let e=0;e<6;e++)t.dataBounds[e]!==t.lastTickBounds[e]&&(o=!0,t.lastTickBounds[e]=t.dataBounds[e]);if(n||o||t.forceUpdate){const n=new Array(12).fill(0);for(let e=0;e<6;e++)if(r[e])for(let t=0;t<4;t++)n[yu[e][t]]++;const a=t.generateTicks(t.dataBounds);e.updatePolyData(r,n,a.ticks),e.updateTextData(r,n,a.ticks,a.tickStrings),(o||t.forceUpdate)&&e.updateTextureAtlas(a.tickStrings)}t.forceUpdate=!1},e.updateTextureAtlas=e=>{t.tmContext.textBaseline=&quot;bottom&quot;,t.tmContext.textAlign=&quot;left&quot;,t._tmAtlas.clear();let n=0,r=1;for(let o=0;o<3;o++){if(!t._tmAtlas.has(t.axisLabels[o])){Mu(t.tmContext,t.axisTextStyle);const e=t.tmContext.measureText(t.axisLabels[o]),a={height:e.actualBoundingBoxAscent+2,startingHeight:r,width:e.width+2,textStyle:t.axisTextStyle};t._tmAtlas.set(t.axisLabels[o],a),r+=a.height,n<a.width&&(n=a.width)}Mu(t.tmContext,t.tickTextStyle);for(let a=0;a<e[o].length;a++)if(!t._tmAtlas.has(e[o][a])){const i=t.tmContext.measureText(e[o][a]),s={height:i.actualBoundingBoxAscent+2,startingHeight:r,width:i.width+2,textStyle:t.tickTextStyle};t._tmAtlas.set(e[o][a],s),r+=s.height,n<s.width&&(n=s.width)}}n=wo(n),r=wo(r),t._tmAtlas.forEach((e=>{e.tcoords=[0,(r-e.startingHeight-e.height)/r,e.width/n,(r-e.startingHeight-e.height)/r,e.width/n,(r-e.startingHeight)/r,0,(r-e.startingHeight)/r]})),t.tmCanvas.width=n,t.tmCanvas.height=r,t.tmContext.textBaseline=&quot;bottom&quot;,t.tmContext.textAlign=&quot;left&quot;,t.tmContext.clearRect(0,0,n,r),t._tmAtlas.forEach(((e,n)=>{Mu(t.tmContext,e.textStyle),t.tmContext.fillText(n,1,e.startingHeight+e.height-1)})),t.tmTexture.setCanvas(t.tmCanvas),t.tmTexture.modified()},e.onModified((()=>{t.forceUpdate=!0,e.update()})),e.setTickTextStyle=n=>{t.tickTextStyle={...t.tickTextStyle,...n},e.modified()},e.setAxisTextStyle=n=>{t.axisTextStyle={...t.axisTextStyle,...n},e.modified()},e.get_tmAtlas=()=>t._tmAtlas,e.getBounds=()=>(e.update(),Gi.setBounds(t.bounds,t.gridActor.getBounds()),Gi.scaleAboutCenter(t.bounds,t.boundsScaleFactor,t.boundsScaleFactor,t.boundsScaleFactor),t.bounds);const n=Wt.chain(e.setProperty,t.gridActor.setProperty);e.setProperty=e=>n(e)[0]}(e,t)}var Lu={newInstance:Wt.newInstance(Du,&quot;vtkCubeAxesActor&quot;),extend:Du,newCubeAxesActorHelper:Vu,defaultGenerateTicks:Eu};const Bu={};const Nu=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Bu,n),qt.extend(e,t,n),t.CubeAxesActorHelper=Lu.newCubeAxesActorHelper(),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLCubeAxesActor&quot;),e.buildPass=n=>{n&&(t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getParent(),t.CubeAxesActorHelper.getRenderable()||t.CubeAxesActorHelper.setRenderable(t.renderable),e.prepareNodes(),e.addMissingNode(t.CubeAxesActorHelper.getTmActor()),e.addMissingNode(t.renderable.getGridActor()),e.removeUnusedNodes())},e.opaquePass=(e,n)=>{if(e){const e=t._openGLRenderer?t._openGLRenderer.getRenderable().getActiveCamera():null,n=t._openGLRenderer.getTiledSizeAndOrigin();t.CubeAxesActorHelper.updateAPISpecificData([n.usize,n.vsize],e,t._openGLRenderWindow.getRenderable())}}}(e,t)}),&quot;vtkOpenGLCubeAxesActor&quot;);Jt(&quot;vtkCubeAxesActor&quot;,Nu);const Fu={ARRAY_BUFFER:0,ELEMENT_ARRAY_BUFFER:1,TEXTURE_BUFFER:2};var _u={ObjectType:Fu};const{ObjectType:ku}=_u,Gu={objectType:ku.ARRAY_BUFFER,context:null,allocatedGPUMemoryInBytes:0};function Uu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Gu,n),Wt.obj(e,t),Wt.get(e,t,[&quot;_openGLRenderWindow&quot;,&quot;allocatedGPUMemoryInBytes&quot;]),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){function n(e){switch(e){case ku.ELEMENT_ARRAY_BUFFER:return t.context.ELEMENT_ARRAY_BUFFER;case ku.TEXTURE_BUFFER:if(&quot;TEXTURE_BUFFER&quot;in t.context)return t.context.TEXTURE_BUFFER;case ku.ARRAY_BUFFER:default:return t.context.ARRAY_BUFFER}}t.classHierarchy.push(&quot;vtkOpenGLBufferObject&quot;);let r=null,o=null,a=!0,i=&quot;&quot;;e.getType=()=>r,e.setType=e=>{r=e},e.getHandle=()=>o,e.isReady=()=>!1===a,e.generateBuffer=e=>{const a=n(e);return null===o&&(o=t.context.createBuffer(),r=e),n(r)===a},e.upload=(s,l)=>e.generateBuffer(l)?(t.context.bindBuffer(n(r),o),t.context.bufferData(n(r),s,t.context.STATIC_DRAW),t.allocatedGPUMemoryInBytes=s.length*s.BYTES_PER_ELEMENT,a=!1,!0):(i=&quot;Trying to upload array buffer to incompatible buffer.&quot;,!1),e.bind=()=>!!o&&(t.context.bindBuffer(n(r),o),!0),e.release=()=>!!o&&(t.context.bindBuffer(n(r),null),!0),e.releaseGraphicsResources=()=>{null!==o&&(t.context.bindBuffer(n(r),null),t.context.deleteBuffer(o),o=null,t.allocatedGPUMemoryInBytes=0)},e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))},e.getError=()=>i}(e,t)}var zu={newInstance:Wt.newInstance(Uu),extend:Uu,..._u};function Wu(e){let t=0,n=0;for(let r=0;r<3;++r){const o=e.getRange(r),a=o[1]-o[0];t+=a*a;const i=.5*(o[1]+o[0]);n+=i*i}const r=t>0&&(Math.abs(n)/t>1e6||Math.abs(Math.log10(t))>3||0===t&&n>1e6);if(r){const t=new Float64Array(3),n=new Float64Array(3);for(let r=0;r<3;++r){const o=e.getRange(r),a=o[1]-o[0];t[r]=.5*(o[1]+o[0]),n[r]=a>0?1/a:1}return{useShiftAndScale:r,coordShift:t,coordScale:n}}return{useShiftAndScale:r,coordShift:new Float32Array([0,0,0]),coordScale:new Float32Array([1,1,1])}}const{vtkErrorMacro:Hu}=Wt;const ju={elementCount:0,stride:0,colorBOStride:0,vertexOffset:0,normalOffset:0,tCoordOffset:0,tCoordComponents:0,colorOffset:0,colorComponents:0,tcoordBO:null,customData:[],coordShift:null,coordScale:null,coordShiftAndScaleEnabled:!1,inverseShiftAndScaleMatrix:null};function Ku(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ju,n),zu.extend(e,t,n),Wt.setGet(e,t,[&quot;colorBO&quot;,&quot;elementCount&quot;,&quot;stride&quot;,&quot;colorBOStride&quot;,&quot;vertexOffset&quot;,&quot;normalOffset&quot;,&quot;tCoordOffset&quot;,&quot;tCoordComponents&quot;,&quot;colorOffset&quot;,&quot;colorComponents&quot;,&quot;customData&quot;]),Wt.get(e,t,[&quot;coordShift&quot;,&quot;coordScale&quot;,&quot;coordShiftAndScaleEnabled&quot;,&quot;inverseShiftAndScaleMatrix&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLCellArrayBufferObject&quot;),e.setType(Fu.ARRAY_BUFFER),e.createVBO=function(n,r,o,a){let i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null;if(!n.getData()||!n.getData().length)return t.elementCount=0,0;t.blockSize=3,t.vertexOffset=0,t.normalOffset=0,t.tCoordOffset=0,t.tCoordComponents=0,t.colorComponents=0,t.colorOffset=0,t.customData=[];const s=a.points.getData();let l=null,c=null,u=null;const d=a.colors?a.colors.getNumberOfComponents():0,p=a.tcoords?a.tcoords.getNumberOfComponents():0;a.normals&&(t.normalOffset=4*t.blockSize,t.blockSize+=3,l=a.normals.getData()),a.customAttributes&&a.customAttributes.forEach((e=>{e&&(t.customData.push({data:e.getData(),offset:4*t.blockSize,components:e.getNumberOfComponents(),name:e.getName()}),t.blockSize+=e.getNumberOfComponents())})),a.tcoords&&(t.tCoordOffset=4*t.blockSize,t.tCoordComponents=p,t.blockSize+=p,c=a.tcoords.getData()),a.colors?(t.colorComponents=a.colors.getNumberOfComponents(),t.colorOffset=0,u=a.colors.getData(),t.colorBO||(t.colorBO=zu.newInstance()),t.colorBO.setOpenGLRenderWindow(t._openGLRenderWindow)):t.colorBO=null,t.stride=4*t.blockSize;let f,g=0,m=0,h=0,v=0,T=0,y=0;const b={anythingToPoints(e,t,n,r){for(let o=0;o<e;++o)f(t[n+o],r)},linesToWireframe(e,t,n,r){for(let o=0;o<e-1;++o)f(t[n+o],r),f(t[n+o+1],r)},polysToWireframe(e,t,n,r){if(e>2)for(let o=0;o<e;++o)f(t[n+o],r),f(t[n+(o+1)%e],r)},stripsToWireframe(e,t,n,r){if(e>2){for(let o=0;o<e-1;++o)f(t[n+o],r),f(t[n+o+1],r);for(let o=0;o<e-2;o++)f(t[n+o],r),f(t[n+o+2],r)}},polysToSurface(e,t,n,r){for(let o=0;o<e-2;o++)f(t[n+0],r),f(t[n+o+1],r),f(t[n+o+2],r)},stripsToSurface(e,t,n,r){for(let o=0;o<e-2;o++)f(t[n+o],r),f(t[n+o+1+o%2],r),f(t[n+o+1+(o+1)%2],r)}},x={anythingToPoints(e,t){return e},linesToWireframe(e,t){return e>1?2*(e-1):0},polysToWireframe(e,t){return e>2?2*e:0},stripsToWireframe(e,t){return e>2?4*e-6:0},polysToSurface(e,t){return e>2?3*(e-2):0},stripsToSurface(e,t,n){return e>2?3*(e-2):0}};let C=null,S=null;o===Zi.POINTS||&quot;verts&quot;===r?(C=b.anythingToPoints,S=x.anythingToPoints):o===Zi.WIREFRAME||&quot;lines&quot;===r?(C=b[`${r}ToWireframe`],S=x[`${r}ToWireframe`]):(C=b[`${r}ToSurface`],S=x[`${r}ToSurface`]);const A=n.getData(),I=A.length;let w=0;for(let e=0;e<I;)w+=S(A[e],A),e+=A[e]+1;let O=null;const P=new Float32Array(w*t.blockSize);u&&(O=new Uint8Array(4*w));let R=0,M=0;const{useShiftAndScale:E,coordShift:V,coordScale:D}=Wu(a.points);if(E?e.setCoordShiftAndScale(V,D):!0===t.coordShiftAndScaleEnabled&&e.setCoordShiftAndScale(null,null),i)if(i.points||i.cells){const e=new Int32Array(w+i.points.length);e.set(i.points),i.points=e;const t=new Int32Array(w+i.cells.length);t.set(i.cells),i.cells=t}else i.points=new Int32Array(w),i.cells=new Int32Array(w);let L=a.vertexOffset;f=function(e,n){if(i&&(i.points[L]=e,i.cells[L]=y+a.cellOffset),++L,g=3*e,t.coordShiftAndScaleEnabled?(P[R++]=(s[g++]-t.coordShift[0])*t.coordScale[0],P[R++]=(s[g++]-t.coordShift[1])*t.coordScale[1],P[R++]=(s[g++]-t.coordShift[2])*t.coordScale[2]):(P[R++]=s[g++],P[R++]=s[g++],P[R++]=s[g++]),null!==l&&(m=a.haveCellNormals?3*(y+a.cellOffset):3*e,P[R++]=l[m++],P[R++]=l[m++],P[R++]=l[m++]),t.customData.forEach((t=>{T=e*t.components;for(let e=0;e<t.components;++e)P[R++]=t.data[T++]})),null!==c){h=a.useTCoordsPerCell?n*p:e*p;for(let e=0;e<p;++e)P[R++]=c[h++]}null!==u&&(v=a.haveCellScalars?(y+a.cellOffset)*d:e*d,O[M++]=u[v++],O[M++]=u[v++],O[M++]=u[v++],O[M++]=4===d?u[v++]:255)};for(let e=0;e<I;e+=A[e]+1,y++)C(A[e],A,e+1,y+a.cellOffset);return t.elementCount=w,e.upload(P,Fu.ARRAY_BUFFER),t.colorBO&&(t.colorBOStride=4,t.colorBO.upload(O,Fu.ARRAY_BUFFER)),y},e.setCoordShiftAndScale=(e,n)=>{null===e||e.constructor===Float64Array&&3===e.length?null===n||n.constructor===Float64Array&&3===n.length?(null!==t.coordShift&&null!==e&&Pn(e,t.coordShift)||(t.coordShift=e),null!==t.coordScale&&null!==n&&Pn(n,t.coordScale)||(t.coordScale=n),t.coordShiftAndScaleEnabled=function(e,t){return null!==e&&null!==t&&!(On(e,[0,0,0])&&On(t,[1,1,1]))}(t.coordShift,t.coordScale),t.coordShiftAndScaleEnabled?t.inverseShiftAndScaleMatrix=function(e,t){const n=new Float64Array(3);xn(n,t);const r=new Float64Array(16);return _(r,Ba(),e,n),r}(t.coordShift,t.coordScale):t.inverseShiftAndScaleMatrix=null):Hu(&quot;Wrong type for coordScale, expected vec3 or null&quot;):Hu(&quot;Wrong type for coordShift, expected vec3 or null&quot;)}}(e,t)}var $u={newInstance:Wt.newInstance(Ku),extend:Ku};const{vtkErrorMacro:qu}=Wt,Xu={shaderType:&quot;Unknown&quot;,source:&quot;&quot;,error:&quot;&quot;,handle:0,dirty:!1,context:null};function Yu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Xu,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;shaderType&quot;,&quot;source&quot;,&quot;error&quot;,&quot;handle&quot;,&quot;context&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkShader&quot;),e.compile=()=>{let e=t.context.VERTEX_SHADER;if(!t.source||!t.source.length||&quot;Unknown&quot;===t.shaderType)return!1;if(0!==t.handle&&(t.context.deleteShader(t.handle),t.handle=0),e=&quot;Fragment&quot;===t.shaderType?t.context.FRAGMENT_SHADER:t.context.VERTEX_SHADER,t.handle=t.context.createShader(e),t.context.shaderSource(t.handle,t.source),t.context.compileShader(t.handle),!t.context.getShaderParameter(t.handle,t.context.COMPILE_STATUS)){const e=t.context.getShaderInfoLog(t.handle);return qu(`Error compiling shader '${t.source}': ${e}`),t.context.deleteShader(t.handle),t.handle=0,!1}return!0},e.cleanup=()=>{&quot;Unknown&quot;!==t.shaderType&&0!==t.handle&&(t.context.deleteShader(t.handle),t.handle=0,t.dirty=!0)}}(e,t)}var Zu={newInstance:Wt.newInstance(Yu,&quot;vtkShader&quot;),extend:Yu};const{vtkErrorMacro:Qu}=Wt,Ju={vertexShaderHandle:0,fragmentShaderHandle:0,geometryShaderHandle:0,vertexShader:null,fragmentShader:null,geometryShader:null,linked:!1,bound:!1,compiled:!1,error:&quot;&quot;,handle:0,numberOfOutputs:0,attributesLocs:null,uniformLocs:null,md5Hash:0,context:null,lastCameraMTime:null};function ed(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ju,n),t.attributesLocs={},t.uniformLocs={},t.vertexShader=Zu.newInstance(),t.vertexShader.setShaderType(&quot;Vertex&quot;),t.fragmentShader=Zu.newInstance(),t.fragmentShader.setShaderType(&quot;Fragment&quot;),t.geometryShader=Zu.newInstance(),t.geometryShader.setShaderType(&quot;Geometry&quot;),Wt.obj(e,t),Wt.get(e,t,[&quot;lastCameraMTime&quot;]),Wt.setGet(e,t,[&quot;error&quot;,&quot;handle&quot;,&quot;compiled&quot;,&quot;bound&quot;,&quot;md5Hash&quot;,&quot;vertexShader&quot;,&quot;fragmentShader&quot;,&quot;geometryShader&quot;,&quot;linked&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkShaderProgram&quot;),e.compileShader=()=>t.vertexShader.compile()?t.fragmentShader.compile()?e.attachShader(t.vertexShader)&&e.attachShader(t.fragmentShader)?e.link()?(e.setCompiled(!0),1):(Qu(`Links failed: ${t.error}`),0):(Qu(t.error),0):(Qu(t.fragmentShader.getSource().split(&quot;\\n&quot;).map(((e,t)=>`${t}: ${e}`)).join(&quot;\\n&quot;)),Qu(t.fragmentShader.getError()),0):(Qu(t.vertexShader.getSource().split(&quot;\\n&quot;).map(((e,t)=>`${t}: ${e}`)).join(&quot;\\n&quot;)),Qu(t.vertexShader.getError()),0),e.cleanup=()=>{&quot;Unknown&quot;!==t.shaderType&&0!==t.handle&&(e.release(),0!==t.vertexShaderHandle&&(t.context.detachShader(t.handle,t.vertexShaderHandle),t.vertexShaderHandle=0),0!==t.fragmentShaderHandle&&(t.context.detachShader(t.handle,t.fragmentShaderHandle),t.fragmentShaderHandle=0),t.context.deleteProgram(t.handle),t.handle=0,e.setCompiled(!1))},e.bind=()=>!(!t.linked&&!e.link()||(t.context.useProgram(t.handle),e.setBound(!0),0)),e.isBound=()=>!!t.bound,e.release=()=>{t.context.useProgram(null),e.setBound(!1)},e.setContext=e=>{t.vertexShader.setContext(e),t.fragmentShader.setContext(e),t.geometryShader.setContext(e)},e.link=()=>{if(t.linked)return!0;if(0===t.handle)return t.error=&quot;Program has not been initialized, and/or does not have shaders.&quot;,!1;if(t.uniformLocs={},t.context.linkProgram(t.handle),!t.context.getProgramParameter(t.handle,t.context.LINK_STATUS)){const e=t.context.getProgramInfoLog(t.handle);return Qu(`Error linking shader ${e}`),t.handle=0,!1}return e.setLinked(!0),t.attributeLocs={},!0},e.setUniformMatrix=(n,r)=>{const o=e.findUniform(n);if(-1===o)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;const a=new Float32Array(r);return t.context.uniformMatrix4fv(o,!1,a),!0},e.setUniformMatrix3x3=(n,r)=>{const o=e.findUniform(n);if(-1===o)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;const a=new Float32Array(r);return t.context.uniformMatrix3fv(o,!1,a),!0},e.setUniformf=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform1f(o,r),!0)},e.setUniformfv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform1fv(o,r),!0)},e.setUniformi=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform1i(o,r),!0)},e.setUniformiv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform1iv(o,r),!0)},e.setUniform2f=(n,r,o)=>{const a=e.findUniform(n);if(-1===a)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;if(void 0===o)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform2f(a,r,o),!0},e.setUniform2fv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform2fv(o,r),!0)},e.setUniform2i=(n,r,o)=>{const a=e.findUniform(n);if(-1===a)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;if(void 0===o)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform2i(a,r,o),!0},e.setUniform2iv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform2iv(o,r),!0)},e.setUniform3f=(n,r,o,a)=>{const i=e.findUniform(n);if(-1===i)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;if(void 0===a)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform3f(i,r,o,a),!0},e.setUniform3fArray=(n,r)=>{const o=e.findUniform(n);if(-1===o)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;if(!Array.isArray(r)||3!==r.length)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform3f(o,r[0],r[1],r[2]),!0},e.setUniform3fv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform3fv(o,r),!0)},e.setUniform3i=function(n){const r=e.findUniform(n);if(-1===r)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;for(var o=arguments.length,a=new Array(o>1?o-1:0),i=1;i<o;i++)a[i-1]=arguments[i];let s=a;if(1===s.length&&Array.isArray(s[0])&&(s=s[0]),3!==s.length)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform3i(r,s[0],s[1],s[2]),!0},e.setUniform3iv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform3iv(o,r),!0)},e.setUniform4f=function(n){const r=e.findUniform(n);if(-1===r)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;for(var o=arguments.length,a=new Array(o>1?o-1:0),i=1;i<o;i++)a[i-1]=arguments[i];let s=a;if(1===s.length&&Array.isArray(s[0])&&(s=s[0]),4!==s.length)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform4f(r,s[0],s[1],s[2],s[3]),!0},e.setUniform4fv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform4fv(o,r),!0)},e.setUniform4i=function(n){const r=e.findUniform(n);if(-1===r)return t.error=`Could not set uniform ${n} . No such uniform.`,!1;for(var o=arguments.length,a=new Array(o>1?o-1:0),i=1;i<o;i++)a[i-1]=arguments[i];let s=a;if(1===s.length&&Array.isArray(s[0])&&(s=s[0]),4!==s.length)throw new RangeError(&quot;Invalid number of values for array&quot;);return t.context.uniform4i(r,s[0],s[1],s[2],s[3]),!0},e.setUniform4iv=(n,r)=>{const o=e.findUniform(n);return-1===o?(t.error=`Could not set uniform ${n} . No such uniform.`,!1):(t.context.uniform4iv(o,r),!0)},e.findUniform=e=>{if(!e||!t.linked)return-1;let n=t.uniformLocs[e];return void 0!==n?n:(n=t.context.getUniformLocation(t.handle,e),null===n?(t.error=`Uniform ${e} not found in current shader program.`,t.uniformLocs[e]=-1,-1):(t.uniformLocs[e]=n,n))},e.isUniformUsed=e=>{if(!e)return!1;let n=t.uniformLocs[e];return void 0!==n?null!==n:t.linked?(n=t.context.getUniformLocation(t.handle,e),t.uniformLocs[e]=n,null!==n):(Qu(&quot;attempt to find uniform when the shader program is not linked&quot;),!1)},e.isAttributeUsed=e=>{if(!e)return!1;if(e in t.attributeLocs)return!0;if(!t.linked)return Qu(&quot;attempt to find uniform when the shader program is not linked&quot;),!1;const n=t.context.getAttribLocation(t.handle,e);return-1!==n&&(t.attributeLocs[e]=n,!0)},e.attachShader=n=>{if(0===n.getHandle())return t.error=&quot;Shader object was not initialized, cannot attach it.&quot;,!1;if(&quot;Unknown&quot;===n.getShaderType())return t.error=&quot;Shader object is of type Unknown and cannot be used.&quot;,!1;if(0===t.handle){const e=t.context.createProgram();if(0===e)return t.error=&quot;Could not create shader program.&quot;,!1;t.handle=e,t.linked=!1}return&quot;Vertex&quot;===n.getShaderType()&&(0!==t.vertexShaderHandle&&t.context.detachShader(t.handle,t.vertexShaderHandle),t.vertexShaderHandle=n.getHandle()),&quot;Fragment&quot;===n.getShaderType()&&(0!==t.fragmentShaderHandle&&t.context.detachShader(t.handle,t.fragmentShaderHandle),t.fragmentShaderHandle=n.getHandle()),t.context.attachShader(t.handle,n.getHandle()),e.setLinked(!1),!0},e.detachShader=e=>{if(0===e.getHandle())return t.error=&quot;shader object was not initialized, cannot attach it.&quot;,!1;if(&quot;Unknown&quot;===e.getShaderType())return t.error=&quot;Shader object is of type Unknown and cannot be used.&quot;,!1;switch(0===t.handle&&(t.error=&quot;This shader program has not been initialized yet.&quot;),e.getShaderType()){case&quot;Vertex&quot;:return t.vertexShaderHandle!==e.getHandle()?(t.error=&quot;The supplied shader was not attached to this program.&quot;,!1):(t.context.detachShader(t.handle,e.getHandle()),t.vertexShaderHandle=0,t.linked=!1,!0);case&quot;Fragment&quot;:return t.fragmentShaderHandle!==e.getHandle()?(t.error=&quot;The supplied shader was not attached to this program.&quot;,!1):(t.context.detachShader(t.handle,e.getHandle()),t.fragmentShaderHandle=0,t.linked=!1,!0);default:return!1}},e.setContext=e=>{t.context=e,t.vertexShader.setContext(e),t.fragmentShader.setContext(e),t.geometryShader.setContext(e)},e.setLastCameraMTime=e=>{t.lastCameraMTime=e}}(e,t)}var td={newInstance:Wt.newInstance(ed,&quot;vtkShaderProgram&quot;),extend:ed,substitute:function(e,t,n,r){const o=&quot;string&quot;==typeof n?n:n.join(&quot;\\n&quot;),a=!1===r?t:new RegExp(t,&quot;g&quot;),i=e.replace(a,o);return{replace:i!==o,result:i}}};const nd={forceEmulation:!1,handleVAO:0,handleProgram:0,supported:!0,buffers:null,context:null};function rd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,nd,n),t.buffers=[],Wt.obj(e,t),Wt.get(e,t,[&quot;supported&quot;]),Wt.setGet(e,t,[&quot;forceEmulation&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLVertexArrayObject&quot;),e.exposedMethod=()=>{},e.initialize=()=>{t.instancingExtension=null,t._openGLRenderWindow.getWebgl2()||(t.instancingExtension=t.context.getExtension(&quot;ANGLE_instanced_arrays&quot;)),!t.forceEmulation&&t._openGLRenderWindow&&t._openGLRenderWindow.getWebgl2()?(t.extension=null,t.supported=!0,t.handleVAO=t.context.createVertexArray()):(t.extension=t.context.getExtension(&quot;OES_vertex_array_object&quot;),!t.forceEmulation&&t.extension?(t.supported=!0,t.handleVAO=t.extension.createVertexArrayOES()):t.supported=!1)},e.isReady=()=>0!==t.handleVAO||!1===t.supported,e.bind=()=>{if(e.isReady()||e.initialize(),e.isReady()&&t.supported)t.extension?t.extension.bindVertexArrayOES(t.handleVAO):t.context.bindVertexArray(t.handleVAO);else if(e.isReady()){const e=t.context;for(let n=0;n<t.buffers.length;++n){const r=t.buffers[n];t.context.bindBuffer(e.ARRAY_BUFFER,r.buffer);for(let n=0;n<r.attributes.length;++n){const o=r.attributes[n],a=o.isMatrix?o.size:1;for(let n=0;n<a;++n)e.enableVertexAttribArray(o.index+n),e.vertexAttribPointer(o.index+n,o.size,o.type,o.normalize,o.stride,o.offset+o.stride*n/o.size),o.divisor>0&&(t.instancingExtension?t.instancingExtension.vertexAttribDivisorANGLE(o.index+n,1):e.vertexAttribDivisor(o.index+n,1))}}}},e.release=()=>{if(e.isReady()&&t.supported)t.extension?t.extension.bindVertexArrayOES(null):t.context.bindVertexArray(null);else if(e.isReady()){const e=t.context;for(let n=0;n<t.buffers.length;++n){const r=t.buffers[n];t.context.bindBuffer(e.ARRAY_BUFFER,r.buffer);for(let n=0;n<r.attributes.length;++n){const o=r.attributes[n],a=o.isMatrix?o.size:1;for(let n=0;n<a;++n)e.enableVertexAttribArray(o.index+n),e.vertexAttribPointer(o.index+n,o.size,o.type,o.normalize,o.stride,o.offset+o.stride*n/o.size),o.divisor>0&&(t.instancingExtension?t.instancingExtension.vertexAttribDivisorANGLE(o.index+n,0):e.vertexAttribDivisor(o.index+n,0)),e.disableVertexAttribArray(o.index+n)}}}},e.shaderProgramChanged=()=>{e.release(),t.handleVAO&&(t.extension?t.extension.deleteVertexArrayOES(t.handleVAO):t.context.deleteVertexArray(t.handleVAO)),t.handleVAO=0,t.handleProgram=0},e.releaseGraphicsResources=()=>{e.shaderProgramChanged(),t.handleVAO&&(t.extension?t.extension.deleteVertexArrayOES(t.handleVAO):t.context.deleteVertexArray(t.handleVAO)),t.handleVAO=0,t.supported=!0,t.handleProgram=0},e.addAttributeArray=(t,n,r,o,a,i,s,l)=>e.addAttributeArrayWithDivisor(t,n,r,o,a,i,s,l,0,!1),e.addAttributeArrayWithDivisor=(n,r,o,a,i,s,l,c,u,d)=>{if(!n)return!1;if(!n.isBound()||0===r.getHandle()||r.getType()!==Fu.ARRAY_BUFFER)return!1;if(0===t.handleProgram&&(t.handleProgram=n.getHandle()),e.isReady()||e.initialize(),!e.isReady()||t.handleProgram!==n.getHandle())return!1;const p=t.context,f={};if(f.name=o,f.index=p.getAttribLocation(t.handleProgram,o),f.offset=a,f.stride=i,f.type=s,f.size=l,f.normalize=c,f.isMatrix=d,f.divisor=u,-1===f.Index)return!1;if(r.bind(),p.enableVertexAttribArray(f.index),p.vertexAttribPointer(f.index,f.size,f.type,f.normalize,f.stride,f.offset),u>0&&(t.instancingExtension?t.instancingExtension.vertexAttribDivisorANGLE(f.index,1):p.vertexAttribDivisor(f.index,1)),f.buffer=r.getHandle(),!t.supported){let e=!1;for(let n=0;n<t.buffers.length;++n){const r=t.buffers[n];if(r.buffer===f.buffer){e=!0;let t=!1;for(let e=0;e<r.attributes.length;++e)r.attributes[e].name===o&&(t=!0,r.attributes[e]=f);t||r.attributes.push(f)}}e||t.buffers.push({buffer:f.buffer,attributes:[f]})}return!0},e.addAttributeMatrixWithDivisor=(n,r,o,a,i,s,l,c,u)=>{const d=e.addAttributeArrayWithDivisor(n,r,o,a,i,s,l,c,u,!0);if(!d)return d;const p=t.context,f=p.getAttribLocation(t.handleProgram,o);for(let e=1;e<l;e++)p.enableVertexAttribArray(f+e),p.vertexAttribPointer(f+e,l,s,c,i,a+i*e/l),u>0&&(t.instancingExtension?t.instancingExtension.vertexAttribDivisorANGLE(f+e,1):p.vertexAttribDivisor(f+e,1));return!0},e.removeAttributeArray=n=>{if(!e.isReady()||0===t.handleProgram)return!1;if(!t.supported)for(let e=0;e<t.buffers.length;++e){const r=t.buffers[e];for(let o=0;o<r.attributes.length;++o)if(r.attributes[o].name===n)return r.attributes.splice(o,1),r.attributes.length||t.buffers.splice(e,1),!0}return!0},e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))}}(e,t)}var od={newInstance:Wt.newInstance(rd,&quot;vtkOpenGLVertexArrayObject&quot;),extend:rd};const ad={Start:0,Points:0,Lines:1,Tris:2,TriStrips:3,TrisEdges:4,TriStripsEdges:5,End:6},id={context:null,program:null,shaderSourceTime:null,VAO:null,attributeUpdateTime:null,CABO:null,primitiveType:0,pointPicking:!1};function sd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,id,n),Wt.obj(e,t),t.shaderSourceTime={},Wt.obj(t.shaderSourceTime),t.attributeUpdateTime={},Wt.obj(t.attributeUpdateTime),Wt.setGet(e,t,[&quot;program&quot;,&quot;shaderSourceTime&quot;,&quot;VAO&quot;,&quot;attributeUpdateTime&quot;,&quot;CABO&quot;,&quot;primitiveType&quot;,&quot;pointPicking&quot;]),t.program=td.newInstance(),t.VAO=od.newInstance(),t.CABO=$u.newInstance(),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLHelper&quot;),e.setOpenGLRenderWindow=e=>{t.context=e.getContext(),t.program.setContext(t.context),t.VAO.setOpenGLRenderWindow(e),t.CABO.setOpenGLRenderWindow(e)},e.releaseGraphicsResources=e=>{t.VAO.releaseGraphicsResources(),t.CABO.releaseGraphicsResources(),t.CABO.setElementCount(0)},e.drawArrays=(n,r,o,a)=>{if(t.CABO.getElementCount()){const i=e.getOpenGLMode(o),s=e.haveWideLines(n,r),l=t.context,c=l.getParameter(l.DEPTH_WRITEMASK);t.pointPicking&&l.depthMask(!1),i===l.LINES&&s?(e.updateShaders(n,r,a),l.drawArraysInstanced(i,0,t.CABO.getElementCount(),2*Math.ceil(r.getProperty().getLineWidth()))):(l.lineWidth(r.getProperty().getLineWidth()),e.updateShaders(n,r,a),l.drawArrays(i,0,t.CABO.getElementCount()),l.lineWidth(1));const u=(i===l.POINTS?1:0)||(i===l.LINES?2:3);return t.pointPicking&&l.depthMask(c),t.CABO.getElementCount()/u}return 0},e.getOpenGLMode=e=>{if(t.pointPicking)return t.context.POINTS;const n=t.primitiveType;return e===Zi.POINTS||n===ad.Points?t.context.POINTS:e===Zi.WIREFRAME||n===ad.Lines||n===ad.TrisEdges||n===ad.TriStripsEdges?t.context.LINES:t.context.TRIANGLES},e.haveWideLines=(e,n)=>n.getProperty().getLineWidth()>1&&!(t.CABO.getOpenGLRenderWindow()&&t.CABO.getOpenGLRenderWindow().getHardwareMaximumLineWidth()>=n.getProperty().getLineWidth()),e.getNeedToRebuildShaders=(t,n,r)=>!!(r.getNeedToRebuildShaders(e,t,n)||0===e.getProgram()||e.getShaderSourceTime().getMTime()<r.getMTime()||e.getShaderSourceTime().getMTime()<n.getMTime()),e.updateShaders=(n,r,o)=>{if(e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};o.buildShaders(a,n,r);const i=t.CABO.getOpenGLRenderWindow().getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==e.getProgram()&&(e.setProgram(i),e.getVAO().releaseGraphicsResources()),e.getShaderSourceTime().modified()}else t.CABO.getOpenGLRenderWindow().getShaderCache().readyShaderProgram(e.getProgram());e.getVAO().bind(),o.setMapperShaderParameters(e,n,r),o.setPropertyShaderParameters(e,n,r),o.setCameraShaderParameters(e,n,r),o.setLightingShaderParameters(e,n,r),o.invokeShaderCallbacks(e,n,r)},e.setMapperShaderParameters=(n,r,o)=>{if(e.haveWideLines(n,r)){e.getProgram().setUniform2f(&quot;viewportSize&quot;,o.usize,o.vsize);const t=parseFloat(r.getProperty().getLineWidth()),n=t/2;e.getProgram().setUniformf(&quot;lineWidthStepSize&quot;,t/Math.ceil(t)),e.getProgram().setUniformf(&quot;halfLineWidth&quot;,n)}t.primitiveType===ad.Points||r.getProperty().getRepresentation()===Zi.POINTS?e.getProgram().setUniformf(&quot;pointSize&quot;,r.getProperty().getPointSize()):t.pointPicking&&e.getProgram().setUniformf(&quot;pointSize&quot;,e.getPointPickingPrimitiveSize())},e.replaceShaderPositionVC=(n,r,o)=>{let a=n.Vertex;a=td.substitute(a,&quot;//VTK::PositionVC::Dec&quot;,[&quot;//VTK::PositionVC::Dec&quot;,&quot;uniform float pointSize;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;//VTK::PositionVC::Impl&quot;,&quot;  gl_PointSize = pointSize;&quot;],!1).result,e.getOpenGLMode(o.getProperty().getRepresentation())===t.context.LINES&&e.haveWideLines(r,o)&&(a=td.substitute(a,&quot;//VTK::PositionVC::Dec&quot;,[&quot;//VTK::PositionVC::Dec&quot;,&quot;uniform vec2 viewportSize;&quot;,&quot;uniform float lineWidthStepSize;&quot;,&quot;uniform float halfLineWidth;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;//VTK::PositionVC::Impl&quot;,&quot; if (halfLineWidth > 0.0)&quot;,&quot;   {&quot;,&quot;   float offset = float(gl_InstanceID / 2) * lineWidthStepSize - halfLineWidth;&quot;,&quot;   vec4 tmpPos = gl_Position;&quot;,&quot;   vec3 tmpPos2 = tmpPos.xyz / tmpPos.w;&quot;,&quot;   tmpPos2.x = tmpPos2.x + 2.0 * mod(float(gl_InstanceID), 2.0) * offset / viewportSize[0];&quot;,&quot;   tmpPos2.y = tmpPos2.y + 2.0 * mod(float(gl_InstanceID + 1), 2.0) * offset / viewportSize[1];&quot;,&quot;   gl_Position = vec4(tmpPos2.xyz * tmpPos.w, tmpPos.w);&quot;,&quot;   }&quot;]).result),n.Vertex=a},e.getPointPickingPrimitiveSize=()=>t.primitiveType===ad.Points?2:t.primitiveType===ad.Lines?4:6,e.getAllocatedGPUMemoryInBytes=()=>e.getCABO().getAllocatedGPUMemoryInBytes()}(e,t)}var ld={newInstance:Wt.newInstance(sd),extend:sd,primTypes:ad};const cd={CLAMP_TO_EDGE:0,REPEAT:1,MIRRORED_REPEAT:2},ud={NEAREST:0,LINEAR:1,NEAREST_MIPMAP_NEAREST:2,NEAREST_MIPMAP_LINEAR:3,LINEAR_MIPMAP_NEAREST:4,LINEAR_MIPMAP_LINEAR:5};var dd={Wrap:cd,Filter:ud};const pd=new Float32Array(1),fd=new Int32Array(pd.buffer);var gd={fromHalf:function(e){const t=(32768&e)>>15,n=(31744&e)>>10,r=1023&e;return 0===n?(t?-1:1)*2**-14*(r/1024):31===n?r?NaN:1/0*(t?-1:1):(t?-1:1)*2**(n-15)*(1+r/1024)},toHalf:function(e){pd[0]=e;const t=fd[0];let n=t>>16&32768,r=t>>12&2047;const o=t>>23&255;return o<103?n:o>142?(n|=31744,n|=(255===o?0:1)&&8388607&t,n):o<113?(r|=2048,n|=(r>>114-o)+(r>>113-o&1),n):(n|=o-112<<10|r>>1,n+=1&r,n)}};let md;const{Wrap:hd,Filter:vd}=dd,{VtkDataTypes:Td}=xs,{vtkDebugMacro:yd,vtkErrorMacro:bd,vtkWarningMacro:xd,requiredParam:Cd}=Ht,{toHalf:Sd}=gd;function Ad(e,t){function n(){return{internalFormat:t.internalFormat,format:t.format,openGLDataType:t.openGLDataType,width:t.width,height:t.height}}t.classHierarchy.push(&quot;vtkOpenGLTexture&quot;),e.render=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:null;if(n?t._openGLRenderWindow=n:(t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;)),t.context=t._openGLRenderWindow.getContext(),t.renderable.getInterpolate()?(t.generateMipmap?e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR):e.setMinificationFilter(vd.LINEAR),e.setMagnificationFilter(vd.LINEAR)):(e.setMinificationFilter(vd.NEAREST),e.setMagnificationFilter(vd.NEAREST)),t.renderable.getRepeat()&&(e.setWrapR(hd.REPEAT),e.setWrapS(hd.REPEAT),e.setWrapT(hd.REPEAT)),t.renderable.getInputData()&&t.renderable.setImage(null),!t.handle||t.renderable.getMTime()>t.textureBuildTime.getMTime()){if(null!==t.renderable.getImageBitmap()&&(t.renderable.getInterpolate()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR)),t.renderable.getImageBitmap()&&t.renderable.getImageLoaded()&&(e.create2DFromImageBitmap(t.renderable.getImageBitmap()),e.activate(),e.sendParameters(),t.textureBuildTime.modified())),null!==t.renderable.getImage()&&(t.renderable.getInterpolate()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR)),t.renderable.getImage()&&t.renderable.getImageLoaded()&&(e.create2DFromImage(t.renderable.getImage()),e.activate(),e.sendParameters(),t.textureBuildTime.modified())),null!==t.renderable.getCanvas()){t.renderable.getInterpolate()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR));const n=t.renderable.getCanvas();e.create2DFromRaw({width:n.width,height:n.height,numComps:4,dataType:Td.UNSIGNED_CHAR,data:n,flip:!0}),e.activate(),e.sendParameters(),t.textureBuildTime.modified()}if(null!==t.renderable.getJsImageData()){const n=t.renderable.getJsImageData();t.renderable.getInterpolate()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR)),e.create2DFromRaw({width:n.width,height:n.height,numComps:4,dataType:Td.UNSIGNED_CHAR,data:n.data,flip:!0}),e.activate(),e.sendParameters(),t.textureBuildTime.modified()}const n=t.renderable.getInputData(0);if(n&&n.getPointData().getScalars()){const r=n.getExtent(),o=n.getPointData().getScalars(),a=[];for(let e=0;e<t.renderable.getNumberOfInputPorts();++e){const n=t.renderable.getInputData(e),r=n?n.getPointData().getScalars().getData():null;r&&a.push(r)}t.renderable.getInterpolate()&&4===o.getNumberOfComponents()&&(t.generateMipmap=!0,e.setMinificationFilter(vd.LINEAR_MIPMAP_LINEAR)),a.length%6==0?e.createCubeFromRaw({width:r[1]-r[0]+1,height:r[3]-r[2]+1,numComps:o.getNumberOfComponents(),dataType:o.getDataType(),data:a}):e.create2DFromRaw({width:r[1]-r[0]+1,height:r[3]-r[2]+1,numComps:o.getNumberOfComponents(),dataType:o.getDataType(),data:o.getData()}),e.activate(),e.sendParameters(),t.textureBuildTime.modified()}}t.handle&&e.activate()};const r=()=>{if(t.minificationFilter!==vd.LINEAR&&t.magnificationFilter!==vd.LINEAR||(void 0===md&&(md=function(){try{const e=4,t=2,n=1,r=new Int16Array([0,32767]),o=[1,1],a=document.createElement(&quot;canvas&quot;);a.width=e,a.height=e;const i=a.getContext(&quot;webgl2&quot;);if(!i)return!1;const s=i.getExtension(&quot;EXT_texture_norm16&quot;);if(!s)return!1;const l=`#version 300 es\\n    void main() {\\n      gl_PointSize = ${e.toFixed(1)};\\n      gl_Position = vec4(0, 0, 0, 1);\\n    }\\n  `,c=&quot;#version 300 es\\n    precision highp float;\\n    precision highp int;\\n    precision highp sampler2D;\\n\\n    uniform sampler2D u_image;\\n\\n    out vec4 color;\\n\\n    void main() {\\n        vec4 intColor = texture(u_image, gl_PointCoord.xy);\\n        color = vec4(vec3(intColor.rrr), 1);\\n    }\\n    &quot;,u=i.createShader(i.VERTEX_SHADER);if(i.shaderSource(u,l),i.compileShader(u),!i.getShaderParameter(u,i.COMPILE_STATUS))return!1;const d=i.createShader(i.FRAGMENT_SHADER);if(i.shaderSource(d,c),i.compileShader(d),!i.getShaderParameter(d,i.COMPILE_STATUS))return!1;const p=i.createProgram();if(i.attachShader(p,u),i.attachShader(p,d),i.linkProgram(p),!i.getProgramParameter(p,i.LINK_STATUS))return!1;const f=i.createTexture();i.bindTexture(i.TEXTURE_2D,f),i.texImage2D(i.TEXTURE_2D,0,s.R16_SNORM_EXT,t,n,0,i.RED,i.SHORT,r),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_MAG_FILTER,i.LINEAR),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_MIN_FILTER,i.LINEAR),i.useProgram(p),i.drawArrays(i.POINTS,0,1);const g=new Uint8Array(4);i.readPixels(o[0],o[1],1,1,i.RGBA,i.UNSIGNED_BYTE,g);const[m,h,v]=g,T=i.getExtension(&quot;WEBGL_lose_context&quot;);return T&&T.loseContext(),m===h&&h===v&&0!==m}catch(e){return!1}}()),md))return t.oglNorm16Ext};function o(e){const[t,n,r,o,a,i]=e;return[n-t+1,o-r+1,i-a+1]}function a(e){const[t,n,r]=o(e);return t*n*r}function i(e,n){const r=new((arguments.length>2&&void 0!==arguments[2]?arguments[2]:null)||e.constructor)(n.reduce(((e,t)=>e+a(t)),0)),o=[t.width,t.height,t.depth];let i=0;return n.forEach((t=>{!function(e,t,n,r,o){const[a,i,s,l,c,u]=n,[d,p]=t,f=d*p;let g=o;for(let t=c;t<=u;t++){const n=t*f;for(let t=s;t<=l;t++){const o=n+t*d;for(let t=o+a,n=o+i;t<=n;t++,g++)r[g]=e[t]}}}(e,o,t,r,i),i+=a(t)})),r}function s(e){if(t._openGLRenderWindow.getWebgl2())return e;const n=[],r=t.width,o=t.height,a=t.components;if(e&&(!Oo(r)||!Oo(o))){const i=t.context.getExtension(&quot;OES_texture_half_float&quot;),s=wo(r),l=wo(o),c=s*l*t.components;for(let u=0;u<e.length;u++)if(null!==e[u]){let d=null;const p=o/l,f=r/s;let g=!1;t.openGLDataType===t.context.FLOAT?d=new Float32Array(c):i&&t.openGLDataType===i.HALF_FLOAT_OES?(d=new Uint16Array(c),g=!0):d=new Uint8Array(c);for(let t=0;t<l;t++){const n=t*s*a,i=t*p;let l=Math.floor(i),c=Math.ceil(i);c>=o&&(c=o-1);const m=i-l,h=1-m;l=l*r*a,c=c*r*a;for(let t=0;t<s;t++){const o=t*a,i=t*f;let s=Math.floor(i),p=Math.ceil(i);p>=r&&(p=r-1);const v=i-s;s*=a,p*=a;for(let t=0;t<a;t++)d[n+o+t]=g?gd.toHalf(gd.fromHalf(e[u][l+s+t])*h*(1-v)+gd.fromHalf(e[u][l+p+t])*h*v+gd.fromHalf(e[u][c+s+t])*m*(1-v)+gd.fromHalf(e[u][c+p+t])*m*v):e[u][l+s+t]*h*(1-v)+e[u][l+p+t]*h*v+e[u][c+s+t]*m*(1-v)+e[u][c+p+t]*m*v}}n.push(d),t.width=s,t.height=l}else n.push(null)}if(0===n.length)for(let t=0;t<e.length;t++)n.push(e[t]);return n}function l(e){return!!t._openGLRenderWindow&&(!t.resizable&&!t.renderable?.getResizable()&&(!!t._openGLRenderWindow.getWebgl2()&&(!(t._openGLRenderWindow.getGLInformations().RENDERER.value.match(/WebKit/gi)&&navigator.platform.match(/Mac/gi)&&r())||e!==Td.UNSIGNED_SHORT&&e!==Td.SHORT)))}function c(n,r){const o=n.getNumberOfComponents(),a=n.getDataType(),i=n.getData(),s=new Array(o),l=new Array(o);for(let e=0;e<o;++e){const[t,r]=n.getRange(e);s[e]=t,l[e]=r}const c=function(e,t,n){const r=new Array(n),o=new Array(n);for(let a=0;a<n;++a)r[a]=e[a],o[a]=t[a]-e[a]||1;return{scale:o,offset:r}}(s,l,o);return function(n,r,o,a){e.getOpenGLDataType(n);const i=function(e,t){for(let n=0;n<e.length;n++){const r=e[n],o=t[n]+r;if(r<-2048||r>2048||o<-2048||o>2048)return!1}return!0}(r,o)||a;let s=!1;if(t._openGLRenderWindow.getWebgl2())s=t.openGLDataType===t.context.FLOAT&&null===t.context.getExtension(&quot;OES_texture_float_linear&quot;)&&i||t.openGLDataType===t.context.HALF_FLOAT;else{const e=t.context.getExtension(&quot;OES_texture_half_float&quot;);s=e&&t.openGLDataType===e.HALF_FLOAT_OES}t.canUseHalfFloat=s&&i}(a,c.offset,c.scale,r),e.useHalfFloat()||e.getOpenGLDataType(a,!0),{numComps:o,dataType:a,data:i,scaleOffsets:c}}e.destroyTexture=()=>{e.deactivate(),t.context&&t.handle&&t.context.deleteTexture(t.handle),t._prevTexParams=null,t.handle=0,t.numberOfDimensions=0,t.target=0,t.components=0,t.width=0,t.height=0,t.depth=0,e.resetFormatAndType()},e.createTexture=()=>{t.handle||(t.handle=t.context.createTexture(),t.target&&(t.context.bindTexture(t.target,t.handle),t.context.texParameteri(t.target,t.context.TEXTURE_MIN_FILTER,e.getOpenGLFilterMode(t.minificationFilter)),t.context.texParameteri(t.target,t.context.TEXTURE_MAG_FILTER,e.getOpenGLFilterMode(t.magnificationFilter)),t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_S,e.getOpenGLWrapMode(t.wrapS)),t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_T,e.getOpenGLWrapMode(t.wrapT)),t._openGLRenderWindow.getWebgl2()&&t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_R,e.getOpenGLWrapMode(t.wrapR)),t.context.bindTexture(t.target,null)))},e.getTextureUnit=()=>t._openGLRenderWindow?t._openGLRenderWindow.getTextureUnitForTexture(e):-1,e.activate=()=>{t._openGLRenderWindow.activateTexture(e),e.bind()},e.deactivate=()=>{t._openGLRenderWindow&&t._openGLRenderWindow.deactivateTexture(e)},e.releaseGraphicsResources=n=>{n&&t.handle&&(n.activateTexture(e),n.deactivateTexture(e),t.context.deleteTexture(t.handle),t._prevTexParams=null,t.handle=0,t.numberOfDimensions=0,t.target=0,t.internalFormat=0,t.format=0,t.openGLDataType=0,t.components=0,t.width=0,t.height=0,t.depth=0,t.allocatedGPUMemoryInBytes=0),t.shaderProgram&&(t.shaderProgram.releaseGraphicsResources(n),t.shaderProgram=null)},e.bind=()=>{t.context.bindTexture(t.target,t.handle),t.autoParameters&&e.getMTime()>t.sendParametersTime.getMTime()&&e.sendParameters()},e.isBound=()=>{let e=!1;if(t.context&&t.handle){let n=0;t.target===t.context.TEXTURE_2D?n=t.context.TEXTURE_BINDING_2D:xd(&quot;impossible case&quot;),e=t.context.getIntegerv(n)===t.handle}return e},e.sendParameters=()=>{t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_S,e.getOpenGLWrapMode(t.wrapS)),t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_T,e.getOpenGLWrapMode(t.wrapT)),t._openGLRenderWindow.getWebgl2()&&t.context.texParameteri(t.target,t.context.TEXTURE_WRAP_R,e.getOpenGLWrapMode(t.wrapR)),t.context.texParameteri(t.target,t.context.TEXTURE_MIN_FILTER,e.getOpenGLFilterMode(t.minificationFilter)),t.context.texParameteri(t.target,t.context.TEXTURE_MAG_FILTER,e.getOpenGLFilterMode(t.magnificationFilter)),t._openGLRenderWindow.getWebgl2()&&(t.context.texParameteri(t.target,t.context.TEXTURE_BASE_LEVEL,t.baseLevel),t.context.texParameteri(t.target,t.context.TEXTURE_MAX_LEVEL,t.maxLevel)),t.sendParametersTime.modified()},e.getInternalFormat=(n,r)=>(t._forceInternalFormat||(t.internalFormat=e.getDefaultInternalFormat(n,r)),t.internalFormat||yd(`Unable to find suitable internal format for T=${n} NC= ${r}`),[t.context.R32F,t.context.RG32F,t.context.RGB32F,t.context.RGBA32F].includes(t.internalFormat)&&!t.context.getExtension(&quot;OES_texture_float_linear&quot;)&&xd(&quot;Failed to load OES_texture_float_linear. Texture filtering is not available for *32F internal formats.&quot;),t.internalFormat),e.getDefaultInternalFormat=(n,o)=>{let a=0;return a=t._openGLRenderWindow.getDefaultTextureInternalFormat(n,o,r(),e.useHalfFloat()),a||(a||(yd(&quot;Unsupported internal texture type!&quot;),yd(`Unable to find suitable internal format for T=${n} NC= ${o}`)),a)},e.useHalfFloat=()=>t.enableUseHalfFloat&&t.canUseHalfFloat,e.setInternalFormat=n=>{t._forceInternalFormat=!0,n!==t.internalFormat&&(t.internalFormat=n,e.modified())},e.getFormat=(n,r)=>(t.format=e.getDefaultFormat(n,r),t.format),e.getDefaultFormat=(e,n)=>{if(t._openGLRenderWindow.getWebgl2())switch(n){case 1:return t.context.RED;case 2:return t.context.RG;case 3:default:return t.context.RGB;case 4:return t.context.RGBA}else switch(n){case 1:return t.context.LUMINANCE;case 2:return t.context.LUMINANCE_ALPHA;case 3:default:return t.context.RGB;case 4:return t.context.RGBA}},e.resetFormatAndType=()=>{t._prevTexParams=null,t.format=0,t.internalFormat=0,t._forceInternalFormat=!1,t.openGLDataType=0},e.getDefaultDataType=n=>{const o=e.useHalfFloat();if(t._openGLRenderWindow.getWebgl2())switch(n){case Td.UNSIGNED_CHAR:return t.context.UNSIGNED_BYTE;case r()&&!o&&Td.SHORT:return t.context.SHORT;case r()&&!o&&Td.UNSIGNED_SHORT:return t.context.UNSIGNED_SHORT;case o&&Td.SHORT:case o&&Td.UNSIGNED_SHORT:return t.context.HALF_FLOAT;case Td.FLOAT:case Td.VOID:default:return t.context.FLOAT}switch(n){case Td.UNSIGNED_CHAR:return t.context.UNSIGNED_BYTE;case Td.FLOAT:case Td.VOID:default:if(t.context.getExtension(&quot;OES_texture_float&quot;)&&t.context.getExtension(&quot;OES_texture_float_linear&quot;))return t.context.FLOAT;{const e=t.context.getExtension(&quot;OES_texture_half_float&quot;);if(e&&t.context.getExtension(&quot;OES_texture_half_float_linear&quot;))return e.HALF_FLOAT_OES}return t.context.UNSIGNED_BYTE}},e.getOpenGLDataType=function(n){let r=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return t.openGLDataType&&!r||(t.openGLDataType=e.getDefaultDataType(n)),t.openGLDataType},e.getShiftAndScale=()=>{let e=0,n=1;switch(t.openGLDataType){case t.context.BYTE:n=127.5,e=n-128;break;case t.context.UNSIGNED_BYTE:n=255,e=0;break;case t.context.SHORT:n=32767.5,e=n-32768;break;case t.context.UNSIGNED_SHORT:n=65536,e=0;break;case t.context.INT:n=2147483647.5,e=n-2147483648;break;case t.context.UNSIGNED_INT:n=4294967295,e=0;case t.context.FLOAT:}return{shift:e,scale:n}},e.getOpenGLFilterMode=e=>{switch(e){case vd.NEAREST:return t.context.NEAREST;case vd.LINEAR:return t.context.LINEAR;case vd.NEAREST_MIPMAP_NEAREST:return t.context.NEAREST_MIPMAP_NEAREST;case vd.NEAREST_MIPMAP_LINEAR:return t.context.NEAREST_MIPMAP_LINEAR;case vd.LINEAR_MIPMAP_NEAREST:return t.context.LINEAR_MIPMAP_NEAREST;case vd.LINEAR_MIPMAP_LINEAR:return t.context.LINEAR_MIPMAP_LINEAR;default:return t.context.NEAREST}},e.getOpenGLWrapMode=e=>{switch(e){case hd.CLAMP_TO_EDGE:return t.context.CLAMP_TO_EDGE;case hd.REPEAT:return t.context.REPEAT;case hd.MIRRORED_REPEAT:return t.context.MIRRORED_REPEAT;default:return t.context.CLAMP_TO_EDGE}},e.updateArrayDataTypeForGL=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]&&arguments[2],o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[];const a=[];let s=t.width*t.height*t.components;r&&(s*=t.depth);const l=!!o.length;if(e!==Td.FLOAT&&t.openGLDataType===t.context.FLOAT)for(let e=0;e<n.length;e++)if(n[e])if(l)a.push(i(n[e],o,Float32Array));else{const t=n[e].length>s?n[e].subarray(0,s):n[e];a.push(new Float32Array(t))}else a.push(null);if(e!==Td.UNSIGNED_CHAR&&t.openGLDataType===t.context.UNSIGNED_BYTE)for(let e=0;e<n.length;e++)if(n[e])if(l)a.push(i(n[e],o,Uint8Array));else{const t=n[e].length>s?n[e].subarray(0,s):n[e];a.push(new Uint8Array(t))}else a.push(null);let c=!1;if(t._openGLRenderWindow.getWebgl2())c=t.openGLDataType===t.context.HALF_FLOAT;else{const e=t.context.getExtension(&quot;OES_texture_half_float&quot;);c=e&&t.openGLDataType===e.HALF_FLOAT_OES}if(c)for(let e=0;e<n.length;e++)if(n[e]){const t=l?i(n[e],o):n[e],r=new Uint16Array(l?t.length:s),c=r.length;for(let e=0;e<c;e++)r[e]=Sd(t[e]);a.push(r)}else a.push(null);if(0===a.length)for(let e=0;e<n.length;e++)a.push(l&&n[e]?i(n[e],o):n[e]);return a},e.create2DFromRaw=function(){let{width:n=Cd(&quot;width&quot;),height:o=Cd(&quot;height&quot;),numComps:a=Cd(&quot;numComps&quot;),dataType:i=Cd(&quot;dataType&quot;),data:c=Cd(&quot;data&quot;),flip:u=!1}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};if(e.getOpenGLDataType(i,!0),e.getInternalFormat(i,a),e.getFormat(i,a),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_2D,t.components=a,t.width=n,t.height=o,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind();const d=[c],p=s(e.updateArrayDataTypeForGL(i,d));return t.context.pixelStorei(t.context.UNPACK_FLIP_Y_WEBGL,u),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(i)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),null!=p[0]&&t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,p[0])):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,p[0]),t.generateMipmap&&t.context.generateMipmap(t.target),u&&t.context.pixelStorei(t.context.UNPACK_FLIP_Y_WEBGL,!1),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*a*t._openGLRenderWindow.getDefaultTextureByteSize(i,r(),e.useHalfFloat()),e.deactivate(),!0},e.createCubeFromRaw=function(){let{width:n=Cd(&quot;width&quot;),height:o=Cd(&quot;height&quot;),numComps:a=Cd(&quot;numComps&quot;),dataType:i=Cd(&quot;dataType&quot;),data:c=Cd(&quot;data&quot;)}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};if(e.getOpenGLDataType(i),e.getInternalFormat(i,a),e.getFormat(i,a),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_CUBE_MAP,t.components=a,t.width=n,t.height=o,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),t.maxLevel=c.length/6-1,e.createTexture(),e.bind();const u=s(e.updateArrayDataTypeForGL(i,c)),d=[];let p=t.width,f=t.height;for(let e=0;e<u.length;e++){e%6==0&&0!==e&&(p/=2,f/=2),d[e]=at(i,f*p*t.components);for(let n=0;n<f;++n){const r=n*p*t.components,o=(f-n-1)*p*t.components;d[e].set(u[e].slice(o,o+p*t.components),r)}}t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(i)&&t.context.texStorage2D(t.target,6,t.internalFormat,t.width,t.height);for(let e=0;e<6;e++){let n=0,r=t.width,o=t.height;for(;r>=1&&o>=1;){let a=null;n<=t.maxLevel&&(a=d[6*n+e]),l(i)?null!=a&&t.context.texSubImage2D(t.context.TEXTURE_CUBE_MAP_POSITIVE_X+e,n,0,0,r,o,t.format,t.openGLDataType,a):t.context.texImage2D(t.context.TEXTURE_CUBE_MAP_POSITIVE_X+e,n,t.internalFormat,r,o,0,t.format,t.openGLDataType,a),n++,r/=2,o/=2}}return t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*a*t._openGLRenderWindow.getDefaultTextureByteSize(i,r(),e.useHalfFloat()),e.deactivate(),!0},e.createDepthFromRaw=function(){let{width:n=Cd(&quot;width&quot;),height:o=Cd(&quot;height&quot;),dataType:a=Cd(&quot;dataType&quot;),data:i=Cd(&quot;data&quot;)}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};return e.getOpenGLDataType(a),t.format=t.context.DEPTH_COMPONENT,t._openGLRenderWindow.getWebgl2()?a===Td.FLOAT?t.internalFormat=t.context.DEPTH_COMPONENT32F:t.internalFormat=t.context.DEPTH_COMPONENT16:t.internalFormat=t.context.DEPTH_COMPONENT,t.internalFormat&&t.format&&t.openGLDataType?(t.target=t.context.TEXTURE_2D,t.components=1,t.width=n,t.height=o,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind(),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(a)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),null!=i&&t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,i)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,i),t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(a,r(),e.useHalfFloat()),e.deactivate(),!0):(bd(&quot;Failed to determine texture parameters.&quot;),!1)},e.create2DFromImage=n=>{if(e.getOpenGLDataType(Td.UNSIGNED_CHAR),e.getInternalFormat(Td.UNSIGNED_CHAR,4),e.getFormat(Td.UNSIGNED_CHAR,4),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_2D,t.components=4,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind();const o=!(t._openGLRenderWindow.getWebgl2()||Oo(n.width)&&Oo(n.height));let a=n,i=n.width,s=n.height,c=!0;const u=window.chrome;if(o||u){const e=new OffscreenCanvas(wo(n.width),wo(n.height));i=e.width,s=e.height;const t=e.getContext(&quot;2d&quot;);t.translate(0,e.height),t.scale(1,-1),t.drawImage(n,0,0,n.width,n.height,0,0,e.width,e.height),a=e,c=!1}return t.width=i,t.height=s,t.context.pixelStorei(t.context.UNPACK_FLIP_Y_WEBGL,c),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(Td.UNSIGNED_CHAR)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,a)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,a),t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(Td.UNSIGNED_CHAR,r(),e.useHalfFloat()),e.deactivate(),!0},e.create2DFromImageBitmap=n=>(e.getOpenGLDataType(Td.UNSIGNED_CHAR),e.getInternalFormat(Td.UNSIGNED_CHAR,4),e.getFormat(Td.UNSIGNED_CHAR,4),t.internalFormat&&t.format&&t.openGLDataType?(t.target=t.context.TEXTURE_2D,t.components=4,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind(),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),t.width=n.width,t.height=n.height,l(Td.UNSIGNED_CHAR)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,n)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,n),t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(Td.UNSIGNED_CHAR,r(),e.useHalfFloat()),e.deactivate(),!0):(bd(&quot;Failed to determine texture parameters.&quot;),!1)),e.create2DFilterableFromRaw=function(){let{width:t=Cd(&quot;width&quot;),height:n=Cd(&quot;height&quot;),numComps:r=Cd(&quot;numComps&quot;),dataType:o=Cd(&quot;dataType&quot;),data:a=Cd(&quot;data&quot;),preferSizeOverAccuracy:i=!1,ranges:s}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};return e.create2DFilterableFromDataArray({width:t,height:n,dataArray:xs.newInstance({numberOfComponents:r,dataType:o,values:a,ranges:s}),preferSizeOverAccuracy:i})},e.create2DFilterableFromDataArray=function(){let{width:t=Cd(&quot;width&quot;),height:n=Cd(&quot;height&quot;),dataArray:r=Cd(&quot;dataArray&quot;),preferSizeOverAccuracy:o=!1}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};const{numComps:a,dataType:i,data:s}=c(r,o);e.create2DFromRaw({width:t,height:n,numComps:a,dataType:i,data:s})},e.updateVolumeInfoForGL=(n,o)=>{let a=!1;const i=e.useHalfFloat();t.volumeInfo?.scale&&t.volumeInfo?.offset||(t.volumeInfo={scale:new Array(o),offset:new Array(o)});for(let e=0;e<o;++e)t.volumeInfo.scale[e]=1,t.volumeInfo.offset[e]=0;if(r()&&!i&&n===Td.SHORT){for(let e=0;e<o;++e)t.volumeInfo.scale[e]=32767;a=!0}if(r()&&!i&&n===Td.UNSIGNED_SHORT){for(let e=0;e<o;++e)t.volumeInfo.scale[e]=65535;a=!0}if(n===Td.UNSIGNED_CHAR){for(let e=0;e<o;++e)t.volumeInfo.scale[e]=255;a=!0}return(n===Td.FLOAT||i&&(n===Td.SHORT||n===Td.UNSIGNED_SHORT))&&(a=!0),a},e.create3DFromRaw=function(){let{width:i=Cd(&quot;width&quot;),height:c=Cd(&quot;height&quot;),depth:u=Cd(&quot;depth&quot;),numComps:d=Cd(&quot;numComps&quot;),dataType:p=Cd(&quot;dataType&quot;),data:f=Cd(&quot;data&quot;),updatedExtents:g=[]}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},m=p,h=f;if(!e.updateVolumeInfoForGL(m,d)&&h){const e=i*c*u,n=structuredClone(t.volumeInfo),r=new Float32Array(e*d);t.volumeInfo.offset=n.offset,t.volumeInfo.scale=n.scale;let o=0;const a=n.scale.map((e=>1/e));for(let t=0;t<e;t++)for(let e=0;e<d;e++)r[o]=(h[o]-n.offset[e])*a[e],o++;m=Td.FLOAT,h=r}if(e.getOpenGLDataType(m),e.getInternalFormat(m,d),e.getFormat(m,d),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_3D,t.components=d,t.width=i,t.height=c,t.depth=u,t.numberOfDimensions=3,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind();const v=g.length>0,T=!v||!ke(t._prevTexParams,n()),y=[h],b=s(e.updateArrayDataTypeForGL(m,y,!0,T?[]:g));if(t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),T)l(m)?(t.context.texStorage3D(t.target,1,t.internalFormat,t.width,t.height,t.depth),null!=b[0]&&t.context.texSubImage3D(t.target,0,0,0,0,t.width,t.height,t.depth,t.format,t.openGLDataType,b[0])):t.context.texImage3D(t.target,0,t.internalFormat,t.width,t.height,t.depth,0,t.format,t.openGLDataType,b[0]),t._prevTexParams=n();else if(v){const e=b[0];let n=0;for(let r=0;r<g.length;r++){const i=g[r],s=o(i),l=a(i),c=new e.constructor(e.buffer,n,l);n+=c.byteLength,t.context.texSubImage3D(t.target,0,i[0],i[2],i[4],s[0],s[1],s[2],t.format,t.openGLDataType,c)}}return t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(m,r(),e.useHalfFloat()),e.deactivate(),!0},e.create3DFilterableFromRaw=function(){let{width:t=Cd(&quot;width&quot;),height:n=Cd(&quot;height&quot;),depth:r=Cd(&quot;depth&quot;),numComps:o=Cd(&quot;numComps&quot;),dataType:a=Cd(&quot;dataType&quot;),data:i=Cd(&quot;data&quot;),preferSizeOverAccuracy:s=!1,ranges:l,updatedExtents:c=[]}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};return e.create3DFilterableFromDataArray({width:t,height:n,depth:r,dataArray:xs.newInstance({numberOfComponents:o,dataType:a,values:i,ranges:l}),preferSizeOverAccuracy:s,updatedExtents:c})},e.create3DFilterableFromDataArray=function(){let{width:n=Cd(&quot;width&quot;),height:r=Cd(&quot;height&quot;),depth:o=Cd(&quot;depth&quot;),dataArray:a=Cd(&quot;dataArray&quot;),preferSizeOverAccuracy:i=!1,updatedExtents:s=[]}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};const{numComps:u,dataType:d,data:p,scaleOffsets:f}=c(a,i),g=[],m=[];for(let e=0;e<u;++e)g[e]=0,m[e]=1;if(t.volumeInfo={scale:m,offset:g,dataComputedScale:f.scale,dataComputedOffset:f.offset,width:n,height:r,depth:o},t._openGLRenderWindow.getWebgl2())return e.create3DFromRaw({width:n,height:r,depth:o,numComps:u,dataType:d,data:p,updatedExtents:s});const h=n*r*o,v=structuredClone(f);let T=(e,t,n,r,o)=>{e[t]=n},y=Td.UNSIGNED_CHAR;if(d===Td.UNSIGNED_CHAR)for(let e=0;e<u;++e)v.offset[e]=0,v.scale[e]=255;else t.context.getExtension(&quot;OES_texture_float&quot;)&&t.context.getExtension(&quot;OES_texture_float_linear&quot;)?(y=Td.FLOAT,T=(e,t,n,r,o)=>{e[t]=(n-r)/o}):(y=Td.UNSIGNED_CHAR,T=(e,t,n,r,o)=>{e[t]=255*(n-r)/o});if(e.getOpenGLDataType(y),e.getInternalFormat(y,u),e.getFormat(y,u),!t.internalFormat||!t.format||!t.openGLDataType)return bd(&quot;Failed to determine texture parameters.&quot;),!1;t.target=t.context.TEXTURE_2D,t.components=u,t.depth=1,t.numberOfDimensions=2;let b=t.context.getParameter(t.context.MAX_TEXTURE_SIZE);b>4096&&(y===Td.FLOAT||u>=3)&&(b=4096);let x=1,C=1;h>b*b&&(x=Math.ceil(Math.sqrt(h/(b*b))),C=x);let S=Math.sqrt(h)/x;S=wo(S);const A=Math.floor(S*x/n),I=Math.ceil(o/A),w=wo(r*I/C);let O;t.width=S,t.height=w,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind(),t.volumeInfo.xreps=A,t.volumeInfo.yreps=I,t.volumeInfo.xstride=x,t.volumeInfo.ystride=C,t.volumeInfo.offset=v.offset,t.volumeInfo.scale=v.scale;const P=S*w*u;O=y===Td.FLOAT?new Float32Array(P):new Uint8Array(P);let R=0;const M=Math.floor(n/x),E=Math.floor(r/C);for(let e=0;e<I;e++){const a=Math.min(A,o-e*A),i=u*(t.width-a*Math.floor(n/x));for(let t=0;t<E;t++){for(let o=0;o<a;o++){const a=u*((e*A+o)*n*r+C*t*n);for(let e=0;e<M;e++)for(let t=0;t<u;t++)T(O,R,p[a+x*e*u+t],v.offset[t],v.scale[t]),R++}R+=i}}return t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),l(y)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),null!=O&&t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,O)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,O),e.deactivate(),!0},e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))},e.getMaximumTextureSize=e=>e&&e.isCurrent()?e.getIntegerv(e.MAX_TEXTURE_SIZE):-1,e.enableUseHalfFloat=e=>{t.enableUseHalfFloat=e}}const Id={_openGLRenderWindow:null,_forceInternalFormat:!1,_prevTexParams:null,context:null,handle:0,sendParametersTime:null,textureBuildTime:null,numberOfDimensions:0,target:0,format:0,openGLDataType:0,components:0,width:0,height:0,depth:0,autoParameters:!0,wrapS:hd.CLAMP_TO_EDGE,wrapT:hd.CLAMP_TO_EDGE,wrapR:hd.CLAMP_TO_EDGE,minificationFilter:vd.NEAREST,magnificationFilter:vd.NEAREST,minLOD:-1e3,maxLOD:1e3,baseLevel:0,maxLevel:1e3,generateMipmap:!1,oglNorm16Ext:null,allocatedGPUMemoryInBytes:0,enableUseHalfFloat:!0,canUseHalfFloat:!1};function wd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Id,n),qt.extend(e,t,n),t.sendParametersTime={},ht(t.sendParametersTime,{mtime:0}),t.textureBuildTime={},ht(t.textureBuildTime,{mtime:0}),xt(e,t,[&quot;format&quot;,&quot;openGLDataType&quot;]),Ct(e,t,[&quot;keyMatrixTime&quot;,&quot;minificationFilter&quot;,&quot;magnificationFilter&quot;,&quot;wrapS&quot;,&quot;wrapT&quot;,&quot;wrapR&quot;,&quot;generateMipmap&quot;,&quot;oglNorm16Ext&quot;]),Tt(e,t,[&quot;width&quot;,&quot;height&quot;,&quot;volumeInfo&quot;,&quot;components&quot;,&quot;handle&quot;,&quot;target&quot;,&quot;allocatedGPUMemoryInBytes&quot;]),wt(0,t,[&quot;openGLRenderWindow&quot;]),Ad(e,t)}const Od=Mt(wd,&quot;vtkOpenGLTexture&quot;);var Pd={newInstance:Od,extend:wd,...dd};Jt(&quot;vtkTexture&quot;,Od);var Rd=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkPolyDataVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\nattribute vec4 vertexMC;\\n\\n// frag position in VC\\n//VTK::PositionVC::Dec\\n\\n// optional normal declaration\\n//VTK::Normal::Dec\\n\\n// extra lighting parameters\\n//VTK::Light::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// material property values\\n//VTK::Color::Dec\\n\\n// clipping plane vars\\n//VTK::Clip::Dec\\n\\n// camera and actor matrix values\\n//VTK::Camera::Dec\\n\\n// Apple Bug\\n//VTK::PrimID::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\nvoid main()\\n{\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Clip::Impl\\n\\n  //VTK::PrimID::Impl\\n\\n  //VTK::PositionVC::Impl\\n\\n  //VTK::Light::Impl\\n\\n  //VTK::Picking::Impl\\n}\\n&quot;,Md=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkPolyDataFS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// Template for the polydata mappers fragment shader\\n\\nuniform int PrimitiveIDOffset;\\n\\n// VC position of this fragment\\n//VTK::PositionVC::Dec\\n\\n// optional color passed in from the vertex shader, vertexColor\\n//VTK::Color::Dec\\n\\n// optional surface normal declaration\\n//VTK::Normal::Dec\\n\\n// extra lighting parameters\\n//VTK::Light::Dec\\n\\n// define vtkImageLabelOutlineOn\\n//VTK::ImageLabelOutlineOn\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\n// Depth Peeling Support\\n//VTK::DepthPeeling::Dec\\n\\n// clipping plane vars\\n//VTK::Clip::Dec\\n\\n// label outline \\n//VTK::LabelOutline::Dec\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\n// Apple Bug\\n//VTK::PrimID::Dec\\n\\n// handle coincident offsets\\n//VTK::Coincident::Dec\\n\\n//VTK::ZBuffer::Dec\\n\\n//VTK::LabelOutlineHelperFunction\\n\\nvoid main()\\n{\\n  // VC position of this fragment. This should not branch/return/discard.\\n  //VTK::PositionVC::Impl\\n\\n  // Place any calls that require uniform flow (e.g. dFdx) here.\\n  //VTK::UniformFlow::Impl\\n\\n  // Set gl_FragDepth here (gl_FragCoord.z by default)\\n  //VTK::Depth::Impl\\n\\n  // Early depth peeling abort:\\n  //VTK::DepthPeeling::PreColor\\n\\n  // Apple Bug\\n  //VTK::PrimID::Impl\\n\\n  //VTK::Clip::Impl\\n\\n  //VTK::Color::Impl\\n\\n  // Generate the normal if we are not passed in one\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Light::Impl\\n\\n  if (gl_FragData[0].a <= 0.0)\\n    {\\n    discard;\\n    }\\n\\n  //VTK::DepthPeeling::Impl\\n\\n  //VTK::Picking::Impl\\n\\n  // handle coincident offsets\\n  //VTK::Coincident::Impl\\n\\n  //VTK::ZBuffer::Impl\\n\\n  //VTK::RenderPassFragmentShader::Impl\\n}\\n&quot;,Ed=function(e,t){e.replaceShaderCoincidentOffset=(n,r,o)=>{const a=e.getCoincidentParameters(r,o);if(a&&(0!==a.factor||0!==a.offset)){let e=n.Fragment;e=td.substitute(e,&quot;//VTK::Coincident::Dec&quot;,[&quot;uniform float cfactor;&quot;,&quot;uniform float coffset;&quot;]).result,t.context.getExtension(&quot;EXT_frag_depth&quot;)&&(0!==a.factor?(e=td.substitute(e,&quot;//VTK::UniformFlow::Impl&quot;,[&quot;float cscale = length(vec2(dFdx(gl_FragCoord.z),dFdy(gl_FragCoord.z)));&quot;,&quot;//VTK::UniformFlow::Impl&quot;],!1).result,e=td.substitute(e,&quot;//VTK::Depth::Impl&quot;,&quot;gl_FragDepthEXT = gl_FragCoord.z + cfactor*cscale + 0.000016*coffset;&quot;).result):e=td.substitute(e,&quot;//VTK::Depth::Impl&quot;,&quot;gl_FragDepthEXT = gl_FragCoord.z + 0.000016*coffset;&quot;).result),t._openGLRenderWindow.getWebgl2()&&(0!==a.factor?(e=td.substitute(e,&quot;//VTK::UniformFlow::Impl&quot;,[&quot;float cscale = length(vec2(dFdx(gl_FragCoord.z),dFdy(gl_FragCoord.z)));&quot;,&quot;//VTK::UniformFlow::Impl&quot;],!1).result,e=td.substitute(e,&quot;//VTK::Depth::Impl&quot;,&quot;gl_FragDepth = gl_FragCoord.z + cfactor*cscale + 0.000016*coffset;&quot;).result):e=td.substitute(e,&quot;//VTK::Depth::Impl&quot;,&quot;gl_FragDepth = gl_FragCoord.z + 0.000016*coffset;&quot;).result),n.Fragment=e}}},Vd=function(e,t){e.applyShaderReplacements=(e,t,n)=>{let r=null;if(t&&(r=t.ShaderReplacements),r)for(let t=0;t<r.length;t++){const o=r[t];if(n&&o.replaceFirst||!n&&!o.replaceFirst){const t=o.shaderType,n=e[t],r=td.substitute(n,o.originalValue,o.replacementValue,o.replaceAll);e[t]=r.result}}},e.buildShaders=(n,r,o)=>{e.getReplacedShaderTemplate(n,r,o),t.lastRenderPassShaderReplacement=t.currentRenderPass?t.currentRenderPass.getShaderReplacement():null,t.lastRenderPassShaderReplacement&&t.lastRenderPassShaderReplacement(n);const a=t.renderable.getViewSpecificProperties().OpenGL;e.applyShaderReplacements(n,a,!0),e.replaceShaderValues(n,r,o),e.applyShaderReplacements(n,a)},e.getReplacedShaderTemplate=(n,r,o)=>{const a=t.renderable.getViewSpecificProperties().OpenGL;e.getShaderTemplate(n,r,o);let i=n.Vertex;if(a){const e=a.VertexShaderCode;void 0!==e&&&quot;&quot;!==e&&(i=e)}n.Vertex=i;let s=n.Fragment;if(a){const e=a.FragmentShaderCode;void 0!==e&&&quot;&quot;!==e&&(s=e)}n.Fragment=s;let l=n.Geometry;if(a){const e=a.GeometryShaderCode;void 0!==e&&(l=e)}n.Geometry=l}};const{FieldAssociations:Dd}=Us,{primTypes:Ld}=ld,{Representation:Bd,Shading:Nd}=os,{ScalarMode:Fd}=Gl,{Filter:_d,Wrap:kd}=Pd,{vtkErrorMacro:Gd}=Ht,Ud={type:&quot;StartEvent&quot;},zd={type:&quot;EndEvent&quot;},{CoordinateSystem:Wd}=Ki;const Hd={context:null,VBOBuildTime:0,VBOBuildString:null,primitives:null,primTypes:null,shaderRebuildString:null,tmpMat4:null,ambientColor:[],diffuseColor:[],specularColor:[],lightColor:[],lightDirection:[],lastHaveSeenDepthRequest:!1,haveSeenDepthRequest:!1,lastSelectionState:Al.MIN_KNOWN_PASS-1,selectionStateChanged:null,selectionWebGLIdsToVTKIds:null,pointPicking:!1};function jd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Hd,n),qt.extend(e,t,n),Ed(e,t,n),Vd(e,t,n),t.primitives=[],t.primTypes=Ld,t.tmpMat3=fe(new Float64Array(9)),t.tmpMat4=m(new Float64Array(16));for(let e=Ld.Start;e<Ld.End;e++)t.primitives[e]=ld.newInstance(),t.primitives[e].setPrimitiveType(e),t.primitives[e].set({lastLightComplexity:0,lastLightCount:0,lastSelectionPass:!1},!0);Ct(e,t,[&quot;context&quot;]),t.VBOBuildTime={},ht(t.VBOBuildTime,{mtime:0}),t.selectionStateChanged={},ht(t.selectionStateChanged,{mtime:0}),function(e,t){function n(e,t,n){return t.identity(n),e.reduce(((e,n,r)=>0===r?n?t.copy(e,n):t.identity(e):n?t.multiply(e,e,n):e),n)}t.classHierarchy.push(&quot;vtkOpenGLPolyDataMapper&quot;),e.buildPass=n=>{n&&(t.currentRenderPass=null,t.openGLActor=e.getFirstAncestorOfType(&quot;vtkOpenGLActor&quot;),t._openGLRenderer=t.openGLActor.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t.openGLCamera=t._openGLRenderer.getViewNodeFor(t._openGLRenderer.getRenderable().getActiveCamera()))},e.translucentPass=(n,r)=>{n&&(t.currentRenderPass=r,e.render())},e.zBufferPass=n=>{n&&(t.haveSeenDepthRequest=!0,t.renderDepth=!0,e.render(),t.renderDepth=!1)},e.opaqueZBufferPass=t=>e.zBufferPass(t),e.opaquePass=t=>{t&&e.render()},e.render=()=>{const n=t._openGLRenderWindow.getContext();if(t.context!==n){t.context=n;for(let e=Ld.Start;e<Ld.End;e++)t.primitives[e].setOpenGLRenderWindow(t._openGLRenderWindow)}const r=t.openGLActor.getRenderable(),o=t._openGLRenderer.getRenderable();e.renderPiece(o,r)},e.getShaderTemplate=(e,t,n)=>{e.Vertex=Rd,e.Fragment=Md,e.Geometry=&quot;&quot;},e.replaceShaderColor=(e,n,r)=>{let o=e.Vertex,a=e.Geometry,i=e.Fragment;const s=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);let l=[&quot;uniform float ambient;&quot;,&quot;uniform float diffuse;&quot;,&quot;uniform float specular;&quot;,&quot;uniform float opacityUniform; // the fragment opacity&quot;,&quot;uniform vec3 ambientColorUniform;&quot;,&quot;uniform vec3 diffuseColorUniform;&quot;];s&&(l=l.concat([&quot;uniform vec3 specularColorUniform;&quot;,&quot;uniform float specularPowerUniform;&quot;]));let c=[&quot;vec3 ambientColor;&quot;,&quot;  vec3 diffuseColor;&quot;,&quot;  float opacity;&quot;];s&&(c=c.concat([&quot;  vec3 specularColor;&quot;,&quot;  float specularPower;&quot;])),c=c.concat([&quot;  ambientColor = ambientColorUniform;&quot;,&quot;  diffuseColor = diffuseColorUniform;&quot;,&quot;  opacity = opacityUniform;&quot;]),s&&(c=c.concat([&quot;  specularColor = specularColorUniform;&quot;,&quot;  specularPower = specularPowerUniform;&quot;])),0===t.lastBoundBO.getCABO().getColorComponents()||t.drawingEdges||(l=l.concat([&quot;varying vec4 vertexColorVSOutput;&quot;]),o=td.substitute(o,&quot;//VTK::Color::Dec&quot;,[&quot;attribute vec4 scalarColor;&quot;,&quot;varying vec4 vertexColorVSOutput;&quot;]).result,o=td.substitute(o,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorVSOutput =  scalarColor;&quot;]).result,a=td.substitute(a,&quot;//VTK::Color::Dec&quot;,[&quot;in vec4 vertexColorVSOutput[];&quot;,&quot;out vec4 vertexColorGSOutput;&quot;]).result,a=td.substitute(a,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorGSOutput = vertexColorVSOutput[i];&quot;]).result),0===t.lastBoundBO.getCABO().getColorComponents()||t.drawingEdges?(t.renderable.getAreScalarsMappedFromCells()||t.renderable.getInterpolateScalarsBeforeMapping())&&t.renderable.getColorCoordinates()&&!t.drawingEdges?i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,c.concat([&quot;  vec4 texColor = texture2D(texture1, tcoordVCVSOutput.st);&quot;,&quot;  diffuseColor = texColor.rgb;&quot;,&quot;  ambientColor = texColor.rgb;&quot;,&quot;  opacity = opacity*texColor.a;&quot;])).result:(r.getBackfaceProperty()&&!t.drawingEdges&&(l=l.concat([&quot;uniform float opacityUniformBF; // the fragment opacity&quot;,&quot;uniform float ambientIntensityBF; // the material ambient&quot;,&quot;uniform float diffuseIntensityBF; // the material diffuse&quot;,&quot;uniform vec3 ambientColorUniformBF; // ambient material color&quot;,&quot;uniform vec3 diffuseColorUniformBF; // diffuse material color&quot;]),s?(l=l.concat([&quot;uniform float specularIntensityBF; // the material specular intensity&quot;,&quot;uniform vec3 specularColorUniformBF; // intensity weighted color&quot;,&quot;uniform float specularPowerUniformBF;&quot;]),c=c.concat([&quot;if (gl_FrontFacing == false) {&quot;,&quot;  ambientColor = ambientIntensityBF * ambientColorUniformBF;&quot;,&quot;  diffuseColor = diffuseIntensityBF * diffuseColorUniformBF;&quot;,&quot;  specularColor = specularIntensityBF * specularColorUniformBF;&quot;,&quot;  specularPower = specularPowerUniformBF;&quot;,&quot;  opacity = opacityUniformBF; }&quot;])):c=c.concat([&quot;if (gl_FrontFacing == false) {&quot;,&quot;  ambientColor = ambientIntensityBF * ambientColorUniformBF;&quot;,&quot;  diffuseColor = diffuseIntensityBF * diffuseColorUniformBF;&quot;,&quot;  opacity = opacityUniformBF; }&quot;])),t.haveCellScalars&&!t.drawingEdges&&(l=l.concat([&quot;uniform samplerBuffer texture1;&quot;])),i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,c).result):i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,c.concat([&quot;  diffuseColor = vertexColorVSOutput.rgb;&quot;,&quot;  ambientColor = vertexColorVSOutput.rgb;&quot;,&quot;  opacity = opacity*vertexColorVSOutput.a;&quot;])).result,i=td.substitute(i,&quot;//VTK::Color::Dec&quot;,l).result,e.Vertex=o,e.Geometry=a,e.Fragment=i},e.replaceShaderLight=(e,n,r)=>{let o=e.Fragment;const a=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;),i=t.lastBoundBO.getReferenceByName(&quot;lastLightCount&quot;);let s=[];switch(a){case 0:o=td.substitute(o,&quot;//VTK::Light::Impl&quot;,[&quot;  gl_FragData[0] = vec4(ambientColor * ambient + diffuseColor * diffuse, opacity);&quot;,&quot;  //VTK::Light::Impl&quot;],!1).result;break;case 1:o=td.substitute(o,&quot;//VTK::Light::Impl&quot;,[&quot;  float df = max(0.0, normalVCVSOutput.z);&quot;,&quot;  float sf = pow(df, specularPower);&quot;,&quot;  vec3 diffuseL = df * diffuseColor;&quot;,&quot;  vec3 specularL = sf * specularColor;&quot;,&quot;  gl_FragData[0] = vec4(ambientColor * ambient + diffuseL * diffuse + specularL * specular, opacity);&quot;,&quot;  //VTK::Light::Impl&quot;],!1).result;break;case 2:for(let e=0;e<i;++e)s=s.concat([`uniform vec3 lightColor${e};`,`uniform vec3 lightDirectionVC${e}; // normalized`,`uniform vec3 lightHalfAngleVC${e}; // normalized`]);o=td.substitute(o,&quot;//VTK::Light::Dec&quot;,s).result,s=[&quot;vec3 diffuseL = vec3(0,0,0);&quot;,&quot;  vec3 specularL = vec3(0,0,0);&quot;,&quot;  float df;&quot;];for(let e=0;e<i;++e)s=s.concat([`  df = max(0.0, dot(normalVCVSOutput, -lightDirectionVC${e}));`,`  diffuseL += ((df) * lightColor${e});`,`  if (dot(normalVCVSOutput, lightDirectionVC${e}) < 0.0)`,&quot;    {&quot;,`    float sf = sign(df)*pow(max(1e-5,\\n                                              dot(reflect(lightDirectionVC${e},normalVCVSOutput),\\n                                                  normalize(-vertexVC.xyz))),\\n                                         specularPower);`,`    specularL += (sf * lightColor${e});`,&quot;    }&quot;]);s=s.concat([&quot;  diffuseL = diffuseL * diffuseColor;&quot;,&quot;  specularL = specularL * specularColor;&quot;,&quot;  gl_FragData[0] = vec4(ambientColor * ambient + diffuseL * diffuse + specularL * specular, opacity);&quot;,&quot;  //VTK::Light::Impl&quot;]),o=td.substitute(o,&quot;//VTK::Light::Impl&quot;,s,!1).result;break;case 3:for(let e=0;e<i;++e)s=s.concat([`uniform vec3 lightColor${e};`,`uniform vec3 lightDirectionVC${e}; // normalized`,`uniform vec3 lightHalfAngleVC${e}; // normalized`,`uniform vec3 lightPositionVC${e};`,`uniform vec3 lightAttenuation${e};`,`uniform float lightConeAngle${e};`,`uniform float lightExponent${e};`,`uniform int lightPositional${e};`]);o=td.substitute(o,&quot;//VTK::Light::Dec&quot;,s).result,s=[&quot;vec3 diffuseL = vec3(0,0,0);&quot;,&quot;  vec3 specularL = vec3(0,0,0);&quot;,&quot;  vec3 vertLightDirectionVC;&quot;,&quot;  float attenuation;&quot;,&quot;  float df;&quot;];for(let e=0;e<i;++e)s=s.concat([&quot;  attenuation = 1.0;&quot;,`  if (lightPositional${e} == 0)`,&quot;    {&quot;,`      vertLightDirectionVC = lightDirectionVC${e};`,&quot;    }&quot;,&quot;  else&quot;,&quot;    {&quot;,`    vertLightDirectionVC = vertexVC.xyz - lightPositionVC${e};`,&quot;    float distanceVC = length(vertLightDirectionVC);&quot;,&quot;    vertLightDirectionVC = normalize(vertLightDirectionVC);&quot;,&quot;    attenuation = 1.0 /&quot;,`      (lightAttenuation${e}.x`,`       + lightAttenuation${e}.y * distanceVC`,`       + lightAttenuation${e}.z * distanceVC * distanceVC);`,&quot;    // per OpenGL standard cone angle is 90 or less for a spot light&quot;,`    if (lightConeAngle${e} <= 90.0)`,&quot;      {&quot;,`      float coneDot = dot(vertLightDirectionVC, lightDirectionVC${e});`,&quot;      // if inside the cone&quot;,`      if (coneDot >= cos(radians(lightConeAngle${e})))`,&quot;        {&quot;,`        attenuation = attenuation * pow(coneDot, lightExponent${e});`,&quot;        }&quot;,&quot;      else&quot;,&quot;        {&quot;,&quot;        attenuation = 0.0;&quot;,&quot;        }&quot;,&quot;      }&quot;,&quot;    }&quot;,&quot;    df = max(0.0, attenuation*dot(normalVCVSOutput, -vertLightDirectionVC));&quot;,`    diffuseL += ((df) * lightColor${e});`,&quot;    if (dot(normalVCVSOutput, vertLightDirectionVC) < 0.0)&quot;,&quot;      {&quot;,`      float sf = sign(df)*attenuation*pow(max(1e-5,\\n                                                           dot(reflect(lightDirectionVC${e},\\n                                                                       normalVCVSOutput),\\n                                                               normalize(-vertexVC.xyz))),\\n                                                       specularPower);`,`    specularL += ((sf) * lightColor${e});`,&quot;    }&quot;]);s=s.concat([&quot;  diffuseL = diffuseL * diffuseColor;&quot;,&quot;  specularL = specularL * specularColor;&quot;,&quot;  gl_FragData[0] = vec4(ambientColor * ambient + diffuseL * diffuse + specularL * specular, opacity);&quot;,&quot;  //VTK::Light::Impl&quot;]),o=td.substitute(o,&quot;//VTK::Light::Impl&quot;,s,!1).result;break;default:Gd(&quot;bad light complexity&quot;)}e.Fragment=o},e.replaceShaderNormal=(e,n,r)=>{if(t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;)>0){let n=e.Vertex,o=e.Geometry,a=e.Fragment;t.lastBoundBO.getCABO().getNormalOffset()?(n=td.substitute(n,&quot;//VTK::Normal::Dec&quot;,[&quot;attribute vec3 normalMC;&quot;,&quot;uniform mat3 normalMatrix;&quot;,&quot;varying vec3 normalVCVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::Normal::Impl&quot;,[&quot;normalVCVSOutput = normalMatrix * normalMC;&quot;]).result,o=td.substitute(o,&quot;//VTK::Normal::Dec&quot;,[&quot;in vec3 normalVCVSOutput[];&quot;,&quot;out vec3 normalVCGSOutput;&quot;]).result,o=td.substitute(o,&quot;//VTK::Normal::Impl&quot;,[&quot;normalVCGSOutput = normalVCVSOutput[i];&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Dec&quot;,[&quot;varying vec3 normalVCVSOutput;&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Impl&quot;,[&quot;vec3 normalVCVSOutput = normalize(normalVCVSOutput);&quot;,&quot;  if (gl_FrontFacing == false) { normalVCVSOutput = -normalVCVSOutput; }&quot;]).result):t.haveCellNormals?(a=td.substitute(a,&quot;//VTK::Normal::Dec&quot;,[&quot;uniform mat3 normalMatrix;&quot;,&quot;uniform samplerBuffer textureN;&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Impl&quot;,[&quot;vec3 normalVCVSOutput = normalize(normalMatrix *&quot;,&quot;    texelFetchBuffer(textureN, gl_PrimitiveID + PrimitiveIDOffset).xyz);&quot;,&quot;  if (gl_FrontFacing == false) { normalVCVSOutput = -normalVCVSOutput; }&quot;]).result):t.lastBoundBO.getOpenGLMode(r.getProperty().getRepresentation())===t.context.LINES?(a=td.substitute(a,&quot;//VTK::UniformFlow::Impl&quot;,[&quot;  vec3 fdx = dFdx(vertexVC.xyz);&quot;,&quot;  vec3 fdy = dFdy(vertexVC.xyz);&quot;,&quot;  //VTK::UniformFlow::Impl&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Impl&quot;,[&quot;vec3 normalVCVSOutput;&quot;,&quot;  if (abs(fdx.x) > 0.0)&quot;,&quot;    { fdx = normalize(fdx); normalVCVSOutput = normalize(cross(vec3(fdx.y, -fdx.x, 0.0), fdx)); }&quot;,&quot;  else { fdy = normalize(fdy); normalVCVSOutput = normalize(cross(vec3(fdy.y, -fdy.x, 0.0), fdy));}&quot;]).result):(a=td.substitute(a,&quot;//VTK::Normal::Dec&quot;,[&quot;uniform int cameraParallel;&quot;]).result,a=td.substitute(a,&quot;//VTK::UniformFlow::Impl&quot;,[&quot;  vec3 fdx = dFdx(vertexVC.xyz);&quot;,&quot;  vec3 fdy = dFdy(vertexVC.xyz);&quot;,&quot;  //VTK::UniformFlow::Impl&quot;]).result,a=td.substitute(a,&quot;//VTK::Normal::Impl&quot;,[&quot;  fdx = normalize(fdx);&quot;,&quot;  fdy = normalize(fdy);&quot;,&quot;  vec3 normalVCVSOutput = normalize(cross(fdx,fdy));&quot;,&quot;  if (cameraParallel == 1 && normalVCVSOutput.z < 0.0) { normalVCVSOutput = -1.0*normalVCVSOutput; }&quot;,&quot;  if (cameraParallel == 0 && dot(normalVCVSOutput,vertexVC.xyz) > 0.0) { normalVCVSOutput = -1.0*normalVCVSOutput; }&quot;]).result),e.Vertex=n,e.Geometry=o,e.Fragment=a}},e.replaceShaderPositionVC=(e,n,r)=>{t.lastBoundBO.replaceShaderPositionVC(e,n,r);let o=e.Vertex,a=e.Geometry,i=e.Fragment;t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;)>0?(o=td.substitute(o,&quot;//VTK::PositionVC::Dec&quot;,[&quot;varying vec4 vertexVCVSOutput;&quot;]).result,o=td.substitute(o,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vertexVCVSOutput = MCVCMatrix * vertexMC;&quot;,&quot;  gl_Position = MCPCMatrix * vertexMC;&quot;]).result,o=td.substitute(o,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Dec&quot;,[&quot;in vec4 vertexVCVSOutput[];&quot;,&quot;out vec4 vertexVCGSOutput;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vertexVCGSOutput = vertexVCVSOutput[i];&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Dec&quot;,[&quot;varying vec4 vertexVCVSOutput;&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vec4 vertexVC = vertexVCVSOutput;&quot;]).result):(o=td.substitute(o,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;]).result,o=td.substitute(o,&quot;//VTK::PositionVC::Impl&quot;,[&quot;  gl_Position = MCPCMatrix * vertexMC;&quot;]).result),e.Vertex=o,e.Geometry=a,e.Fragment=i},e.replaceShaderTCoord=(e,n,r)=>{if(t.lastBoundBO.getCABO().getTCoordOffset()){let n=e.Vertex,r=e.Geometry,o=e.Fragment;if(t.drawingEdges)return;n=td.substitute(n,&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCVSOutput = tcoordMC;&quot;).result;const a=t.openGLActor.getActiveTextures();let i=2,s=2;if(a&&a.length>0&&(i=a[0].getComponents(),a[0].getTarget()===t.context.TEXTURE_CUBE_MAP&&(s=3)),t.renderable.getColorTextureMap()&&(i=t.renderable.getColorTextureMap().getPointData().getScalars().getNumberOfComponents(),s=2),2===s){if(n=td.substitute(n,&quot;//VTK::TCoord::Dec&quot;,&quot;attribute vec2 tcoordMC; varying vec2 tcoordVCVSOutput;&quot;).result,r=td.substitute(r,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec2 tcoordVCVSOutput[];&quot;,&quot;out vec2 tcoordVCGSOutput;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCGSOutput = tcoordVCVSOutput[i];&quot;).result,o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;varying vec2 tcoordVCVSOutput;&quot;,&quot;uniform sampler2D texture1;&quot;]).result,a&&a.length>=1)switch(i){case 1:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.r;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.r;&quot;]).result;break;case 2:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.r;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.r;&quot;,&quot;  opacity = opacity * tcolor.g;&quot;]).result;break;default:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.rgb;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.rgb;&quot;,&quot;  opacity = opacity * tcolor.a;&quot;]).result}}else switch(n=td.substitute(n,&quot;//VTK::TCoord::Dec&quot;,&quot;attribute vec3 tcoordMC; varying vec3 tcoordVCVSOutput;&quot;).result,r=td.substitute(r,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec3 tcoordVCVSOutput[];&quot;,&quot;out vec3 tcoordVCGSOutput;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCGSOutput = tcoordVCVSOutput[i];&quot;).result,o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;varying vec3 tcoordVCVSOutput;&quot;,&quot;uniform samplerCube texture1;&quot;]).result,i){case 1:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.r;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.r;&quot;]).result;break;case 2:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.r;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.r;&quot;,&quot;  opacity = opacity * tcolor.g;&quot;]).result;break;default:o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);&quot;,&quot;  ambientColor = ambientColor*tcolor.rgb;&quot;,&quot;  diffuseColor = diffuseColor*tcolor.rgb;&quot;,&quot;  opacity = opacity * tcolor.a;&quot;]).result}e.Vertex=n,e.Geometry=r,e.Fragment=o}},e.replaceShaderClip=(e,n,r)=>{let o=e.Vertex,a=e.Fragment;if(t.renderable.getNumberOfClippingPlanes()){const e=t.renderable.getNumberOfClippingPlanes();o=td.substitute(o,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,`uniform vec4 clipPlanes[${e}];`,`varying float clipDistancesVSOutput[${e}];`]).result,o=td.substitute(o,&quot;//VTK::Clip::Impl&quot;,[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], vertexMC);&quot;,&quot;    }&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,`varying float clipDistancesVSOutput[${e}];`]).result,a=td.substitute(a,&quot;//VTK::Clip::Impl&quot;,[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    if (clipDistancesVSOutput[planeNum] < 0.0) discard;&quot;,&quot;    }&quot;]).result}e.Vertex=o,e.Fragment=a},e.getCoincidentParameters=(e,n)=>{let r={factor:0,offset:0};const o=n.getProperty();if(t.renderable.getResolveCoincidentTopology()==gl.PolygonOffset||o.getEdgeVisibility()&&o.getRepresentation()===Bd.SURFACE){const e=t.lastBoundBO.getPrimitiveType();e===Ld.Points||o.getRepresentation()===Bd.POINTS?r=t.renderable.getCoincidentTopologyPointOffsetParameter():e===Ld.Lines||o.getRepresentation()===Bd.WIREFRAME?r=t.renderable.getCoincidentTopologyLineOffsetParameters():e!==Ld.Tris&&e!==Ld.TriStrips||(r=t.renderable.getCoincidentTopologyPolygonOffsetParameters()),e!==Ld.TrisEdges&&e!==Ld.TriStripsEdges||(r=t.renderable.getCoincidentTopologyPolygonOffsetParameters(),r.factor/=2,r.offset/=2)}const a=t._openGLRenderer.getSelector();return a&&a.getFieldAssociation()===Dd.FIELD_ASSOCIATION_POINTS&&(r.offset-=2),r},e.replaceShaderPicking=(e,n,r)=>{let o=e.Fragment,a=e.Vertex;if(o=td.substitute(o,&quot;//VTK::Picking::Dec&quot;,[&quot;uniform int picking;&quot;,&quot;//VTK::Picking::Dec&quot;]).result,t._openGLRenderer.getSelector()){switch(t.lastSelectionState!==Al.ID_LOW24&&t.lastSelectionState!==Al.ID_HIGH24||(a=td.substitute(a,&quot;//VTK::Picking::Dec&quot;,[&quot;flat out int vertexIDVSOutput;\\n&quot;,&quot;uniform int VertexIDOffset;\\n&quot;]).result,a=td.substitute(a,&quot;//VTK::Picking::Impl&quot;,&quot;  vertexIDVSOutput = gl_VertexID + VertexIDOffset;\\n&quot;).result,o=td.substitute(o,&quot;//VTK::Picking::Dec&quot;,&quot;flat in int vertexIDVSOutput;\\n&quot;).result,o=td.substitute(o,&quot;//VTK::Picking::Impl&quot;,[&quot;  int idx = vertexIDVSOutput;&quot;,&quot;//VTK::Picking::Impl&quot;]).result),t.lastSelectionState){case Al.ID_LOW24:o=td.substitute(o,&quot;//VTK::Picking::Impl&quot;,&quot;  gl_FragData[0] = vec4(float(idx%256)/255.0, float((idx/256)%256)/255.0, float((idx/65536)%256)/255.0, 1.0);&quot;).result;break;case Al.ID_HIGH24:o=td.substitute(o,&quot;//VTK::Picking::Impl&quot;,&quot;  gl_FragData[0] = vec4(float((idx/16777216)%256)/255.0, 0.0, 0.0, 1.0);&quot;).result;break;default:o=td.substitute(o,&quot;//VTK::Picking::Dec&quot;,&quot;uniform vec3 mapperIndex;&quot;).result,o=td.substitute(o,&quot;//VTK::Picking::Impl&quot;,&quot;  gl_FragData[0] = picking != 0 ? vec4(mapperIndex,1.0) : gl_FragData[0];&quot;).result}e.Fragment=o,e.Vertex=a}},e.replaceShaderValues=(n,r,o)=>{if(e.replaceShaderColor(n,r,o),e.replaceShaderNormal(n,r,o),e.replaceShaderLight(n,r,o),e.replaceShaderTCoord(n,r,o),e.replaceShaderPicking(n,r,o),e.replaceShaderClip(n,r,o),e.replaceShaderCoincidentOffset(n,r,o),e.replaceShaderPositionVC(n,r,o),t.haveSeenDepthRequest){let e=n.Fragment;e=td.substitute(e,&quot;//VTK::ZBuffer::Dec&quot;,&quot;uniform int depthRequest;&quot;).result,e=td.substitute(e,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float iz = floor(gl_FragCoord.z*65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result,n.Fragment=e}},e.getNeedToRebuildShaders=(e,n,r)=>{let o=0,a=0;const i=e.getPrimitiveType(),s=t.currentInput;let l=!1;const c=s.getPointData().getNormals(),u=s.getCellData().getNormals(),d=r.getProperty().getInterpolation()===Nd.FLAT,p=r.getProperty().getRepresentation(),f=e.getOpenGLMode(p,i);if(f===t.context.TRIANGLES||u&&!c||!d&&c?l=!0:d||f!==t.context.LINES||(l=!0),r.getProperty().getLighting()&&l){o=0;const e=n.getLightsByReference();for(let t=0;t<e.length;++t){const n=e[t];n.getSwitch()>0&&(a++,0===o&&(o=1)),1===o&&(a>1||1!==n.getIntensity()||!n.lightTypeIsHeadLight())&&(o=2),o<3&&n.getPositional()&&(o=3)}}let g=!1;const m=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;),h=t.lastBoundBO.getReferenceByName(&quot;lastLightCount&quot;);return m===o&&h===a||(t.lastBoundBO.set({lastLightComplexity:o},!0),t.lastBoundBO.set({lastLightCount:a},!0),g=!0),(!t.currentRenderPass&&t.lastRenderPassShaderReplacement||t.currentRenderPass&&t.currentRenderPass.getShaderReplacement()!==t.lastRenderPassShaderReplacement)&&(g=!0),!!(t.lastHaveSeenDepthRequest!==t.haveSeenDepthRequest||e.getShaderSourceTime().getMTime()<t.renderable.getMTime()||e.getShaderSourceTime().getMTime()<t.currentInput.getMTime()||e.getShaderSourceTime().getMTime()<t.selectionStateChanged.getMTime()||g)&&(t.lastHaveSeenDepthRequest=t.haveSeenDepthRequest,!0)},e.invokeShaderCallbacks=(e,n,r)=>{const o=t.renderable.getViewSpecificProperties().ShadersCallbacks;o&&o.forEach((t=>{t.callback(t.userData,e,n,r)}))},e.setMapperShaderParameters=(n,r,o)=>{if(n.getProgram().isUniformUsed(&quot;PrimitiveIDOffset&quot;)&&n.getProgram().setUniformi(&quot;PrimitiveIDOffset&quot;,t.primitiveIDOffset),n.getProgram().isUniformUsed(&quot;VertexIDOffset&quot;)&&n.getProgram().setUniformi(&quot;VertexIDOffset&quot;,t.vertexIDOffset),n.getCABO().getElementCount()&&(t.VBOBuildTime.getMTime()>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())){const e=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);n.getProgram().isAttributeUsed(&quot;vertexMC&quot;)&&(n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;vertexMC&quot;,n.getCABO().getVertexOffset(),n.getCABO().getStride(),t.context.FLOAT,3,!1)||Gd(&quot;Error setting vertexMC in shader VAO.&quot;)),n.getProgram().isAttributeUsed(&quot;normalMC&quot;)&&n.getCABO().getNormalOffset()&&e>0?n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;normalMC&quot;,n.getCABO().getNormalOffset(),n.getCABO().getStride(),t.context.FLOAT,3,!1)||Gd(&quot;Error setting normalMC in shader VAO.&quot;):n.getVAO().removeAttributeArray(&quot;normalMC&quot;),t.renderable.getCustomShaderAttributes().forEach(((e,r)=>{n.getProgram().isAttributeUsed(`${e}MC`)&&(n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),`${e}MC`,n.getCABO().getCustomData()[r].offset,n.getCABO().getStride(),t.context.FLOAT,n.getCABO().getCustomData()[r].components,!1)||Gd(`Error setting ${e}MC in shader VAO.`))})),n.getProgram().isAttributeUsed(&quot;tcoordMC&quot;)&&n.getCABO().getTCoordOffset()?n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;tcoordMC&quot;,n.getCABO().getTCoordOffset(),n.getCABO().getStride(),t.context.FLOAT,n.getCABO().getTCoordComponents(),!1)||Gd(&quot;Error setting tcoordMC in shader VAO.&quot;):n.getVAO().removeAttributeArray(&quot;tcoordMC&quot;),n.getProgram().isAttributeUsed(&quot;scalarColor&quot;)&&n.getCABO().getColorComponents()?n.getVAO().addAttributeArray(n.getProgram(),n.getCABO().getColorBO(),&quot;scalarColor&quot;,n.getCABO().getColorOffset(),n.getCABO().getColorBOStride(),t.context.UNSIGNED_BYTE,4,!0)||Gd(&quot;Error setting scalarColor in shader VAO.&quot;):n.getVAO().removeAttributeArray(&quot;scalarColor&quot;),n.getAttributeUpdateTime().modified()}if(t.renderable.getNumberOfClippingPlanes()){const e=t.renderable.getNumberOfClippingPlanes(),r=[],a=n.getCABO().getCoordShiftAndScaleEnabled()?n.getCABO().getInverseShiftAndScaleMatrix():null,i=a?p(t.tmpMat4,o.getMatrix()):o.getMatrix();a&&(h(i,i),b(i,i,a),h(i,i));for(let n=0;n<e;n++){const e=[];t.renderable.getClippingPlaneInDataCoords(i,n,e);for(let t=0;t<4;t++)r.push(e[t])}n.getProgram().setUniformi(&quot;numClipPlanes&quot;,e),n.getProgram().setUniform4fv(&quot;clipPlanes&quot;,r)}t.internalColorTexture&&n.getProgram().isUniformUsed(&quot;texture1&quot;)&&n.getProgram().setUniformi(&quot;texture1&quot;,t.internalColorTexture.getTextureUnit());const a=t.openGLActor.getActiveTextures();if(a)for(let e=0;e<a.length;++e){const t=a[e].getTextureUnit(),r=`texture${t+1}`;n.getProgram().isUniformUsed(r)&&n.getProgram().setUniformi(r,t)}if(t.haveSeenDepthRequest&&n.getProgram().setUniformi(&quot;depthRequest&quot;,t.renderDepth?1:0),n.getProgram().isUniformUsed(&quot;coffset&quot;)){const t=e.getCoincidentParameters(r,o);n.getProgram().setUniformf(&quot;coffset&quot;,t.offset),n.getProgram().isUniformUsed(&quot;cfactor&quot;)&&n.getProgram().setUniformf(&quot;cfactor&quot;,t.factor)}n.setMapperShaderParameters(r,o,t._openGLRenderer.getTiledSizeAndOrigin());const i=t._openGLRenderer.getSelector();n.getProgram().setUniform3fArray(&quot;mapperIndex&quot;,i?i.getPropColorValue():[0,0,0]),n.getProgram().setUniformi(&quot;picking&quot;,i?i.getCurrentPass()+1:0)},e.setLightingShaderParameters=(e,n,r)=>{const o=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);if(o<2)return;const a=e.getProgram();let i=0;const s=n.getLightsByReference();for(let e=0;e<s.length;++e){const r=s[e];if(r.getSwitch()>0){const e=r.getColorByReference(),o=r.getIntensity();t.lightColor[0]=e[0]*o,t.lightColor[1]=e[1]*o,t.lightColor[2]=e[2]*o;const s=r.getDirection(),l=n.getActiveCamera().getViewMatrix(),c=[...s];r.lightTypeIsSceneLight()&&(c[0]=l[0]*s[0]+l[1]*s[1]+l[2]*s[2],c[1]=l[4]*s[0]+l[5]*s[1]+l[6]*s[2],c[2]=l[8]*s[0]+l[9]*s[1]+l[10]*s[2],Fo(c)),t.lightDirection[0]=c[0],t.lightDirection[1]=c[1],t.lightDirection[2]=c[2],Fo(t.lightDirection),a.setUniform3fArray(`lightColor${i}`,t.lightColor),a.setUniform3fArray(`lightDirectionVC${i}`,t.lightDirection),i++}}if(o<3)return;const l=n.getActiveCamera().getViewMatrix();h(l,l),i=0;for(let e=0;e<s.length;++e){const t=s[e];if(t.getSwitch()>0){const e=t.getTransformedPosition(),n=new Float64Array(3);In(n,e,l),a.setUniform3fArray(`lightAttenuation${i}`,t.getAttenuationValuesByReference()),a.setUniformi(`lightPositional${i}`,t.getPositional()),a.setUniformf(`lightExponent${i}`,t.getExponent()),a.setUniformf(`lightConeAngle${i}`,t.getConeAngle()),a.setUniform3fArray(`lightPositionVC${i}`,[n[0],n[1],n[2]]),i++}}},e.setCameraShaderParameters=(e,a,i)=>{const s=e.getProgram(),l=t.openGLCamera.getKeyMatrices(a),c=a.getActiveCamera(),u=t.openGLCamera.getKeyMatrixTime().getMTime(),d=s.getLastCameraMTime(),p=e.getCABO().getCoordShiftAndScaleEnabled()?e.getCABO().getInverseShiftAndScaleMatrix():null,f=i.getIsIdentity(),g=f?{mcwc:null,normalMatrix:null}:t.openGLActor.getKeyMatrices();if(i.getCoordinateSystem()===Wd.DISPLAY){const e=t._openGLRenderer.getTiledSizeAndOrigin();m(t.tmpMat4),t.tmpMat4[0]=2/e.usize,t.tmpMat4[12]=-1,t.tmpMat4[5]=2/e.vsize,t.tmpMat4[13]=-1,b(t.tmpMat4,t.tmpMat4,p),s.setUniformMatrix(&quot;MCPCMatrix&quot;,t.tmpMat4)}else s.setUniformMatrix(&quot;MCPCMatrix&quot;,n([l.wcpc,g.mcwc,p],r,t.tmpMat4));s.isUniformUsed(&quot;MCVCMatrix&quot;)&&s.setUniformMatrix(&quot;MCVCMatrix&quot;,n([l.wcvc,g.mcwc,p],r,t.tmpMat4)),s.isUniformUsed(&quot;normalMatrix&quot;)&&s.setUniformMatrix3x3(&quot;normalMatrix&quot;,n([l.normalMatrix,g.normalMatrix],o,t.tmpMat3)),d!==u&&(s.isUniformUsed(&quot;cameraParallel&quot;)&&s.setUniformi(&quot;cameraParallel&quot;,c.getParallelProjection()),s.setLastCameraMTime(u)),f||s.setLastCameraMTime(0)},e.setPropertyShaderParameters=(e,n,r)=>{const o=e.getProgram();let a=r.getProperty(),i=a.getOpacity(),s=t.drawingEdges?a.getEdgeColorByReference():a.getAmbientColorByReference(),l=t.drawingEdges?a.getEdgeColorByReference():a.getDiffuseColorByReference(),c=t.drawingEdges?1:a.getAmbient(),u=t.drawingEdges?0:a.getDiffuse(),d=t.drawingEdges?0:a.getSpecular();const p=a.getSpecularPower();o.setUniformf(&quot;opacityUniform&quot;,i),o.setUniform3fArray(&quot;ambientColorUniform&quot;,s),o.setUniform3fArray(&quot;diffuseColorUniform&quot;,l),o.setUniformf(&quot;ambient&quot;,c),o.setUniformf(&quot;diffuse&quot;,u);const f=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);if(f<1)return;let g=a.getSpecularColorByReference();if(o.setUniform3fArray(&quot;specularColorUniform&quot;,g),o.setUniformf(&quot;specularPowerUniform&quot;,p),o.setUniformf(&quot;specular&quot;,d),o.isUniformUsed(&quot;ambientIntensityBF&quot;)){if(a=r.getBackfaceProperty(),i=a.getOpacity(),s=a.getAmbientColor(),c=a.getAmbient(),l=a.getDiffuseColor(),u=a.getDiffuse(),g=a.getSpecularColor(),d=a.getSpecular(),o.setUniformf(&quot;ambientIntensityBF&quot;,c),o.setUniformf(&quot;diffuseIntensityBF&quot;,u),o.setUniformf(&quot;opacityUniformBF&quot;,i),o.setUniform3fArray(&quot;ambientColorUniformBF&quot;,s),o.setUniform3fArray(&quot;diffuseColorUniformBF&quot;,l),f<1)return;o.setUniformf(&quot;specularIntensityBF&quot;,d),o.setUniform3fArray(&quot;specularColorUniformBF&quot;,g),o.setUniformf(&quot;specularPowerUniformBF&quot;,p)}},e.updateMaximumPointCellIds=(e,n)=>{const r=t._openGLRenderer.getSelector();if(r){if(t.selectionWebGLIdsToVTKIds?.points?.length){const e=t.selectionWebGLIdsToVTKIds.points.length;r.setMaximumPointId(e-1)}if(t.selectionWebGLIdsToVTKIds?.cells?.length){const e=t.selectionWebGLIdsToVTKIds.cells.length;r.setMaximumCellId(e-1)}r.getFieldAssociation()===Dd.FIELD_ASSOCIATION_POINTS&&(t.pointPicking=!0)}},e.renderPieceStart=(n,r)=>{t.primitiveIDOffset=0,t.vertexIDOffset=0;const o=function(e){const t=e.getSelector();return t?t.getCurrentPass():Al.MIN_KNOWN_PASS-1}(t._openGLRenderer);t.lastSelectionState!==o&&(t.selectionStateChanged.modified(),t.lastSelectionState=o),t._openGLRenderer.getSelector()&&t._openGLRenderer.getSelector().renderProp(r),e.updateBufferObjects(n,r),t.renderable.getColorTextureMap()&&t.internalColorTexture.activate(),t.lastBoundBO=null},e.renderPieceDraw=(n,r)=>{const o=r.getProperty().getRepresentation(),a=r.getProperty().getEdgeVisibility()&&o===Bd.SURFACE,i=t._openGLRenderer.getSelector(),s=i&&i.getFieldAssociation()===Dd.FIELD_ASSOCIATION_POINTS&&(t.lastSelectionState===Al.ID_LOW24||t.lastSelectionState===Al.ID_HIGH24);for(let i=Ld.Start;i<Ld.End;i++)t.primitives[i].setPointPicking(s),t.primitives[i].getCABO().getElementCount()&&(t.drawingEdges=a&&(i===Ld.TrisEdges||i===Ld.TriStripsEdges),t.drawingEdges&&(t.renderDepth||t.lastSelectionState>=0)||(t.lastBoundBO=t.primitives[i],t.primitiveIDOffset+=t.primitives[i].drawArrays(n,r,o,e),t.vertexIDOffset+=t.primitives[i].getCABO().getElementCount()))},e.renderPieceFinish=(e,n)=>{t.LastBoundBO&&t.LastBoundBO.getVAO().release(),t.renderable.getColorTextureMap()&&t.internalColorTexture.deactivate()},e.renderPiece=(n,r)=>{if(e.invokeEvent(Ud),t.renderable.getStatic()||t.renderable.update(),t.currentInput=t.renderable.getInputData(),e.invokeEvent(zd),!t.currentInput)return void Gd(&quot;No input!&quot;);if(!t.currentInput.getPoints||!t.currentInput.getPoints().getNumberOfValues())return;const o=t.context,a=r.getProperty().getBackfaceCulling(),i=r.getProperty().getFrontfaceCulling();a||i?i?(t._openGLRenderWindow.enableCullFace(),o.cullFace(o.FRONT)):(t._openGLRenderWindow.enableCullFace(),o.cullFace(o.BACK)):t._openGLRenderWindow.disableCullFace(),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r)},e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n),e.updateMaximumPointCellIds()},e.getNeedToRebuildBufferObjects=(n,r)=>{const o=t.VBOBuildTime.getMTime();return o<e.getMTime()||o<t.renderable.getMTime()||o<r.getMTime()||o<t.currentInput.getMTime()},e.buildBufferObjects=(e,n)=>{const r=t.currentInput;if(null===r)return;t.renderable.mapScalars(r,1);const o=t.renderable.getColorMapColors();t.haveCellScalars=!1;const a=t.renderable.getScalarMode();t.renderable.getScalarVisibility()&&(a!==Fd.USE_CELL_DATA&&a!==Fd.USE_CELL_FIELD_DATA&&a!==Fd.USE_FIELD_DATA&&r.getPointData().getScalars()||a===Fd.USE_POINT_FIELD_DATA||!o||(t.haveCellScalars=!0));let i=n.getProperty().getInterpolation()!==Nd.FLAT?r.getPointData().getNormals():null;null===i&&r.getCellData().getNormals()&&(t.haveCellNormals=!0,i=r.getCellData().getNormals());const s=n.getProperty().getRepresentation();let l=r.getPointData().getTCoords();t.openGLActor.getActiveTextures()||(l=null);let c=!1;if(t.renderable.getColorCoordinates()){l=t.renderable.getColorCoordinates(),c=t.renderable.getAreScalarsMappedFromCells(),t.internalColorTexture||(t.internalColorTexture=Pd.newInstance({resizable:!0}));const e=t.internalColorTexture;e.setMinificationFilter(_d.NEAREST),e.setMagnificationFilter(_d.NEAREST),e.setWrapS(kd.CLAMP_TO_EDGE),e.setWrapT(kd.CLAMP_TO_EDGE),e.setOpenGLRenderWindow(t._openGLRenderWindow);const n=t.renderable.getColorTextureMap(),r=n.getExtent(),o=n.getPointData().getScalars();e.create2DFromRaw({width:r[1]-r[0]+1,height:r[3]-r[2]+1,numComps:o.getNumberOfComponents(),dataType:o.getDataType(),data:o.getData()}),e.activate(),e.sendParameters(),e.deactivate()}const u=`${r.getMTime()}A${s}B${r.getMTime()}C${i?i.getMTime():1}D${o?o.getMTime():1}E${n.getProperty().getEdgeVisibility()}F${l?l.getMTime():1}`;if(t.VBOBuildString!==u){const e={points:r.getPoints(),normals:i,tcoords:l,colors:o,cellOffset:0,vertexOffset:0,useTCoordsPerCell:c,haveCellScalars:t.haveCellScalars,haveCellNormals:t.haveCellNormals,customAttributes:t.renderable.getCustomShaderAttributes().map((e=>r.getPointData().getArrayByName(e)))};t.renderable.getPopulateSelectionSettings()&&(t.selectionWebGLIdsToVTKIds={points:null,cells:null});const a=[{inRep:&quot;verts&quot;,cells:r.getVerts()},{inRep:&quot;lines&quot;,cells:r.getLines()},{inRep:&quot;polys&quot;,cells:r.getPolys()},{inRep:&quot;strips&quot;,cells:r.getStrips()},{inRep:&quot;polys&quot;,cells:r.getPolys()},{inRep:&quot;strips&quot;,cells:r.getStrips()}],d=n.getProperty().getEdgeVisibility()&&s===Bd.SURFACE;for(let n=Ld.Start;n<Ld.End;n++)n!==Ld.TrisEdges&&n!==Ld.TriStripsEdges?(e.cellOffset+=t.primitives[n].getCABO().createVBO(a[n].cells,a[n].inRep,s,e,t.selectionWebGLIdsToVTKIds),e.vertexOffset+=t.primitives[n].getCABO().getElementCount()):d?t.primitives[n].getCABO().createVBO(a[n].cells,a[n].inRep,Bd.WIREFRAME,{...e,tcoords:null,colors:null,haveCellScalars:!1,haveCellNormals:!1}):t.primitives[n].releaseGraphicsResources();t.renderable.getPopulateSelectionSettings()&&t.renderable.setSelectionWebGLIdsToVTKIds(t.selectionWebGLIdsToVTKIds),t.VBOBuildString=u}t.VBOBuildTime.modified()},e.getAllocatedGPUMemoryInBytes=()=>{let e=0;return t.primitives.forEach((t=>{e+=t.getAllocatedGPUMemoryInBytes()})),e}}(e,t)}const Kd=Mt(jd,&quot;vtkOpenGLPolyDataMapper&quot;);var $d={newInstance:Kd,extend:jd};Jt(&quot;vtkMapper&quot;,Kd);const qd=1,{primTypes:Xd}=ld,{Filter:Yd,Wrap:Zd}=Pd,{vtkErrorMacro:Qd}=Ht,Jd={type:&quot;StartEvent&quot;},ep={type:&quot;EndEvent&quot;},tp={context:null,VBOBuildTime:0,VBOBuildString:null,primitives:null,primTypes:null,shaderRebuildString:null};const np=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,tp,n),qt.extend(e,t,n),Ed(e,t,n),Vd(e,t,n),t.primitives=[],t.primTypes=Xd,t.tmpMat4=m(new Float64Array(16));for(let e=Xd.Start;e<Xd.End;e++)t.primitives[e]=ld.newInstance(),t.primitives[e].setPrimitiveType(e),t.primitives[e].set({lastLightComplexity:0,lastLightCount:0,lastSelectionPass:!1},!0);Ct(e,t,[&quot;context&quot;]),t.VBOBuildTime={},ht(t.VBOBuildTime,{mtime:0}),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLPolyDataMapper2D&quot;),e.buildPass=n=>{n&&(t.openGLActor2D=e.getFirstAncestorOfType(&quot;vtkOpenGLActor2D&quot;),t._openGLRenderer=t.openGLActor2D.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t.openGLCamera=t._openGLRenderer.getViewNodeFor(t._openGLRenderer.getRenderable().getActiveCamera()))},e.overlayPass=t=>{t&&e.render()},e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkPolyData2DVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\n// all variables that represent positions or directions have a suffix\\n// indicating the coordinate system they are in. The possible values are\\n// MC - Model Coordinates\\n// WC - WC world coordinates\\n// VC - View Coordinates\\n// DC - Display Coordinates\\n\\nin vec4 vertexWC;\\n\\n// frag position in VC\\n//VTK::PositionVC::Dec\\n\\n// material property values\\n//VTK::Color::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// Apple Bug\\n//VTK::PrimID::Dec\\n\\nuniform mat4 WCVCMatrix;  // World to view matrix\\n\\nvoid main()\\n{\\n  // Apple Bug\\n  //VTK::PrimID::Impl\\n\\n  gl_Position = WCVCMatrix*vertexWC;\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::PositionVC::Impl\\n}\\n&quot;,e.Fragment=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkPolyData2DFS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\nuniform int PrimitiveIDOffset;\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// Scalar coloring\\n//VTK::Color::Dec\\n\\n// Depth Peeling\\n//VTK::DepthPeeling::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\n// Apple Bug\\n//VTK::PrimID::Dec\\n\\nvoid main()\\n{\\n  // Apple Bug\\n  //VTK::PrimID::Impl\\n\\n  //VTK::Color::Impl\\n  //VTK::TCoord::Impl\\n\\n  //VTK::DepthPeeling::Impl\\n  //VTK::Picking::Impl\\n\\n  if (gl_FragData[0].a <= 0.0)\\n    {\\n    discard;\\n    }\\n}\\n&quot;,e.Geometry=&quot;&quot;},e.render=()=>{const n=t._openGLRenderWindow.getContext();if(t.context!==n){t.context=n;for(let e=Xd.Start;e<Xd.End;e++)t.primitives[e].setOpenGLRenderWindow(t._openGLRenderWindow)}const r=t.openGLActor2D.getRenderable(),o=t._openGLRenderer.getRenderable();e.renderPiece(o,r)},e.renderPiece=(n,r)=>{if(e.invokeEvent(Jd),t.renderable.getStatic()||t.renderable.update(),t.currentInput=t.renderable.getInputData(),e.invokeEvent(ep),!t.currentInput)return void Qd(&quot;No input!&quot;);if(!t.currentInput.getPoints||!t.currentInput.getPoints().getNumberOfValues())return;const o=t.context;t._openGLRenderWindow.enableCullFace(),o.cullFace(o.BACK),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r)},e.renderPieceStart=(n,r)=>{t.primitiveIDOffset=0,t._openGLRenderer.getSelector()&&(t._openGLRenderer.getSelector().getCurrentPass(),t._openGLRenderer.getSelector().renderProp(r)),t.renderable.getColorTextureMap()&&t.internalColorTexture.activate(),e.updateBufferObjects(n,r),t.lastBoundBO=null},e.getNeedToRebuildShaders=(e,n,r)=>e.getShaderSourceTime().getMTime()<t.renderable.getMTime()||e.getShaderSourceTime().getMTime()<t.currentInput.getMTime(),e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n)},e.getNeedToRebuildBufferObjects=(n,r)=>{const o=t.VBOBuildTime.getMTime();return!!(o<e.getMTime()||o<t._openGLRenderWindow.getMTime()||o<t.renderable.getMTime()||o<r.getMTime()||o<t.currentInput.getMTime()||t.renderable.getTransformCoordinate()&&o<n.getMTime())},e.buildBufferObjects=(e,n)=>{const r=t.currentInput;if(null===r)return;t.renderable.mapScalars(r,n.getProperty().getOpacity());const o=t.renderable.getColorMapColors(),a=n.getProperty().getRepresentation();let i=r.getPointData().getTCoords();t.openGLActor2D.getActiveTextures()||(i=null);let s=!1;if(t.renderable.getColorCoordinates()){i=t.renderable.getColorCoordinates(),s=t.renderable.getAreScalarsMappedFromCells(),t.internalColorTexture||(t.internalColorTexture=Pd.newInstance({resizable:!0}));const e=t.internalColorTexture;e.setMinificationFilter(Yd.NEAREST),e.setMagnificationFilter(Yd.NEAREST),e.setWrapS(Zd.CLAMP_TO_EDGE),e.setWrapT(Zd.CLAMP_TO_EDGE),e.setOpenGLRenderWindow(t._openGLRenderWindow);const n=t.renderable.getColorTextureMap(),r=n.getExtent(),o=n.getPointData().getScalars();e.create2DFromRaw({width:r[1]-r[0]+1,height:r[3]-r[2]+1,numComps:o.getNumberOfComponents(),dataType:o.getDataType(),data:o.getData()}),e.activate(),e.sendParameters(),e.deactivate()}const l=t.renderable.getTransformCoordinate(),c=e.getRenderWindow().getViews()[0].getViewportSize(e),u=`${r.getMTime()}A${a}B${r.getMTime()}C${o?o.getMTime():1}D${i?i.getMTime():1}E${l?e.getMTime():1}F${c}`;if(t.VBOBuildString!==u){let n=r.getPoints();if(l){const t=Yl.newInstance(),r=n.getNumberOfPoints();t.setNumberOfPoints(r);const o=[];for(let a=0;a<r;++a){n.getPoint(a,o),l.setValue(o);const r=l.getComputedDoubleViewportValue(e);t.setPoint(a,r[0],r[1],0)}n=t}const c={points:n,tcoords:i,colors:o,cellOffset:0,useTCoordsPerCell:s,haveCellScalars:t.renderable.getAreScalarsMappedFromCells(),customAttributes:t.renderable.getCustomShaderAttributes().map((e=>r.getPointData().getArrayByName(e)))};c.cellOffset+=t.primitives[Xd.Points].getCABO().createVBO(r.getVerts(),&quot;verts&quot;,a,c),c.cellOffset+=t.primitives[Xd.Lines].getCABO().createVBO(r.getLines(),&quot;lines&quot;,a,c),c.cellOffset+=t.primitives[Xd.Tris].getCABO().createVBO(r.getPolys(),&quot;polys&quot;,a,c),c.cellOffset+=t.primitives[Xd.TriStrips].getCABO().createVBO(r.getStrips(),&quot;strips&quot;,a,c),t.VBOBuildTime.modified(),t.VBOBuildString=u}},e.renderPieceDraw=(n,r)=>{const o=r.getProperty().getRepresentation();t.context.depthMask(!0);for(let a=Xd.Start;a<Xd.End;a++)t.primitives[a].getCABO().getElementCount()&&(t.lastBoundBO=t.primitives[a],t.primitiveIDOffset+=t.primitives[a].drawArrays(n,r,o,e))},e.renderPieceFinish=(e,n)=>{t.lastBoundBO&&t.lastBoundBO.getVAO().release(),t.renderable.getColorTextureMap()&&t.internalColorTexture.deactivate()},e.replaceShaderValues=(t,n,r)=>{e.replaceShaderColor(t,n,r),e.replaceShaderTCoord(t,n,r),e.replaceShaderPicking(t,n,r),e.replaceShaderPositionVC(t,n,r)},e.replaceShaderColor=(e,n,r)=>{let o=e.Vertex,a=e.Geometry,i=e.Fragment,s=[&quot;uniform vec3 diffuseColorUniform;&quot;,&quot;uniform float opacityUniform;&quot;],l=[&quot;vec3 diffuseColor = diffuseColorUniform;&quot;,&quot;float opacity = opacityUniform;&quot;];0!==t.lastBoundBO.getCABO().getColorComponents()?(s=s.concat([&quot;varying vec4 vertexColorVSOutput;&quot;]),o=td.substitute(o,&quot;//VTK::Color::Dec&quot;,[&quot;attribute vec4 scalarColor;&quot;,&quot;varying vec4 vertexColorVSOutput;&quot;]).result,o=td.substitute(o,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorVSOutput =  scalarColor;&quot;]).result,a=td.substitute(a,&quot;//VTK::Color::Dec&quot;,[&quot;in vec4 vertexColorVSOutput[];&quot;,&quot;out vec4 vertexColorGSOutput;&quot;]).result,a=td.substitute(a,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorGSOutput = vertexColorVSOutput[i];&quot;]).result,i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,l.concat([&quot;  diffuseColor = vertexColorVSOutput.rgb;&quot;,&quot;  opacity = opacity*vertexColorVSOutput.a;&quot;])).result):t.renderable.getAreScalarsMappedFromCells()&&(l=l.concat([&quot;  vec4 texColor = texture2D(texture1, tcoordVCVSOutput.st);&quot;,&quot;  diffuseColor = texColor.rgb;&quot;,&quot;  opacity = opacity*texColor.a;&quot;])),l=l.concat([&quot;gl_FragData[0] = vec4(diffuseColor, opacity);&quot;]),i=td.substitute(i,&quot;//VTK::Color::Dec&quot;,s).result,i=td.substitute(i,&quot;//VTK::Color::Impl&quot;,l).result,e.Vertex=o,e.Geometry=a,e.Fragment=i},e.replaceShaderTCoord=(e,n,r)=>{if(t.lastBoundBO.getCABO().getTCoordOffset()){let n=e.Vertex,r=e.Geometry,o=e.Fragment;const a=t.lastBoundBO.getCABO().getTCoordComponents();1===a?(n=td.substitute(n,&quot;//VTK::TCoord::Dec&quot;,[&quot;in float tcoordMC;&quot;,&quot;out float tcoordVCVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::TCoord::Impl&quot;,[&quot;tcoordVCVSOutput = tcoordMC;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Dec&quot;,[&quot;in float tcoordVCVSOutput[];\\n&quot;,&quot;out float tcoordVCGSOutput;&quot;]).result,r=td.substitute(r,[&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCGSOutput = tcoordVCVSOutput[i];&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;in float tcoordVCVSOutput;&quot;,&quot;uniform sampler2D texture1;&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;gl_FragData[0] = gl_FragData[0]*texture2D(texture1, vec2(tcoordVCVSOutput,0));&quot;]).result):2===a&&(n=td.substitute(n,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec2 tcoordMC;&quot;,&quot;out vec2 tcoordVCVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::TCoord::Impl&quot;,[&quot;tcoordVCVSOutput = tcoordMC;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec2 tcoordVCVSOutput[];\\n&quot;,&quot;out vec2 tcoordVCGSOutput;&quot;]).result,r=td.substitute(r,&quot;//VTK::TCoord::Impl&quot;,[&quot;tcoordVCGSOutput = tcoordVCVSOutput[i];&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;in vec2 tcoordVCVSOutput;&quot;,&quot;uniform sampler2D texture1;&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;gl_FragData[0] = gl_FragData[0]*texture2D(texture1, tcoordVCVSOutput.st);&quot;]).result),t.renderable.getAreScalarsMappedFromCells()&&(r=td.substitute(r,&quot;//VTK::PrimID::Impl&quot;,[&quot;gl_PrimitiveID = gl_PrimitiveIDIn;&quot;]).result),e.Vertex=n,e.Geometry=r,e.Fragment=o}},e.replaceShaderPicking=(e,t,n)=>{let r=e.Fragment;r=td.substitute(r,&quot;//VTK::Picking::Dec&quot;,[&quot;uniform vec3 mapperIndex;&quot;,&quot;uniform int picking;&quot;]).result,r=td.substitute(r,&quot;//VTK::Picking::Impl&quot;,&quot;  gl_FragData[0] = picking != 0 ? vec4(mapperIndex,1.0) : gl_FragData[0];&quot;).result,e.Fragment=r},e.replaceShaderPositionVC=(e,n,r)=>{t.lastBoundBO.replaceShaderPositionVC(e,n,r)},e.invokeShaderCallbacks=(e,n,r)=>{const o=t.renderable.getViewSpecificProperties().ShadersCallbacks;o&&o.forEach((t=>{t.callback(t.userData,e,n,r)}))},e.setMapperShaderParameters=(e,n,r)=>{if(e.getProgram().isUniformUsed(&quot;PrimitiveIDOffset&quot;)&&e.getProgram().setUniformi(&quot;PrimitiveIDOffset&quot;,t.primitiveIDOffset),e.getProgram().isAttributeUsed(&quot;vertexWC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;vertexWC&quot;,e.getCABO().getVertexOffset(),e.getCABO().getStride(),t.context.FLOAT,3,!1)||Qd(&quot;Error setting vertexWC in shader VAO.&quot;)),e.getCABO().getElementCount()&&(t.VBOBuildTime.getMTime()>e.getAttributeUpdateTime().getMTime()||e.getShaderSourceTime().getMTime()>e.getAttributeUpdateTime().getMTime())){t.renderable.getCustomShaderAttributes().forEach(((n,r)=>{e.getProgram().isAttributeUsed(`${n}MC`)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),`${n}MC`,e.getCABO().getCustomData()[r].offset,e.getCABO().getStride(),t.context.FLOAT,e.getCABO().getCustomData()[r].components,!1)||Qd(`Error setting ${n}MC in shader VAO.`))})),e.getProgram().isAttributeUsed(&quot;tcoordMC&quot;)&&e.getCABO().getTCoordOffset()?e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;tcoordMC&quot;,e.getCABO().getTCoordOffset(),e.getCABO().getStride(),t.context.FLOAT,e.getCABO().getTCoordComponents(),!1)||Qd(&quot;Error setting tcoordMC in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;tcoordMC&quot;),e.getProgram().isAttributeUsed(&quot;scalarColor&quot;)&&e.getCABO().getColorComponents()?e.getVAO().addAttributeArray(e.getProgram(),e.getCABO().getColorBO(),&quot;scalarColor&quot;,e.getCABO().getColorOffset(),e.getCABO().getColorBOStride(),t.context.UNSIGNED_BYTE,4,!0)||Qd(&quot;Error setting scalarColor in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;scalarColor&quot;),t.internalColorTexture&&e.getProgram().isUniformUsed(&quot;texture1&quot;)&&t.internalColorTexture.getTextureUnit()>-1&&e.getProgram().setUniformi(&quot;texture1&quot;,t.internalColorTexture.getTextureUnit());const o=t.openGLActor2D.getActiveTextures();if(o)for(let t=0;t<o.length;++t){const n=o[t].getTextureUnit(),r=`texture${n+1}`;e.getProgram().isUniformUsed(r)&&e.getProgram().setUniformi(r,n)}e.setMapperShaderParameters(n,r,t._openGLRenderer.getTiledSizeAndOrigin());const a=t._openGLRenderer.getSelector();e.getProgram().setUniform3fArray(&quot;mapperIndex&quot;,a?a.getPropColorValue():[0,0,0]),e.getProgram().setUniformi(&quot;picking&quot;,a?a.getCurrentPass()+1:0)}},e.setPropertyShaderParameters=(e,n,r)=>{const o=t.renderable.getColorMapColors();if(!o||0===o.getNumberOfComponents()){const t=e.getProgram(),n=r.getProperty(),o=n.getOpacity();t.setUniformf(&quot;opacityUniform&quot;,o);const a=n.getColor();t.setUniform3fArray(&quot;diffuseColorUniform&quot;,a)}},e.setLightingShaderParameters=(e,t,n)=>{},e.setCameraShaderParameters=(e,n,o)=>{const a=e.getProgram(),i=e.getCABO().getCoordShiftAndScaleEnabled()?e.getCABO().getInverseShiftAndScaleMatrix():null,s=n.getRenderWindow().getViews()[0].getViewportSize(n),l=n.getViewport(),c=o.getActualPositionCoordinate().getComputedDoubleViewportValue(n),u=[0,0,1,1],d=[0,0,1,1];if(d[0]=l[0]>=u[0]?l[0]:u[0],d[1]=l[1]>=u[1]?l[1]:u[1],d[2]=l[2]<=u[2]?l[2]:u[2],d[3]=l[3]<=u[3]?l[3]:u[3],d[0]>=d[2])return;if(d[1]>=d[3])return;s[0]=yo(s[0]*(d[2]-d[0])/(l[2]-l[0])),s[1]=yo(s[1]*(d[3]-d[1])/(l[3]-l[1]));const p=t._openGLRenderer.getParent().getSize(),f=yo(c[0]-(d[0]-l[0])*p[0]),g=yo(c[1]-(d[1]-l[1])*p[1]),v=-f;let T=-f+s[0];const y=-g;let b=-g+s[1];v===T&&(T=v+1),y===b&&(b=y+1);const x=m(new Float64Array(16));var C,S,A;x[0]=2/(T-v),x[5]=2/(b-y),x[3]=-1*(T+v)/(T-v),x[7]=-1*(b+y)/(b-y),x[10]=0,x[11]=o.getProperty().getDisplayLocation()===qd?-1:1,x[15]=1,h(x,x),a.setUniformMatrix(&quot;WCVCMatrix&quot;,(C=[x,i],S=r,A=t.tmpMat4,S.identity(A),C.reduce(((e,t,n)=>0===n?t?S.copy(e,t):S.identity(e):t?S.multiply(e,e,t):e),A)))},e.getAllocatedGPUMemoryInBytes=()=>{let e=0;return t.primitives.forEach((t=>{e+=t.getAllocatedGPUMemoryInBytes()})),e}}(e,t)}),&quot;vtkOpenGLPolyDataMapper2D&quot;);Jt(&quot;vtkMapper2D&quot;,np);var rp={Orientation:{HORIZONTAL:&quot;horizontal&quot;,VERTICAL:&quot;vertical&quot;,AUTO:&quot;auto&quot;}};const{VectorMode:op}=cl,{Orientation:ap}=rp;function ip(e,t,n){e.strokeStyle=t.strokeColor,e.lineWidth=t.strokeSize,e.fillStyle=t.fontColor;const r=t.fontSize??n;e.font=`${t.fontStyle} ${r}px ${t.fontFamily}`}function sp(e,t){return e=>{const n=e.getLastSize(),r=(n[0]/700)**.8,o=(n[1]/700)**.8,a=Math.min(r,o),i=e.getAxisTextStyle(),s=e.getTickTextStyle();Object.assign(i,t.axisTextStyle),Object.assign(s,t.tickTextStyle),void 0===i.fontSize&&(i.fontSize=Math.max(24*a,12)),void 0===s.fontSize&&(e.getLastAspectRatio()>1?s.fontSize=Math.max(20*a,10):s.fontSize=Math.max(16*a,10));const l=e.updateTextureAtlas();e.setTopTitle(!1);const c=e.getBoxSizeByReference();let u=!1;if(u=t.orientation===ap.VERTICAL||t.orientation!==ap.HORIZONTAL&&e.getLastAspectRatio()>1,u)e.setTickLabelPixelOffset(.3*s.fontSize),l.titleWidth<=l.tickWidth+e.getTickLabelPixelOffset()+.8*s.fontSize?(e.setTopTitle(!0),e.setAxisTitlePixelOffset(.2*s.fontSize),c[0]=2*(l.tickWidth+e.getTickLabelPixelOffset()+.8*s.fontSize)/n[0],e.setBoxPosition([.98-c[0],-.92])):(e.setAxisTitlePixelOffset(.2*s.fontSize),c[0]=2*(l.titleHeight+e.getAxisTitlePixelOffset()+l.tickWidth+e.getTickLabelPixelOffset()+.8*s.fontSize)/n[0],e.setBoxPosition([.99-c[0],-.92])),c[1]=Math.max(1.2,Math.min(1.84/o,1.84));else{e.setAxisTitlePixelOffset(1.2*s.fontSize),e.setTickLabelPixelOffset(.1*s.fontSize);const t=2*(.8*s.fontSize+l.titleHeight+e.getAxisTitlePixelOffset())/n[1],r=2*l.tickWidth/n[0];c[0]=Math.min(1.9,Math.max(1.4,1.4*r*(e.getTicks().length+3))),c[1]=t,e.setBoxPosition([-.5*c[0],-.97])}e.recomputeBarSegments(l)}}function lp(e,t){return e=>{const t=e.getLastTickBounds(),n=ro().domain([t[0],t[1]]),r=n.ticks(5),o=n.tickFormat(5);e.setTicks(r),e.setTickStrings(r.map(o))}}const cp=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{renderable:null};Object.assign(t,{},n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;axisTitlePixelOffset&quot;,&quot;tickLabelPixelOffset&quot;,&quot;renderable&quot;,&quot;topTitle&quot;,&quot;ticks&quot;,&quot;tickStrings&quot;,&quot;tickPositions&quot;]),Wt.get(e,t,[&quot;lastSize&quot;,&quot;lastAspectRatio&quot;,&quot;lastTickBounds&quot;,&quot;axisTextStyle&quot;,&quot;tickTextStyle&quot;,&quot;barActor&quot;,&quot;tmActor&quot;]),Wt.getArray(e,t,[&quot;boxPosition&quot;,&quot;boxSize&quot;]),Wt.setArray(e,t,[&quot;boxPosition&quot;,&quot;boxSize&quot;],2),t.forceUpdate=!1,t.lastRebuildTime={},Wt.obj(t.lastRebuildTime,{mtime:0}),t.lastSize=[-1,-1],t.tmCanvas=document.createElement(&quot;canvas&quot;),t.tmContext=t.tmCanvas.getContext(&quot;2d&quot;),t._tmAtlas=new Map,t.barMapper=Gl.newInstance(),t.barMapper.setInterpolateScalarsBeforeMapping(!0),t.barMapper.setUseLookupTableScalarRange(!0),t.polyData=gu.newInstance(),t.barMapper.setInputData(t.polyData),t.barActor=ss.newInstance(),t.barActor.setMapper(t.barMapper),t.tmPolyData=gu.newInstance(),t.tmMapper=Gl.newInstance(),t.tmMapper.setInputData(t.tmPolyData),t.tmTexture=vu.newInstance({resizable:!0}),t.tmTexture.setInterpolate(!1),t.tmActor=ss.newInstance({parentProp:e}),t.tmActor.setMapper(t.tmMapper),t.tmActor.addTexture(t.tmTexture),t.barPosition=[0,0],t.barSize=[0,0],t.boxPosition=[.88,-.92],t.boxSize=[.1,1.1],t.lastTickBounds=[],function(e,t){t.classHierarchy.push(&quot;vtkScalarBarActorHelper&quot;),e.setRenderable=n=>{t.renderable!==n&&(t.renderable=n,t.barActor.setProperty(n.getProperty()),t.barActor.setParentProp(n),t.barActor.setCoordinateSystemToDisplay(),t.tmActor.setProperty(n.getProperty()),t.tmActor.setParentProp(n),t.tmActor.setCoordinateSystemToDisplay(),t.generateTicks=n.generateTicks,t.axisTextStyle={...n.getAxisTextStyle()},t.tickTextStyle={...n.getTickTextStyle()},e.modified())},e.updateAPISpecificData=(n,r,o)=>{t.lastSize[0]===n[0]&&t.lastSize[1]===n[1]||(t.lastSize[0]=n[0],t.lastSize[1]=n[1],t.lastAspectRatio=n[0]/n[1],t.forceUpdate=!0);const a=t.renderable.getScalarsToColors();if(a&&t.renderable.getVisibility()&&(t.barMapper.setLookupTable(a),t.camera=r,t.renderWindow=o,t.forceUpdate||Math.max(a.getMTime(),e.getMTime(),t.renderable.getMTime())>t.lastRebuildTime.getMTime())){const n=a.getMappingRange();if(t.lastTickBounds=[...n],t.renderable.getGenerateTicks()(e),t.renderable.getAutomated())t.renderable.getAutoLayout()(e);else{t.axisTextStyle={...t.renderable.getAxisTextStyle()},t.tickTextStyle={...t.renderable.getTickTextStyle()},t.barPosition=[...t.renderable.getBarPosition()],t.barSize=[...t.renderable.getBarSize()],t.boxPosition=[...t.renderable.getBoxPosition()],t.boxSize=[...t.renderable.getBoxSize()],t.axisTitlePixelOffset=t.renderable.getAxisTitlePixelOffset(),t.tickLabelPixelOffset=t.renderable.getTickLabelPixelOffset();const n=e.updateTextureAtlas();e.recomputeBarSegments(n)}e.updatePolyDataForLabels(),e.updatePolyDataForBarSegments(),t.lastRebuildTime.modified(),t.forceUpdate=!1}},e.updateTextureAtlas=()=>{t.tmContext.textBaseline=&quot;bottom&quot;,t.tmContext.textAlign=&quot;left&quot;;const n={},r=new Map;let o=0,a=1;ip(t.tmContext,t.axisTextStyle,18);let i=t.tmContext.measureText(t.renderable.getAxisLabel()),s={height:i.actualBoundingBoxAscent+2,startingHeight:a,width:i.width+2,textStyle:t.axisTextStyle};r.set(t.renderable.getAxisLabel(),s),a+=s.height,o=s.width,n.titleWidth=s.width,n.titleHeight=s.height,n.tickWidth=0,n.tickHeight=0,ip(t.tmContext,t.tickTextStyle,14);const l=[...e.getTickStrings(),&quot;NaN&quot;,&quot;Below&quot;,&quot;Above&quot;];for(let e=0;e<l.length;e++)r.has(l[e])||(i=t.tmContext.measureText(l[e]),s={height:i.actualBoundingBoxAscent+2,startingHeight:a,width:i.width+2,textStyle:t.tickTextStyle},r.set(l[e],s),a+=s.height,o<s.width&&(o=s.width),n.tickWidth<s.width&&(n.tickWidth=s.width),n.tickHeight<s.height&&(n.tickHeight=s.height));return o=wo(o),a=wo(a),r.forEach((e=>{e.tcoords=[0,(a-e.startingHeight-e.height)/a,e.width/o,(a-e.startingHeight-e.height)/a,e.width/o,(a-e.startingHeight)/a,0,(a-e.startingHeight)/a]})),t.tmCanvas.width=o,t.tmCanvas.height=a,t.tmContext.textBaseline=&quot;bottom&quot;,t.tmContext.textAlign=&quot;left&quot;,t.tmContext.clearRect(0,0,o,a),r.forEach(((e,n)=>{const r=e.textStyle===t.axisTextStyle?18:14;ip(t.tmContext,e.textStyle,r),t.tmContext.fillText(n,1,e.startingHeight+e.height-1)})),t.tmTexture.setCanvas(t.tmCanvas),t.tmTexture.modified(),t._tmAtlas=r,n},e.computeBarSize=e=>{t.vertical=t.boxSize[1]>t.boxSize[0];const n=2*e.tickHeight/t.lastSize[1],r=[1,1];if(t.vertical){const o=2*(e.tickWidth+t.tickLabelPixelOffset)/t.lastSize[0];if(t.topTitle){const n=2*(e.titleHeight+t.axisTitlePixelOffset)/t.lastSize[1];t.barSize[0]=t.boxSize[0]-o,t.barSize[1]=t.boxSize[1]-n}else{const n=2*(e.titleHeight+t.axisTitlePixelOffset)/t.lastSize[0];t.barSize[0]=t.boxSize[0]-n-o,t.barSize[1]=t.boxSize[1]}t.barPosition[0]=t.boxPosition[0]+o,t.barPosition[1]=t.boxPosition[1],r[1]=n}else{const n=(2*e.tickWidth-8)/t.lastSize[0],o=2*(e.titleHeight+t.axisTitlePixelOffset)/t.lastSize[1];t.barSize[0]=t.boxSize[0],t.barPosition[0]=t.boxPosition[0],t.barSize[1]=t.boxSize[1]-o,t.barPosition[1]=t.boxPosition[1],r[0]=n}return r},e.recomputeBarSegments=n=>{const r=e.computeBarSize(n);t.barSegments=[];const o=[0,0],a=t.vertical?1:0,i=t.vertical?.01:.02;function s(e,n){t.barSegments.push({corners:[[...o],[o[0]+r[0],o[1]],[o[0]+r[0],o[1]+r[1]],[o[0],o[1]+r[1]]],scalars:n,title:e}),o[a]+=r[a]+i}t.renderable.getDrawNanAnnotation()&&t.renderable.getScalarsToColors().getNanColor()&&s(&quot;NaN&quot;,[NaN,NaN,NaN,NaN]),t.renderable.getDrawBelowRangeSwatch()&&t.renderable.getScalarsToColors().getUseBelowRangeColor?.()&&s(&quot;Below&quot;,[-.1,-.1,-.1,-.1]);const l=t.renderable.getScalarsToColors().getUseAboveRangeColor?.();o[a]+=i;const c=r[a];r[a]=l?1-2*i-r[a]-o[a]:1-i-o[a],s(&quot;ticks&quot;,t.vertical?[0,0,.995,.995]:[0,.995,.995,0]),t.renderable.getDrawAboveRangeSwatch()&&l&&(r[a]=c,o[a]+=i,s(&quot;Above&quot;,[1.1,1.1,1.1,1.1]))};const n=new Float64Array(3);e.createPolyDataForOneLabel=(e,r,o,a,i,s)=>{const l=t._tmAtlas.get(e);if(!l)return;let c=s.ptIdx,u=s.cellIdx;n[0]=(.5*r[0]+.5)*t.lastSize[0],n[1]=(.5*r[1]+.5)*t.lastSize[1],n[2]=r[2],n[0]+=i[0],n[1]+=i[1];const d=[],p=&quot;vertical&quot;===a?[1,0]:[0,1];&quot;vertical&quot;===a?(d[0]=l.width,d[1]=-l.height,&quot;middle&quot;===o[0]?n[1]-=l.width/2:&quot;right&quot;===o[0]&&(n[1]-=l.width),&quot;middle&quot;===o[1]?n[0]+=l.height/2:&quot;top&quot;===o[1]&&(n[0]+=l.height)):(d[0]=l.width,d[1]=l.height,&quot;middle&quot;===o[0]?n[0]-=l.width/2:&quot;right&quot;===o[0]&&(n[0]-=l.width),&quot;middle&quot;===o[1]?n[1]-=l.height/2:&quot;top&quot;===o[1]&&(n[1]-=l.height)),s.points[3*c]=n[0],s.points[3*c+1]=n[1],s.points[3*c+2]=n[2],s.tcoords[2*c]=l.tcoords[0],s.tcoords[2*c+1]=l.tcoords[1],c++,n[p[0]]+=d[0],s.points[3*c]=n[0],s.points[3*c+1]=n[1],s.points[3*c+2]=n[2],s.tcoords[2*c]=l.tcoords[2],s.tcoords[2*c+1]=l.tcoords[3],c++,n[p[1]]+=d[1],s.points[3*c]=n[0],s.points[3*c+1]=n[1],s.points[3*c+2]=n[2],s.tcoords[2*c]=l.tcoords[4],s.tcoords[2*c+1]=l.tcoords[5],c++,n[p[0]]-=d[0],s.points[3*c]=n[0],s.points[3*c+1]=n[1],s.points[3*c+2]=n[2],s.tcoords[2*c]=l.tcoords[6],s.tcoords[2*c+1]=l.tcoords[7],c++,s.polys[4*u]=3,s.polys[4*u+1]=c-4,s.polys[4*u+2]=c-3,s.polys[4*u+3]=c-2,u++,s.polys[4*u]=3,s.polys[4*u+1]=c-4,s.polys[4*u+2]=c-2,s.polys[4*u+3]=c-1,s.ptIdx+=4,s.cellIdx+=2};const r=new Float64Array(3);e.updatePolyDataForLabels=()=>{const n=e.getTickStrings().length+t.barSegments.length,o=4*n,a=2*n,i=new Float64Array(3*o),s=new Uint16Array(4*a),l=new Float32Array(2*o),c={ptIdx:0,cellIdx:0,polys:s,points:i,tcoords:l},u=t.vertical?0:1,d=t.vertical?1:0;r[2]=-.99;const p=t.vertical?[&quot;right&quot;,&quot;middle&quot;]:[&quot;middle&quot;,&quot;bottom&quot;];let f=[0,1];const g=[0,0];t.vertical?(g[0]=-t.tickLabelPixelOffset,t.topTitle?(r[0]=t.boxPosition[0]+.5*t.boxSize[0],r[1]=t.barPosition[1]+t.barSize[1],e.createPolyDataForOneLabel(t.renderable.getAxisLabel(),r,[&quot;middle&quot;,&quot;bottom&quot;],&quot;horizontal&quot;,[0,t.axisTitlePixelOffset],c)):(r[0]=t.barPosition[0]+t.barSize[0],r[1]=t.barPosition[1]+.5*t.barSize[1],e.createPolyDataForOneLabel(t.renderable.getAxisLabel(),r,[&quot;middle&quot;,&quot;top&quot;],&quot;vertical&quot;,[t.axisTitlePixelOffset,0],c)),f=[-1,0]):(g[1]=t.tickLabelPixelOffset,r[0]=t.barPosition[0]+.5*t.barSize[0],r[1]=t.barPosition[1]+t.barSize[1],e.createPolyDataForOneLabel(t.renderable.getAxisLabel(),r,[&quot;middle&quot;,&quot;bottom&quot;],&quot;horizontal&quot;,[0,t.axisTitlePixelOffset],c)),r[u]=t.barPosition[u]+(.5*f[u]+.5)*t.barSize[u],r[d]=t.barPosition[d]+.5*t.barSize[d];let m=null;for(let n=0;n<t.barSegments.length;n++){const o=t.barSegments[n];&quot;ticks&quot;===o.title?m=o:(r[d]=t.barPosition[d]+.5*t.barSize[d]*(o.corners[2][d]+o.corners[0][d]),e.createPolyDataForOneLabel(o.title,r,p,&quot;horizontal&quot;,g,c))}const h=t.barPosition[d]+t.barSize[d]*m.corners[0][d],v=t.barSize[d]*(m.corners[2][d]-m.corners[0][d]),T=e.getTicks(),y=e.getTickStrings(),b=e.getTickPositions();for(let n=0;n<T.length;n++){const o=b?b[n]:(T[n]-t.lastTickBounds[0])/(t.lastTickBounds[1]-t.lastTickBounds[0]);r[d]=h+v*o,e.createPolyDataForOneLabel(y[n],r,p,&quot;horizontal&quot;,g,c)}const x=xs.newInstance({numberOfComponents:2,values:l,name:&quot;TextureCoordinates&quot;});t.tmPolyData.getPointData().setTCoords(x),t.tmPolyData.getPoints().setData(i,3),t.tmPolyData.getPoints().modified(),t.tmPolyData.getPolys().setData(s,1),t.tmPolyData.getPolys().modified(),t.tmPolyData.modified()},e.updatePolyDataForBarSegments=()=>{const e=t.renderable.getScalarsToColors();let n=0;t.renderable.getDrawNanAnnotation()&&e.getNanColor()&&(n+=1),t.renderable.getDrawBelowRangeSwatch()&&e.getUseBelowRangeColor?.()&&(n+=1),t.renderable.getDrawAboveRangeSwatch()&&e.getUseAboveRangeColor?.()&&(n+=1);const o=4*(1+n),a=o;let i=1;e.getVectorMode()===op.COMPONENT&&(i=e.getVectorComponent()+1);const s=new Float64Array(3*o),l=new Uint16Array(5*a),c=new Float32Array(o*i);let u=0,d=0;for(let e=0;e<t.barSegments.length;e++){const n=t.barSegments[e];for(let e=0;e<4;e++){r[0]=t.barPosition[0]+n.corners[e][0]*t.barSize[0],r[1]=t.barPosition[1]+n.corners[e][1]*t.barSize[1],s[3*u]=(.5*r[0]+.5)*t.lastSize[0],s[3*u+1]=(.5*r[1]+.5)*t.lastSize[1],s[3*u+2]=r[2];for(let r=0;r<i;r++)c[u*i+r]=t.lastTickBounds[0]+n.scalars[e]*(t.lastTickBounds[1]-t.lastTickBounds[0]);u++}l[5*d]=4,l[5*d+1]=u-4,l[5*d+2]=u-3,l[5*d+3]=u-2,l[5*d+4]=u-1,d++}const p=xs.newInstance({numberOfComponents:i,values:c,name:&quot;Scalars&quot;});t.polyData.getPointData().setScalars(p),t.polyData.getPoints().setData(s,3),t.polyData.getPoints().modified(),t.polyData.getPolys().setData(l,1),t.polyData.getPolys().modified(),t.polyData.modified()}}(e,t)}),&quot;vtkScalarBarActorHelper&quot;);function up(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,function(e){return{automated:!0,autoLayout:null,axisLabel:&quot;Scalar Value&quot;,barPosition:[0,0],barSize:[0,0],boxPosition:[.88,-.92],boxSize:[.1,1.1],scalarToColors:null,axisTitlePixelOffset:36,axisTextStyle:{fontColor:&quot;white&quot;,fontStyle:&quot;normal&quot;,fontSize:void 0,fontFamily:&quot;serif&quot;},tickLabelPixelOffset:14,tickTextStyle:{fontColor:&quot;white&quot;,fontStyle:&quot;normal&quot;,fontSize:void 0,fontFamily:&quot;serif&quot;},generateTicks:null,drawNanAnnotation:!0,drawBelowRangeSwatch:!0,drawAboveRangeSwatch:!0,orientation:null,...e}}(n)),t.autoLayout||(t.autoLayout=sp(0,t)),t.generateTicks||(t.generateTicks=lp()),ss.extend(e,t,n),e.getProperty().setDiffuse(0),e.getProperty().setAmbient(1),Wt.setGet(e,t,[&quot;automated&quot;,&quot;autoLayout&quot;,&quot;axisTitlePixelOffset&quot;,&quot;axisLabel&quot;,&quot;scalarsToColors&quot;,&quot;tickLabelPixelOffset&quot;,&quot;generateTicks&quot;,&quot;drawNanAnnotation&quot;,&quot;drawBelowRangeSwatch&quot;,&quot;drawAboveRangeSwatch&quot;,&quot;orientation&quot;]),Wt.get(e,t,[&quot;axisTextStyle&quot;,&quot;tickTextStyle&quot;]),Wt.getArray(e,t,[&quot;barPosition&quot;,&quot;barSize&quot;,&quot;boxPosition&quot;,&quot;boxSize&quot;]),Wt.setArray(e,t,[&quot;barPosition&quot;,&quot;barSize&quot;,&quot;boxPosition&quot;,&quot;boxSize&quot;],2),function(e,t){t.classHierarchy.push(&quot;vtkScalarBarActor&quot;),e.setTickTextStyle=n=>{t.tickTextStyle={...t.tickTextStyle,...n},e.modified()},e.setAxisTextStyle=n=>{t.axisTextStyle={...t.axisTextStyle,...n},e.modified()},e.setOrientationToHorizontal=()=>e.setOrientation(ap.HORIZONTAL),e.setOrientationToVertical=()=>e.setOrientation(ap.VERTICAL),e.resetAutoLayoutToDefault=()=>{e.setAutoLayout(sp(0,t))},e.resetGenerateTicksToDefault=()=>{e.setGenerateTicks(lp())}}(e,t)}var dp={newInstance:Wt.newInstance(up,&quot;vtkScalarBarActor&quot;),extend:up,newScalarBarActorHelper:cp,...rp};const pp={};const fp=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,pp,n),qt.extend(e,t,n),t.scalarBarActorHelper=dp.newScalarBarActorHelper(),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLScalarBarActor&quot;),e.buildPass=n=>{n&&(t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getParent(),t.scalarBarActorHelper.getRenderable()||t.scalarBarActorHelper.setRenderable(t.renderable),e.prepareNodes(),e.addMissingNode(t.scalarBarActorHelper.getBarActor()),e.addMissingNode(t.scalarBarActorHelper.getTmActor()),e.removeUnusedNodes())},e.opaquePass=(e,n)=>{if(e){const e=t._openGLRenderer?t._openGLRenderer.getRenderable().getActiveCamera():null,n=t._openGLRenderer.getTiledSizeAndOrigin();t.scalarBarActorHelper.updateAPISpecificData([n.usize,n.vsize],e,t._openGLRenderWindow.getRenderable())}}}(e,t)}),&quot;vtkOpenGLScalarBarActor&quot;);Jt(&quot;vtkScalarBarActor&quot;,fp);const{vtkErrorMacro:gp}=Ht,mp={context:null};const hp=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,mp,n),qt.extend(e,t,n),t.openGLTexture=Pd.newInstance(),t.tris=ld.newInstance(),t.keyMatrixTime={},ht(t.keyMatrixTime,{mtime:0}),t.keyMatrices={normalMatrix:fe(new Float64Array(9)),mcwc:m(new Float64Array(16))},Ct(e,t,[&quot;context&quot;]),Tt(e,t,[&quot;activeTextures&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLSkybox&quot;),e.buildPass=n=>{if(n){t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getParent(),t.context=t._openGLRenderWindow.getContext(),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow),t.openGLTexture.setOpenGLRenderWindow(t._openGLRenderWindow);const n=t._openGLRenderer.getRenderable();t.openGLCamera=t._openGLRenderer.getViewNodeFor(n.getActiveCamera())}},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;n.incrementOpaqueActorCount()}},e.opaquePass=(n,r)=>{if(n&&!t._openGLRenderer.getSelector()){e.updateBufferObjects(),t.context.depthMask(!0),t._openGLRenderWindow.getShaderCache().readyShaderProgram(t.tris.getProgram()),t.openGLTexture.render(t._openGLRenderWindow);const n=t.openGLTexture.getTextureUnit();t.tris.getProgram().setUniformi(&quot;sbtexture&quot;,n);const r=t._openGLRenderer.getRenderable(),o=t.openGLCamera.getKeyMatrices(r),a=new Float64Array(16);if(v(a,o.wcpc),t.tris.getProgram().setUniformMatrix(&quot;IMCPCMatrix&quot;,a),&quot;box&quot;===t.lastFormat){const e=r.getActiveCamera().getPosition();t.tris.getProgram().setUniform3f(&quot;camPos&quot;,e[0],e[1],e[2])}t.tris.getVAO().bind(),t.context.drawArrays(t.context.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release(),t.openGLTexture.deactivate()}},e.updateBufferObjects=()=>{if(!t.tris.getCABO().getElementCount()){const e=new Float32Array(12);for(let t=0;t<4;t++)e[3*t]=t%2*2-1,e[3*t+1]=t>1?1:-1,e[3*t+2]=1;const n=xs.newInstance({numberOfComponents:3,values:e});n.setName(&quot;points&quot;);const r=new Uint16Array(8);r[0]=3,r[1]=0,r[2]=1,r[3]=3,r[4]=3,r[5]=0,r[6]=3,r[7]=2;const o=xs.newInstance({numberOfComponents:1,values:r});t.tris.getCABO().createVBO(o,&quot;polys&quot;,Zi.SURFACE,{points:n,cellOffset:0})}t.renderable.getFormat()!==t.lastFormat&&(t.lastFormat=t.renderable.getFormat(),&quot;box&quot;===t.lastFormat&&t.tris.setProgram(t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(&quot;//VTK::System::Dec\\n             attribute vec3 vertexMC;\\n             uniform mat4 IMCPCMatrix;\\n             varying vec3 TexCoords;\\n             void main () {\\n              gl_Position = vec4(vertexMC.xyz, 1.0);\\n              vec4 wpos = IMCPCMatrix * gl_Position;\\n              TexCoords = wpos.xyz/wpos.w;\\n             }&quot;,&quot;//VTK::System::Dec\\n             //VTK::Output::Dec\\n             varying vec3 TexCoords;\\n             uniform samplerCube sbtexture;\\n             uniform vec3 camPos;\\n             void main () {\\n               // skybox looks from inside out\\n               // which means we have to adjust\\n               // our tcoords. Otherwise text would\\n               // be flipped\\n               vec3 tc = normalize(TexCoords - camPos);\\n               if (abs(tc.z) < max(abs(tc.x),abs(tc.y)))\\n               {\\n                 tc = vec3(1.0, 1.0, -1.0) * tc;\\n               }\\n               else\\n               {\\n                 tc = vec3(-1.0, 1.0, 1.0) * tc;\\n               }\\n               gl_FragData[0] = textureCube(sbtexture, tc);\\n             }&quot;,&quot;&quot;)),&quot;background&quot;===t.lastFormat&&t.tris.setProgram(t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(&quot;//VTK::System::Dec\\n             attribute vec3 vertexMC;\\n             uniform mat4 IMCPCMatrix;\\n             varying vec2 TexCoords;\\n             void main () {\\n              gl_Position = vec4(vertexMC.xyz, 1.0);\\n              vec4 wpos = IMCPCMatrix * gl_Position;\\n              TexCoords = vec2(vertexMC.x, vertexMC.y)*0.5 + 0.5;\\n             }&quot;,&quot;//VTK::System::Dec\\n             //VTK::Output::Dec\\n             varying vec2 TexCoords;\\n             uniform sampler2D sbtexture;\\n             void main () {\\n               gl_FragData[0] = texture2D(sbtexture, TexCoords);\\n             }&quot;,&quot;&quot;)),t.tris.getShaderSourceTime().modified(),t.tris.getVAO().bind(),t.tris.getVAO().addAttributeArray(t.tris.getProgram(),t.tris.getCABO(),&quot;vertexMC&quot;,t.tris.getCABO().getVertexOffset(),t.tris.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||gp(&quot;Error setting vertexMC in shader VAO.&quot;));const e=t.renderable.getTextures();e.length||gp(&quot;vtkSkybox requires a texture map&quot;),t.openGLTexture.getRenderable()!==e[0]&&(t.openGLTexture.releaseGraphicsResources(t._openGLRenderWindow),t.openGLTexture.setRenderable(e[0]))}}(e,t)}));Jt(&quot;vtkSkybox&quot;,hp);const{FieldAssociations:vp}=Us,Tp={fieldAssociation:vp.FIELD_ASSOCIATION_CELLS,captureZValues:!1};function yp(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Tp,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;fieldAssociation&quot;,&quot;captureZValues&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkHardwareSelector&quot;),e.getSourceDataAsync=async(e,t,n,r,o)=>{},e.selectAsync=async(t,n,r,o,a)=>{const i=await e.getSourceDataAsync(t,n,r,o,a);return i?i.generateSelection(n,r,o,a):[]}}(e,t)}var bp={newInstance:Wt.newInstance(yp,&quot;vtkHardwareSelector&quot;),extend:yp};const xp={glFramebuffer:null,colorBuffers:null,depthTexture:null,previousDrawBinding:0,previousReadBinding:0,previousDrawBuffer:0,previousReadBuffer:0,previousActiveFramebuffer:null};function Cp(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,xp,n),ht(e,t),t.colorBuffers&&et(&quot;you cannot initialize colorBuffers through the constructor. You should call setColorBuffer() instead.&quot;),t.colorBuffers=[],St(e,t,[&quot;colorBuffers&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkFramebuffer&quot;),e.getBothMode=()=>t.context.FRAMEBUFFER,e.saveCurrentBindingsAndBuffers=t=>{const n=void 0!==t?t:e.getBothMode();e.saveCurrentBindings(n),e.saveCurrentBuffers(n)},e.saveCurrentBindings=e=>{if(!t.context)return void et(&quot;you must set the OpenGLRenderWindow before calling saveCurrentBindings&quot;);const n=t.context;t.previousDrawBinding=n.getParameter(t.context.FRAMEBUFFER_BINDING),t.previousActiveFramebuffer=t._openGLRenderWindow.getActiveFramebuffer()},e.saveCurrentBuffers=e=>{},e.restorePreviousBindingsAndBuffers=t=>{const n=void 0!==t?t:e.getBothMode();e.restorePreviousBindings(n),e.restorePreviousBuffers(n)},e.restorePreviousBindings=e=>{if(!t.context)return void et(&quot;you must set the OpenGLRenderWindow before calling restorePreviousBindings&quot;);const n=t.context;n.bindFramebuffer(n.FRAMEBUFFER,t.previousDrawBinding),t._openGLRenderWindow.setActiveFramebuffer(t.previousActiveFramebuffer)},e.restorePreviousBuffers=e=>{},e.bind=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:null;null===n&&(n=t.context.FRAMEBUFFER),t.context.bindFramebuffer(n,t.glFramebuffer);for(let e=0;e<t.colorBuffers.length;e++)t.colorBuffers[e].bind();t._openGLRenderWindow.setActiveFramebuffer(e)},e.create=(e,n)=>{t.context?(t.glFramebuffer=t.context.createFramebuffer(),t.glFramebuffer.width=e,t.glFramebuffer.height=n):et(&quot;you must set the OpenGLRenderWindow before calling create&quot;)},e.setColorBuffer=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;const r=t.context;if(!r)return void et(&quot;you must set the OpenGLRenderWindow before calling setColorBuffer&quot;);let o=r.COLOR_ATTACHMENT0;if(n>0){if(!t._openGLRenderWindow.getWebgl2())return void et(&quot;Using multiple framebuffer attachments requires WebGL 2&quot;);o+=n}t.colorBuffers[n]=e,r.framebufferTexture2D(r.FRAMEBUFFER,o,r.TEXTURE_2D,e.getHandle(),0)},e.removeColorBuffer=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;const n=t.context;if(!n)return void et(&quot;you must set the OpenGLRenderWindow before calling removeColorBuffer&quot;);let r=n.COLOR_ATTACHMENT0;if(e>0){if(!t._openGLRenderWindow.getWebgl2())return void et(&quot;Using multiple framebuffer attachments requires WebGL 2&quot;);r+=e}n.framebufferTexture2D(n.FRAMEBUFFER,r,n.TEXTURE_2D,null,0),t.colorBuffers=t.colorBuffers.splice(e,1)},e.setDepthBuffer=e=>{if(t.context)if(t._openGLRenderWindow.getWebgl2()){const n=t.context;n.framebufferTexture2D(n.FRAMEBUFFER,n.DEPTH_ATTACHMENT,n.TEXTURE_2D,e.getHandle(),0)}else et(&quot;Attaching depth buffer textures to fbo requires WebGL 2&quot;);else et(&quot;you must set the OpenGLRenderWindow before calling setDepthBuffer&quot;)},e.removeDepthBuffer=()=>{if(t.context)if(t._openGLRenderWindow.getWebgl2()){const e=t.context;e.framebufferTexture2D(e.FRAMEBUFFER,e.DEPTH_ATTACHMENT,e.TEXTURE_2D,null,0)}else et(&quot;Attaching depth buffer textures to framebuffers requires WebGL 2&quot;);else et(&quot;you must set the OpenGLRenderWindow before calling removeDepthBuffer&quot;)},e.getGLFramebuffer=()=>t.glFramebuffer,e.setOpenGLRenderWindow=n=>{t._openGLRenderWindow!==n&&(e.releaseGraphicsResources(),t._openGLRenderWindow=n,t.context=null,n&&(t.context=t._openGLRenderWindow.getContext()))},e.releaseGraphicsResources=()=>{t.glFramebuffer&&t.context.deleteFramebuffer(t.glFramebuffer)},e.getSize=()=>null==t.glFramebuffer?null:[t.glFramebuffer.width,t.glFramebuffer.height],e.populateFramebuffer=()=>{if(!t.context)return void et(&quot;you must set the OpenGLRenderWindow before calling populateFrameBuffer&quot;);e.bind();const n=t.context,r=Pd.newInstance();r.setOpenGLRenderWindow(t._openGLRenderWindow),r.setMinificationFilter(ud.LINEAR),r.setMagnificationFilter(ud.LINEAR),r.create2DFromRaw({width:t.glFramebuffer.width,height:t.glFramebuffer.height,numComps:4,dataType:cs.UNSIGNED_CHAR,data:null}),e.setColorBuffer(r),t.depthTexture=n.createRenderbuffer(),n.bindRenderbuffer(n.RENDERBUFFER,t.depthTexture),n.renderbufferStorage(n.RENDERBUFFER,n.DEPTH_COMPONENT16,t.glFramebuffer.width,t.glFramebuffer.height),n.framebufferRenderbuffer(n.FRAMEBUFFER,n.DEPTH_ATTACHMENT,n.RENDERBUFFER,t.depthTexture)},e.getColorTexture=()=>t.colorBuffers[0]}(e,t)}var Sp={newInstance:Mt(Cp,&quot;vtkFramebuffer&quot;),extend:Cp};const Ap={contentType:-1,fieldType:-1,properties:null,selectionList:[]};function Ip(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ap,n),Wt.obj(e,t),t.properties={},Wt.setGet(e,t,[&quot;contentType&quot;,&quot;fieldType&quot;,&quot;properties&quot;,&quot;selectionList&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkSelectionNode&quot;),e.getBounds=()=>t.points.getBounds()}(e,t)}var wp={newInstance:Wt.newInstance(Ip,&quot;vtkSelectionNode&quot;),extend:Ip,SelectionContent:{GLOBALIDS:0,PEDIGREEIDS:1,VALUES:2,INDICES:3,FRUSTUM:4,LOCATIONS:5,THRESHOLDS:6,BLOCKS:7,QUERY:8},SelectionField:{CELL:0,POINT:1,FIELD:2,VERTEX:3,EDGE:4,ROW:5}};const{PassTypes:Op}=Il,{SelectionContent:Pp,SelectionField:Rp}=wp,{FieldAssociations:Mp}=Us,{vtkErrorMacro:Ep}=Wt;function Vp(e){return`${e.propID} ${e.compositeID}`}function Dp(e,t,n,r){return n?n[4*(t*(r[2]-r[0]+1)+e)+3]:0}function Lp(e,t,n,r){if(!n)return 0;const o=4*(t*(r[2]-r[0]+1)+e),a=n[o],i=n[o+1];return 256*(256*n[o+2]+i)+a}function Bp(e,t){let n=t;return n<<=24,n|=e,n}function Np(e,t,n,r){const o=n<0?0:n;if(0===o){if(r[0]=t[0],r[1]=t[1],t[0]<e.area[0]||t[0]>e.area[2]||t[1]<e.area[1]||t[1]>e.area[3])return null;const n=[t[0]-e.area[0],t[1]-e.area[1]],o=Lp(n[0],n[1],e.pixBuffer[Op.ACTOR_PASS],e.area);if(o<=0||o-1>=e.props.length)return null;const a={valid:!0};a.propID=o-1,a.prop=e.props[a.propID];let i=Lp(n[0],n[1],e.pixBuffer[Op.COMPOSITE_INDEX_PASS],e.area);if((i<0||i>16777215)&&(i=0),a.compositeID=i-1,e.captureZValues){const r=4*(n[1]*(e.area[2]-e.area[0]+1)+n[0]);a.zValue=(256*e.zBuffer[r]+e.zBuffer[r+1])/65535,a.displayPosition=t}if(e.pixBuffer[Op.ID_LOW24]&&0===Dp(n[0],n[1],e.pixBuffer[Op.ID_LOW24],e.area))return a;const s=Lp(n[0],n[1],e.pixBuffer[Op.ID_LOW24],e.area),l=Lp(n[0],n[1],e.pixBuffer[Op.ID_HIGH24],e.area);return a.attributeID=Bp(s,l),a}const a=[t[0],t[1]],i=[0,0];let s=Np(e,t,0,r);if(s&&s.valid)return s;for(let t=1;t<o;++t){for(let n=a[1]>t?a[1]-t:0;n<=a[1]+t;++n){if(i[1]=n,a[0]>=t&&(i[0]=a[0]-t,s=Np(e,i,0,r),s&&s.valid))return s;if(i[0]=a[0]+t,s=Np(e,i,0,r),s&&s.valid)return s}for(let n=a[0]>=t?a[0]-(t-1):0;n<=a[0]+(t-1);++n){if(i[0]=n,a[1]>=t&&(i[1]=a[1]-t,s=Np(e,i,0,r),s&&s.valid))return s;if(i[1]=a[1]+t,s=Np(e,i,0,r),s&&s.valid)return s}}return r[0]=t[0],r[1]=t[1],null}function Fp(e,t,n,r,o){const a=[];let i=0;return t.forEach(((t,s)=>{const l=wp.newInstance();switch(l.setContentType(Pp.INDICES),e){case Mp.FIELD_ASSOCIATION_CELLS:l.setFieldType(Rp.CELL);break;case Mp.FIELD_ASSOCIATION_POINTS:l.setFieldType(Rp.POINT);break;default:Ep(&quot;Unknown field association&quot;)}l.getProperties().propID=t.info.propID,l.getProperties().prop=t.info.prop,l.getProperties().compositeID=t.info.compositeID,l.getProperties().attributeID=t.info.attributeID,l.getProperties().pixelCount=t.pixelCount,n&&(l.getProperties().displayPosition=[t.info.displayPosition[0],t.info.displayPosition[1],t.info.zValue],l.getProperties().worldPosition=o.displayToWorld(t.info.displayPosition[0],t.info.displayPosition[1],t.info.zValue,r)),l.setSelectionList(t.attributeIDs),a[i]=l,i++})),a}const _p={area:void 0,currentPass:-1,propColorValue:null,props:null,maximumPointId:0,maximumCellId:0,idOffset:1};function kp(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,_p,n),bp.extend(e,t,n),t.propColorValue=[0,0,0],t.props=[],t.area||(t.area=[0,0,0,0]),Wt.setGetArray(e,t,[&quot;area&quot;],4),Wt.setGet(e,t,[&quot;_renderer&quot;,&quot;currentPass&quot;,&quot;_openGLRenderWindow&quot;,&quot;maximumPointId&quot;,&quot;maximumCellId&quot;]),Wt.setGetArray(e,t,[&quot;propColorValue&quot;],3),Wt.moveToProtected(e,t,[&quot;renderer&quot;,&quot;openGLRenderWindow&quot;]),Wt.event(e,t,&quot;event&quot;),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLHardwareSelector&quot;),e.releasePixBuffers=()=>{t.rawPixBuffer=[],t.pixBuffer=[],t.zBuffer=null},e.beginSelection=()=>{t._openGLRenderer=t._openGLRenderWindow.getViewNodeFor(t._renderer),t.maxAttributeId=0;const n=t._openGLRenderWindow.getSize();if(t.framebuffer){t.framebuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.framebuffer.saveCurrentBindingsAndBuffers();const e=t.framebuffer.getSize();e&&e[0]===n[0]&&e[1]===n[1]?t.framebuffer.bind():(t.framebuffer.create(n[0],n[1]),t.framebuffer.populateFramebuffer())}else t.framebuffer=Sp.newInstance(),t.framebuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.framebuffer.saveCurrentBindingsAndBuffers(),t.framebuffer.create(n[0],n[1]),t.framebuffer.populateFramebuffer();if(t._openGLRenderer.clear(),t._openGLRenderer.setSelector(e),t.hitProps={},t.propPixels={},t.props=[],e.releasePixBuffers(),t.fieldAssociation===Mp.FIELD_ASSOCIATION_POINTS){const e=t._openGLRenderWindow.getContext(),n=e.isEnabled(e.BLEND);e.disable(e.BLEND),t._openGLRenderWindow.traverseAllPasses(),n&&e.enable(e.BLEND)}},e.endSelection=()=>{t.hitProps={},t._openGLRenderer.setSelector(null),t.framebuffer.restorePreviousBindingsAndBuffers()},e.preCapturePass=()=>{const e=t._openGLRenderWindow.getContext();t.originalBlending=e.isEnabled(e.BLEND),e.disable(e.BLEND)},e.postCapturePass=()=>{const e=t._openGLRenderWindow.getContext();t.originalBlending&&e.enable(e.BLEND)},e.select=()=>{let n=null;return e.captureBuffers()&&(n=e.generateSelection(t.area[0],t.area[1],t.area[2],t.area[3]),e.releasePixBuffers()),n},e.getSourceDataAsync=async(n,r,o,a,i)=>{if(t._renderer=n,void 0===r){const n=t._openGLRenderWindow.getSize();e.setArea(0,0,n[0]-1,n[1]-1)}else e.setArea(r,o,a,i);if(!e.captureBuffers())return!1;const s={area:[...t.area],pixBuffer:[...t.pixBuffer],captureZValues:t.captureZValues,zBuffer:t.zBuffer,props:[...t.props],fieldAssociation:t.fieldAssociation,renderer:n,openGLRenderWindow:t._openGLRenderWindow,generateSelection:function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return function(e,t,n,r,o){const a=Math.floor(t),i=Math.floor(n),s=Math.floor(r),l=Math.floor(o),c=new Map,u=[0,0];for(let t=i;t<=l;t++)for(let n=a;n<=s;n++){const r=Np(e,[n,t],0,u);if(r&&r.valid){const t=Vp(r);if(c.has(t)){const n=c.get(t);n.pixelCount++,e.captureZValues&&r.zValue<n.info.zValue&&(n.info=r),-1===n.attributeIDs.indexOf(r.attributeID)&&n.attributeIDs.push(r.attributeID)}else c.set(t,{info:r,pixelCount:1,attributeIDs:[r.attributeID]})}}return Fp(e.fieldAssociation,c,e.captureZValues,e.renderer,e.openGLRenderWindow)}(s,...t)}};return s},e.captureBuffers=()=>{if(!t._renderer||!t._openGLRenderWindow)return Ep(&quot;Renderer and view must be set before calling Select.&quot;),!1;t._openGLRenderer=t._openGLRenderWindow.getViewNodeFor(t._renderer),t._openGLRenderWindow.getRenderable().preRender(),e.invokeEvent({type:&quot;StartEvent&quot;}),t.originalBackground=t._renderer.getBackgroundByReference(),t._renderer.setBackground(0,0,0,0);const n=t._openGLRenderWindow.getRenderPasses();e.beginSelection();const r=[];for(t.currentPass=Op.MIN_KNOWN_PASS;t.currentPass<=Op.MAX_KNOWN_PASS;t.currentPass++)e.passRequired(t.currentPass)&&(e.preCapturePass(t.currentPass),t.captureZValues&&t.currentPass===Op.ACTOR_PASS&&&quot;function&quot;==typeof n[0].requestDepth&&&quot;function&quot;==typeof n[0].getFramebuffer?(n[0].requestDepth(),t._openGLRenderWindow.traverseAllPasses()):t._openGLRenderWindow.traverseAllPasses(),e.postCapturePass(t.currentPass),e.savePixelBuffer(t.currentPass),r.push(t.currentPass));return r.forEach((n=>{t.currentPass=n,e.processPixelBuffers()})),t.currentPass=Op.MAX_KNOWN_PASS,e.endSelection(),t._renderer.setBackground(t.originalBackground),e.invokeEvent({type:&quot;EndEvent&quot;}),!0},e.processPixelBuffers=()=>{t.props.forEach(((n,r)=>{e.isPropHit(r)&&n.processSelectorPixelBuffers(e,t.propPixels[r])}))},e.passRequired=e=>{if(e===Op.ID_HIGH24){if(t.fieldAssociation===Mp.FIELD_ASSOCIATION_POINTS)return t.maximumPointId>16777215;if(t.fieldAssociation===Mp.FIELD_ASSOCIATION_CELLS)return t.maximumCellId>16777215}return!0},e.savePixelBuffer=n=>{if(t.pixBuffer[n]=t._openGLRenderWindow.getPixelData(t.area[0],t.area[1],t.area[2],t.area[3]),!t.rawPixBuffer[n]){const e=(t.area[2]-t.area[0]+1)*(t.area[3]-t.area[1]+1)*4;t.rawPixBuffer[n]=new Uint8Array(e),t.rawPixBuffer[n].set(t.pixBuffer[n])}if(n===Op.ACTOR_PASS){if(t.captureZValues){const e=t._openGLRenderWindow.getRenderPasses();if(&quot;function&quot;==typeof e[0].requestDepth&&&quot;function&quot;==typeof e[0].getFramebuffer){const n=e[0].getFramebuffer();n.saveCurrentBindingsAndBuffers(),n.bind(),t.zBuffer=t._openGLRenderWindow.getPixelData(t.area[0],t.area[1],t.area[2],t.area[3]),n.restorePreviousBindingsAndBuffers()}}e.buildPropHitList(t.rawPixBuffer[n])}},e.buildPropHitList=e=>{let n=0;for(let r=0;r<=t.area[3]-t.area[1];r++)for(let o=0;o<=t.area[2]-t.area[0];o++){let a=Lp(o,r,e,t.area);a>0&&(a--,a in t.hitProps||(t.hitProps[a]=!0,t.propPixels[a]=[]),t.propPixels[a].push(4*n)),++n}},e.renderProp=n=>{t.currentPass===Op.ACTOR_PASS&&(e.setPropColorValueFromInt(t.props.length+1),t.props.push(n))},e.renderCompositeIndex=n=>{t.currentPass===Op.COMPOSITE_INDEX_PASS&&e.setPropColorValueFromInt(n+1)},e.renderAttributeId=e=>{e<0||(t.maxAttributeId=e>t.maxAttributeId?e:t.maxAttributeId)},e.passTypeToString=e=>Wt.enumToString(Op,e),e.isPropHit=e=>Boolean(t.hitProps[e]),e.setPropColorValueFromInt=e=>{t.propColorValue[0]=e%256/255,t.propColorValue[1]=Math.floor(e/256)%256/255,t.propColorValue[2]=Math.floor(e/65536)%256/255},e.getPixelInformation=(n,r,o)=>{const a=r<0?0:r;if(0===a){if(o[0]=n[0],o[1]=n[1],n[0]<t.area[0]||n[0]>t.area[2]||n[1]<t.area[1]||n[1]>t.area[3])return null;const e=[n[0]-t.area[0],n[1]-t.area[1]],r=Lp(e[0],e[1],t.pixBuffer[Op.ACTOR_PASS],t.area);if(r<=0||r-1>=t.props.length)return null;const a={valid:!0};a.propID=r-1,a.prop=t.props[a.propID];let i=Lp(e[0],e[1],t.pixBuffer[Op.COMPOSITE_INDEX_PASS],t.area);if((i<0||i>16777215)&&(i=0),a.compositeID=i-1,t.captureZValues){const r=4*(e[1]*(t.area[2]-t.area[0]+1)+e[0]);a.zValue=(256*t.zBuffer[r]+t.zBuffer[r+1])/65535,a.displayPosition=n}if(t.pixBuffer[Op.ID_LOW24]&&0===Dp(e[0],e[1],t.pixBuffer[Op.ID_LOW24],t.area))return a;const s=Lp(e[0],e[1],t.pixBuffer[Op.ID_LOW24],t.area),l=Lp(e[0],e[1],t.pixBuffer[Op.ID_HIGH24],t.area);return a.attributeID=Bp(s,l),a}const i=[n[0],n[1]],s=[0,0];let l=e.getPixelInformation(n,0,o);if(l&&l.valid)return l;for(let t=1;t<a;++t){for(let n=i[1]>t?i[1]-t:0;n<=i[1]+t;++n){if(s[1]=n,i[0]>=t&&(s[0]=i[0]-t,l=e.getPixelInformation(s,0,o),l&&l.valid))return l;if(s[0]=i[0]+t,l=e.getPixelInformation(s,0,o),l&&l.valid)return l}for(let n=i[0]>=t?i[0]-(t-1):0;n<=i[0]+(t-1);++n){if(s[0]=n,i[1]>=t&&(s[1]=i[1]-t,l=e.getPixelInformation(s,0,o),l&&l.valid))return l;if(s[1]=i[1]+t,l=e.getPixelInformation(s,0,o),l&&l.valid)return l}}return o[0]=n[0],o[1]=n[1],null},e.generateSelection=(n,r,o,a)=>{const i=Math.floor(n),s=Math.floor(r),l=Math.floor(o),c=Math.floor(a),u=new Map,d=[0,0];for(let n=s;n<=c;n++)for(let r=i;r<=l;r++){const o=[r,n],a=e.getPixelInformation(o,0,d);if(a&&a.valid){const e=Vp(a);if(u.has(e)){const n=u.get(e);n.pixelCount++,t.captureZValues&&a.zValue<n.info.zValue&&(n.info=a),-1===n.attributeIDs.indexOf(a.attributeID)&&n.attributeIDs.push(a.attributeID)}else u.set(e,{info:a,pixelCount:1,attributeIDs:[a.attributeID]})}}return Fp(t.fieldAssociation,u,t.captureZValues,t._renderer,t._openGLRenderWindow)},e.getRawPixelBuffer=e=>t.rawPixBuffer[e],e.getPixelBuffer=e=>t.pixBuffer[e],e.attach=(e,n)=>{t._openGLRenderWindow=e,t._renderer=n};const n=e.setArea;e.setArea=function(){return!!n(...arguments)&&(t.area[0]=Math.floor(t.area[0]),t.area[1]=Math.floor(t.area[1]),t.area[2]=Math.floor(t.area[2]),t.area[3]=Math.floor(t.area[3]),!0)}}(e,t)}var Gp={newInstance:Wt.newInstance(kp,&quot;vtkOpenGLHardwareSelector&quot;),extend:kp,...Il};const{vtkErrorMacro:Up}=Ht,{Representation:zp}=os,{ObjectType:Wp}=zu,{PassTypes:Hp}=Gp,jp={type:&quot;StartEvent&quot;},Kp={type:&quot;EndEvent&quot;};function $p(e,t,n){e[12]=(e[12]-t[0])*n[0],e[13]=(e[13]-t[1])*n[1],e[14]=(e[14]-t[2])*n[2],e[0]*=n[0],e[5]*=n[1],e[10]*=n[2]}const qp={normalMatrix:null,mcpcMatrix:null,mcwcMatrix:null};const Xp=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,qp,n),$d.extend(e,t,n),t.tmpMat3=fe(new Float64Array(9)),t.normalMatrix=fe(new Float64Array(9)),t.mcpcMatrix=m(new Float64Array(16)),t.mcvcMatrix=m(new Float64Array(16)),t.tmpColor=[],t.glyphBOBuildTime={},ht(t.glyphBOBuildTime,{mtime:0}),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLGlyph3DMapper&quot;);const n={...e};e.renderPiece=(n,r)=>{if(e.invokeEvent(jp),t.renderable.getStatic()||t.renderable.update(),t.currentInput=t.renderable.getInputData(1),e.invokeEvent(Kp),!t.currentInput)return void Up(&quot;No input!&quot;);if(!t.currentInput.getPoints||!t.currentInput.getPoints().getNumberOfValues())return;const o=t.context;t._openGLRenderWindow.getWebgl2()?(t.hardwareSupport=!0,t.extension=null):t.extension||(t.extension=t.context.getExtension(&quot;ANGLE_instanced_arrays&quot;),t.hardwareSupport=!!t.extension);const a=r.getProperty().getBackfaceCulling(),i=r.getProperty().getFrontfaceCulling();a||i?i?(t._openGLRenderWindow.enableCullFace(),o.cullFace(o.FRONT)):(t._openGLRenderWindow.enableCullFace(),o.cullFace(o.BACK)):t._openGLRenderWindow.disableCullFace(),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r)},e.multiply4x4WithOffset=(e,t,n,r)=>{const o=t[0],a=t[1],i=t[2],s=t[3],l=t[4],c=t[5],u=t[6],d=t[7],p=t[8],f=t[9],g=t[10],m=t[11],h=t[12],v=t[13],T=t[14],y=t[15];let b=n[r],x=n[r+1],C=n[r+2],S=n[r+3];e[0]=b*o+x*l+C*p+S*h,e[1]=b*a+x*c+C*f+S*v,e[2]=b*i+x*u+C*g+S*T,e[3]=b*s+x*d+C*m+S*y,b=n[r+4],x=n[r+5],C=n[r+6],S=n[r+7],e[4]=b*o+x*l+C*p+S*h,e[5]=b*a+x*c+C*f+S*v,e[6]=b*i+x*u+C*g+S*T,e[7]=b*s+x*d+C*m+S*y,b=n[r+8],x=n[r+9],C=n[r+10],S=n[r+11],e[8]=b*o+x*l+C*p+S*h,e[9]=b*a+x*c+C*f+S*v,e[10]=b*i+x*u+C*g+S*T,e[11]=b*s+x*d+C*m+S*y,b=n[r+12],x=n[r+13],C=n[r+14],S=n[r+15],e[12]=b*o+x*l+C*p+S*h,e[13]=b*a+x*c+C*f+S*v,e[14]=b*i+x*u+C*g+S*T,e[15]=b*s+x*d+C*m+S*y},e.replaceShaderNormal=(e,r,o)=>{if(t.hardwareSupport&&t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;)>0){let n=e.Vertex;t.lastBoundBO.getCABO().getNormalOffset()&&(n=td.substitute(n,&quot;//VTK::Normal::Dec&quot;,[&quot;attribute vec3 normalMC;&quot;,&quot;attribute mat3 gNormal;&quot;,&quot;uniform mat3 normalMatrix;&quot;,&quot;varying vec3 normalVCVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::Normal::Impl&quot;,[&quot;normalVCVSOutput = normalMatrix * gNormal * normalMC;&quot;]).result),e.Vertex=n}n.replaceShaderNormal(e,r,o)},e.replaceShaderClip=(e,r,o)=>{if(t.hardwareSupport){let n=e.Vertex,r=e.Fragment;if(t.renderable.getNumberOfClippingPlanes()){const e=t.renderable.getNumberOfClippingPlanes();n=td.substitute(n,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,`uniform vec4 clipPlanes[${e}];`,`varying float clipDistancesVSOutput[${e}];`]).result,n=td.substitute(n,&quot;//VTK::Clip::Impl&quot;,[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    vec4 gVertex = gMatrix * vertexMC;&quot;,&quot;    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], gVertex);&quot;,&quot;    }&quot;]).result,r=td.substitute(r,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,`varying float clipDistancesVSOutput[${e}];`]).result,r=td.substitute(r,&quot;//VTK::Clip::Impl&quot;,[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    if (clipDistancesVSOutput[planeNum] < 0.0) discard;&quot;,&quot;    }&quot;]).result}e.Vertex=n,e.Fragment=r}n.replaceShaderClip(e,r,o)},e.replaceShaderColor=(e,r,o)=>{if(t.hardwareSupport&&t.renderable.getColorArray()){let n=e.Vertex,r=e.Geometry,o=e.Fragment;const a=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);let i=[&quot;uniform float ambient;&quot;,&quot;uniform float diffuse;&quot;,&quot;uniform float specular;&quot;,&quot;uniform float opacityUniform; // the fragment opacity&quot;];a&&(i=i.concat([&quot;uniform vec3 specularColorUniform;&quot;,&quot;uniform float specularPowerUniform;&quot;]));let s=[&quot;vec3 ambientColor;&quot;,&quot;  vec3 diffuseColor;&quot;,&quot;  float opacity;&quot;];a&&(s=s.concat([&quot;  vec3 specularColor;&quot;,&quot;  float specularPower;&quot;])),s=s.concat([&quot;  opacity = opacityUniform;&quot;]),a&&(s=s.concat([&quot;  specularColor = specularColorUniform;&quot;,&quot;  specularPower = specularPowerUniform;&quot;])),t.drawingEdges||(i=i.concat([&quot;varying vec4 vertexColorVSOutput;&quot;]),n=td.substitute(n,&quot;//VTK::Color::Dec&quot;,[&quot;attribute vec4 gColor;&quot;,&quot;varying vec4 vertexColorVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorVSOutput = gColor;&quot;]).result,r=td.substitute(r,&quot;//VTK::Color::Dec&quot;,[&quot;in vec4 vertexColorVSOutput[];&quot;,&quot;out vec4 vertexColorGSOutput;&quot;]).result,r=td.substitute(r,&quot;//VTK::Color::Impl&quot;,[&quot;vertexColorGSOutput = vertexColorVSOutput[i];&quot;]).result,s=s.concat([&quot;  diffuseColor = vertexColorVSOutput.rgb;&quot;,&quot;  ambientColor = vertexColorVSOutput.rgb;&quot;,&quot;  opacity = opacity*vertexColorVSOutput.a;&quot;])),o=td.substitute(o,&quot;//VTK::Color::Impl&quot;,s).result,o=td.substitute(o,&quot;//VTK::Color::Dec&quot;,i).result,e.Vertex=n,e.Geometry=r,e.Fragment=o}n.replaceShaderColor(e,r,o)},e.replaceShaderPositionVC=(e,r,o)=>{if(t.hardwareSupport){let n=e.Vertex;t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;)>0?(n=td.substitute(n,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vec4 gVertexMC = gMatrix * vertexMC;&quot;,&quot;vertexVCVSOutput = MCVCMatrix * gVertexMC;&quot;,&quot;  gl_Position = MCPCMatrix * gVertexMC;&quot;]).result,n=td.substitute(n,&quot;//VTK::Camera::Dec&quot;,[&quot;attribute mat4 gMatrix;&quot;,&quot;uniform mat4 MCPCMatrix;&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result):(n=td.substitute(n,&quot;//VTK::Camera::Dec&quot;,[&quot;attribute mat4 gMatrix;&quot;,&quot;uniform mat4 MCPCMatrix;&quot;]).result,n=td.substitute(n,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vec4 gVertexMC = gMatrix * vertexMC;&quot;,&quot;  gl_Position = MCPCMatrix * gVertexMC;&quot;]).result),e.Vertex=n}n.replaceShaderPositionVC(e,r,o)},e.replaceShaderPicking=(e,r,o)=>{if(t.hardwareSupport){let t=e.Fragment,n=e.Vertex;n=td.substitute(n,&quot;//VTK::Picking::Dec&quot;,[&quot;attribute vec3 mapperIndexVS;&quot;,&quot;varying vec3 mapperIndexVSOutput;&quot;]).result,n=td.substitute(n,&quot;//VTK::Picking::Impl&quot;,&quot;  mapperIndexVSOutput = mapperIndexVS;&quot;).result,e.Vertex=n,t=td.substitute(t,&quot;//VTK::Picking::Dec&quot;,[&quot;varying vec3 mapperIndexVSOutput;&quot;,&quot;uniform vec3 mapperIndex;&quot;,&quot;uniform int picking;&quot;]).result,t=td.substitute(t,&quot;//VTK::Picking::Impl&quot;,[&quot;  vec4 pickColor = picking == 2 ? vec4(mapperIndexVSOutput,1.0) : vec4(mapperIndex,1.0);&quot;,&quot;  gl_FragData[0] = picking != 0 ? pickColor : gl_FragData[0];&quot;]).result,e.Fragment=t}else n.replaceShaderPicking(e,r,o)},e.updateGlyphShaderParameters=(n,r,o,a,i,s,l,c)=>{const u=o.getProgram();if(n){const e=t.normalMatrix,n=s,r=9*l,o=t.tmpMat3,a=e[0],i=e[1],c=e[2],d=e[3],p=e[4],f=e[5],g=e[6],m=e[7],h=e[8],v=n[r],T=n[r+1],y=n[r+2],b=n[r+3],x=n[r+4],C=n[r+5],S=n[r+6],A=n[r+7],I=n[r+8];o[0]=v*a+T*d+y*g,o[1]=v*i+T*p+y*m,o[2]=v*c+T*f+y*h,o[3]=b*a+x*d+C*g,o[4]=b*i+x*p+C*m,o[5]=b*c+x*f+C*h,o[6]=S*a+A*d+I*g,o[7]=S*i+A*p+I*m,o[8]=S*c+A*f+I*h,u.setUniformMatrix3x3(&quot;normalMatrix&quot;,t.tmpMat3)}if(e.multiply4x4WithOffset(t.tmpMat4,t.mcpcMatrix,i,16*l),u.setUniformMatrix(&quot;MCPCMatrix&quot;,t.tmpMat4),r&&(e.multiply4x4WithOffset(t.tmpMat4,t.mcvcMatrix,i,16*l),u.setUniformMatrix(&quot;MCVCMatrix&quot;,t.tmpMat4)),a){const e=a.getData();t.tmpColor[0]=e[4*l]/255,t.tmpColor[1]=e[4*l+1]/255,t.tmpColor[2]=e[4*l+2]/255,u.setUniform3fArray(&quot;ambientColorUniform&quot;,t.tmpColor),u.setUniform3fArray(&quot;diffuseColorUniform&quot;,t.tmpColor)}c&&u.setUniform3fArray(&quot;mapperIndex&quot;,c.getPropColorValue())},e.renderPieceDraw=(n,r)=>{const o=r.getProperty().getRepresentation(),a=t.context,i=r.getProperty().getEdgeVisibility()&&o===zp.SURFACE,s=t.openGLCamera.getKeyMatrices(n),l=t.openGLActor.getKeyMatrices();Te(t.normalMatrix,s.normalMatrix,l.normalMatrix),b(t.mcpcMatrix,s.wcpc,l.mcwc),b(t.mcvcMatrix,s.wcvc,l.mcwc);const c=t.renderable.getMatrixArray(),u=t.renderable.getNormalArray(),d=t.renderable.getColorArray(),p=c.length/16;let f=!1;t._openGLRenderer.getSelector()&&t._openGLRenderer.getSelector().getCurrentPass()===Hp.COMPOSITE_INDEX_PASS&&(f=!0);for(let s=t.primTypes.Start;s<t.primTypes.End;s++){const l=t.primitives[s].getCABO();if(l.getElementCount()){t.drawingEdges=i&&(s===t.primTypes.TrisEdges||s===t.primTypes.TriStripsEdges),t.lastBoundBO=t.primitives[s],t.primitives[s].updateShaders(n,r,e);const g=t.primitives[s].getProgram(),m=t.primitives[s].getOpenGLMode(o),h=g.isUniformUsed(&quot;normalMatrix&quot;),v=g.isUniformUsed(&quot;MCVCMatrix&quot;);if(t.hardwareSupport)t.extension?t.extension.drawArraysInstancedANGLE(m,0,l.getElementCount(),p):a.drawArraysInstanced(m,0,l.getElementCount(),p);else for(let n=0;n<p;++n)f&&t._openGLRenderer.getSelector().renderCompositeIndex(n),e.updateGlyphShaderParameters(h,v,t.primitives[s],d,c,u,n,f?t._openGLRenderer.getSelector():null),a.drawArrays(m,0,l.getElementCount())}}},e.setMapperShaderParameters=(e,r,o)=>{if(e.getCABO().getElementCount()&&(t.glyphBOBuildTime.getMTime()>e.getAttributeUpdateTime().getMTime()||e.getShaderSourceTime().getMTime()>e.getAttributeUpdateTime().getMTime()))return e.getProgram().isAttributeUsed(&quot;gMatrix&quot;)?e.getVAO().addAttributeMatrixWithDivisor(e.getProgram(),t.matrixBuffer,&quot;gMatrix&quot;,0,64,t.context.FLOAT,4,!1,1)||Up(&quot;Error setting gMatrix in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;gMatrix&quot;),e.getProgram().isAttributeUsed(&quot;gNormal&quot;)?e.getVAO().addAttributeMatrixWithDivisor(e.getProgram(),t.normalBuffer,&quot;gNormal&quot;,0,36,t.context.FLOAT,3,!1,1)||Up(&quot;Error setting gNormal in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;gNormal&quot;),e.getProgram().isAttributeUsed(&quot;gColor&quot;)?e.getVAO().addAttributeArrayWithDivisor(e.getProgram(),t.colorBuffer,&quot;gColor&quot;,0,4,t.context.UNSIGNED_BYTE,4,!0,1,!1)||Up(&quot;Error setting gColor in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;gColor&quot;),e.getProgram().isAttributeUsed(&quot;mapperIndexVS&quot;)?e.getVAO().addAttributeArrayWithDivisor(e.getProgram(),t.pickBuffer,&quot;mapperIndexVS&quot;,0,4,t.context.UNSIGNED_BYTE,4,!0,1,!1)||Up(&quot;Error setting mapperIndexVS in shader VAO.&quot;):e.getVAO().removeAttributeArray(&quot;mapperIndexVS&quot;),n.setMapperShaderParameters(e,r,o),void e.getAttributeUpdateTime().modified();n.setMapperShaderParameters(e,r,o)},e.getNeedToRebuildBufferObjects=(e,r)=>(t.renderable.buildArrays(),t.VBOBuildTime.getMTime()<t.renderable.getBuildTime().getMTime()||n.getNeedToRebuildBufferObjects(e,r)),e.getNeedToRebuildShaders=(e,r,o)=>!!(n.getNeedToRebuildShaders(e,r,o)||e.getShaderSourceTime().getMTime()<t.renderable.getMTime()||e.getShaderSourceTime().getMTime()<t.currentInput.getMTime()),e.buildBufferObjects=(e,r)=>{const o=t.renderable.getMatrixArray(),a=t.renderable.getInputData(0).getPoints(),{useShiftAndScale:i,coordShift:s,coordScale:l}=Wu(a);if(t.hardwareSupport){const e=t.renderable.getNormalArray(),n=t.renderable.getColorArray();if(t.matrixBuffer||(t.matrixBuffer=zu.newInstance(),t.matrixBuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.normalBuffer=zu.newInstance(),t.normalBuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.colorBuffer=zu.newInstance(),t.colorBuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.pickBuffer=zu.newInstance(),t.pickBuffer.setOpenGLRenderWindow(t._openGLRenderWindow)),i){const e=o.buffer;for(let t=0;t<o.byteLength;t+=64)$p(new Float32Array(e,t,16),s,l)}if(t.renderable.getBuildTime().getMTime()>t.glyphBOBuildTime.getMTime()){t.matrixBuffer.upload(o,Wp.ARRAY_BUFFER),t.normalBuffer.upload(e,Wp.ARRAY_BUFFER),n?t.colorBuffer.upload(n.getData(),Wp.ARRAY_BUFFER):t.colorBuffer.releaseGraphicsResources();const r=o.length/16,a=new Uint8Array(4*r);for(let e=0;e<r;++e){let t=e+1;const n=4*e;a[n]=t%256,t-=a[n],t/=256,a[n+1]=t%256,t-=a[n+1],t/=256,a[n+2]=t%256,a[n+3]=255}t.pickBuffer.upload(a,Wp.ARRAY_BUFFER),t.glyphBOBuildTime.modified()}}if(n.buildBufferObjects(e,r),i)for(let e=ad.Start;e<ad.End;e++)t.primitives[e].getCABO().setCoordShiftAndScale(s,l)}}(e,t)}),&quot;vtkOpenGLGlyph3DMapper&quot;);Jt(&quot;vtkGlyph3DMapper&quot;,Xp);const{vtkErrorMacro:Yp}=Wt;class Zp{constructor(){this.segmentMapping={},this.segments=[null],this.faces=[]}addSegment(e){const t=e[0],n=e[e.length-1];if(t===n||e.length<2)return;const r=this.segmentMapping[t],o=this.segmentMapping[n];if(void 0!==r&&void 0!==o)if(Math.abs(r)===Math.abs(o)){const a=r<o?o:r,i=this.segments[a];if(r>0)for(let t=1;t<e.length-1;t++)i.push(e[t]);else for(let t=1;t<e.length-1;t++)i.unshift(e[e.length-1-t]);this.faces.push(i),this.segments[a]=null,this.segmentMapping[t]=void 0,this.segmentMapping[n]=void 0}else{const t=Math.abs(r),n=Math.abs(o),a=this.segments[t],i=this.segments[n];this.segments[t]=null,this.segments[n]=null,this.segmentMapping[a[0]]=void 0,this.segmentMapping[i[0]]=void 0,this.segmentMapping[a[a.length-1]]=void 0,this.segmentMapping[i[i.length-1]]=void 0,this.addSegment(e),this.addSegment(a),this.addSegment(i)}else if(void 0!==r){if(r>0){const t=this.segments[r];for(let n=1;n<e.length;n++)t.push(e[n]);this.segmentMapping[n]=r}else{const t=this.segments[-r];this.segmentMapping[n]=r;for(let n=1;n<e.length;n++)t.unshift(e[n])}this.segmentMapping[t]=void 0}else if(void 0!==o){if(o>0){const n=this.segments[o];for(let t=1;t<e.length;t++)n.push(e[e.length-1-t]);this.segmentMapping[t]=o}else{const n=this.segments[-o];this.segmentMapping[t]=o;for(let t=1;t<e.length;t++)n.unshift(e[e.length-t-1])}this.segmentMapping[n]=void 0}else{const r=this.segments.length;this.segments.push(e),this.segmentMapping[t]=-r,this.segmentMapping[n]=r}}}const Qp={};function Jp(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Qp,n),Wt.obj(e,t),Wt.algo(e,t,1,1),function(e,t){t.classHierarchy.push(&quot;vtkClosedPolyLineToSurfaceFilter&quot;),e.requestData=(e,t)=>{const n=e[0];if(!n)return void Yp(&quot;Invalid or missing input&quot;);const r=t[0]?.initialize()||gu.newInstance();r.shallowCopy(n);const o=new Zp,a=n.getLines().getData();let i=0;for(;i<a.length;){const e=a[i++],t=[];for(let n=0;n<e;n++)t.push(a[i+n]);o.addSegment(t),i+=e}const{faces:s}=o;let l=s.length;for(let e=0;e<s.length;e++)l+=s[e].length;const c=new Uint16Array(l);i=0;for(let e=0;e<s.length;e++){const t=s[e];c[i++]=t.length;for(let e=0;e<t.length;e++)c[i++]=t[e]}r.setPolys(Kl.newInstance({values:c,name:&quot;faces&quot;})),t[0]=r}}(e,t)}var ef={newInstance:Wt.newInstance(Jp,&quot;vtkClosedPolyLineToSurfaceFilter&quot;),extend:Jp};const{vtkErrorMacro:tf}=Ht;function nf(e,t){t.classHierarchy.push(&quot;vtkCutter&quot;);const n={...e};e.getMTime=()=>{let e=n.getMTime();return t.cutFunction?(e=Math.max(e,t.cutFunction.getMTime()),e):e},e.requestData=(e,n)=>{const r=e[0];if(!r)return void tf(&quot;Invalid or missing input&quot;);if(!t.cutFunction)return void tf(&quot;Missing cut function&quot;);const o=n[0]?.initialize()||gu.newInstance();(function(e,n){const r=e.getPoints(),o=r.getData(),a=e.getPointData(),i=r.getNumberOfPoints(),s=[],l=[],c=[],u={},d=a.getNumberOfArrays();for(let e=0;e<d;e++)u[a.getArrayName(e)]=[];(!t.cutScalars||t.cutScalars.length<i)&&(t.cutScalars=new Float32Array(i));let p=0,f=0;for(;p<o.length;)t.cutScalars[f++]=t.cutFunction.evaluateFunction(o[p++],o[p++],o[p++]);const g=[],m=new Array(3),h=new Array(3),v=[];for(const n=function(e){const t=e.getPolys().getData(),n=e.getStrips().getData(),r={cellSize:0,cell:[],done:!1,polyIdx:0,stripIdx:0,remainingStripLength:0,next(){if(r.polyIdx<t.length){r.cellSize=t[r.polyIdx];const e=r.polyIdx+1,n=e+r.cellSize;r.polyIdx=n;let o=0;for(let a=e;a<n;++a)r.cell[o++]=t[a]}else if(r.stripIdx<n.length){r.cellSize=3,0===r.remainingStripLength&&(r.remainingStripLength=n[r.stripIdx]-2,r.stripIdx+=3);const e=r.stripIdx-2,t=r.stripIdx+1;r.stripIdx++,r.remainingStripLength--;let o=0;for(let a=e;a<t;++a)r.cell[o++]=n[a]}else{if(r.done)throw new Error(&quot;Iterator is done&quot;);r.done=!0}}};return r.next(),r}(e);!n.done;n.next()){if(n.cellSize<=2)continue;for(let e=0;e<n.cellSize;)v[e]=t.cutScalars[n.cell[e++]];const e=v[0]>0;let r=!0;for(let t=1;t<n.cell.length;t++)if(v[t]>0!==e){r=!1;break}if(r)continue;const i=[];for(let e=0;e<n.cellSize;e++){const r=e+1===n.cellSize?0:e+1,s=v[e]>0;if(v[r]>0===s)continue;let l=e,c=r,u=v[c]-v[l];u<=0&&(l=r,c=e,u*=-1);let p=0;0!==u&&(p=(t.cutValue-v[l])/u);const f=n.cell[l],g=n.cell[c];m[0]=o[3*f],m[1]=o[3*f+1],m[2]=o[3*f+2],h[0]=o[3*g],h[1]=o[3*g+1],h[2]=o[3*g+2];const T=[m[0]+p*(h[0]-m[0]),m[1]+p*(h[1]-m[1]),m[2]+p*(h[2]-m[2])],y={};for(let e=0;e<d;e++){const t=a.getArrayByIndex(e),n=a.getArrayName(e),r=t.getData(),o=t.getNumberOfComponents(),i=new Array(o);for(let e=0;e<o;e++){const t=r[o*f+e],n=r[o*g+e];i.push(t+p*(n-t))}y[n]=i}i.push({pointEdge1:f,pointEdge2:g,intersectedPoint:T,intersectedArrays:y,newPointID:-1})}for(let e=0;e<i.length;e++){const t=i[e];let n=!1;for(let r=0;r<g.length;r++){const o=g[r],a=t.pointEdge1===o.pointEdge1&&t.pointEdge2===o.pointEdge2,s=t.intersectedPoint[0]===o.intersectedPoint[0]&&t.intersectedPoint[1]===o.intersectedPoint[1]&&t.intersectedPoint[2]===o.intersectedPoint[2];if(a||s){n=!0,i[e].newPointID=g[r].newPointID;break}}n||(s.push(t.intersectedPoint[0]),s.push(t.intersectedPoint[1]),s.push(t.intersectedPoint[2]),Object.keys(t.intersectedArrays).forEach((e=>{u[e].push(...t.intersectedArrays[e])})),i[e].newPointID=s.length/3-1,g.push(i[e]))}const p=i.length;2===p?l.push(p,i[0].newPointID,i[1].newPointID):p>2&&(c.push(p),i.forEach((e=>{c.push(e.newPointID)})))}n.getPoints().setData(it(r.getDataType(),s),3);const T=n.getPointData();for(let e=0;e<d;e++){const t=a.getArrayName(e),n=xs.newInstance({name:t,dataType:a.getArrayByIndex(e).getDataType(),values:u[t],numberOfComponents:a.getArrayByIndex(e).getNumberOfComponents()});T.addArray(n)}0!==l.length&&n.getLines().setData(Uint16Array.from(l)),0!==c.length&&n.getPolys().setData(Uint16Array.from(c))})(r,o),n[0]=o}}const rf={cutFunction:null,cutScalars:null,cutValue:0};function of(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,rf,n),ht(e,t),Ot(e,t,1,1),Ct(e,t,[&quot;cutFunction&quot;,&quot;cutValue&quot;]),nf(e,t)}var af={newInstance:Mt(of,&quot;vtkCutter&quot;),extend:of};const sf=e=>e,lf=1e-6;class cf{constructor(){let e=arguments.length>0&&void 0!==arguments[0]&&arguments[0];this.matrix=m(new Float64Array(16)),this.tmp=new Float64Array(3),this.angleConv=e?c:sf}rotateFromDirections(e,t){const n=new Float64Array(3),r=new Float64Array(3),o=new Float64Array(16);hn(n,e[0],e[1],e[2]),hn(r,t[0],t[1],t[2]),Cn(n,n),Cn(r,r);const a=Sn(n,r);return a>=1||(An(this.tmp,n,r),gn(this.tmp)<lf&&(An(this.tmp,[1,0,0],e),gn(this.tmp)<lf&&An(this.tmp,[0,1,0],e)),R(o,Math.acos(a),this.tmp),b(this.matrix,this.matrix,o)),this}rotate(e,t){return hn(this.tmp,...t),Cn(this.tmp,this.tmp),S(this.matrix,this.matrix,this.angleConv(e),this.tmp),this}rotateX(e){return A(this.matrix,this.matrix,this.angleConv(e)),this}rotateY(e){return I(this.matrix,this.matrix,this.angleConv(e)),this}rotateZ(e){return w(this.matrix,this.matrix,this.angleConv(e)),this}translate(e,t,n){return hn(this.tmp,e,t,n),x(this.matrix,this.matrix,this.tmp),this}scale(e,t,n){return hn(this.tmp,e,t,n),C(this.matrix,this.matrix,this.tmp),this}multiply(e){return b(this.matrix,this.matrix,e),this}multiply3x3(e){return b(this.matrix,this.matrix,[e[0],e[1],e[2],0,e[3],e[4],e[5],0,e[6],e[7],e[8],0,0,0,0,1]),this}invert(){return v(this.matrix,this.matrix),this}identity(){return m(this.matrix),this}apply(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:-1;if(Xo(ao,this.matrix))return this;const r=-1===n?e.length:t+3*n;for(let n=t;n<r;n+=3)hn(this.tmp,e[n],e[n+1],e[n+2]),In(this.tmp,this.tmp,this.matrix),e[n]=this.tmp[0],e[n+1]=this.tmp[1],e[n+2]=this.tmp[2];return this}getMatrix(){return this.matrix}setMatrix(e){return e&&16===e.length&&p(this.matrix,e),this}}var uf=function(){return new cf(!0)},df=function(){return new cf(!1)};const pf=[2,0,1,2,2,3,2,4,5,2,6,7,2,0,2,2,1,3,2,4,6,2,5,7,2,0,4,2,1,5,2,2,6,2,3,7],ff=[4,0,1,3,2,4,4,6,7,5,4,8,10,11,9,4,12,13,15,14,4,16,18,19,17,4,20,21,23,22],gf={xLength:1,yLength:1,zLength:1,pointType:&quot;Float64Array&quot;,generate3DTextureCoordinates:!1,generateFaces:!0,generateLines:!1};function mf(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,gf,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;xLength&quot;,&quot;yLength&quot;,&quot;zLength&quot;,&quot;generate3DTextureCoordinates&quot;,&quot;generateFaces&quot;,&quot;generateLines&quot;]),Wt.setGetArray(e,t,[&quot;center&quot;,&quot;rotations&quot;],3),Wt.setGetArray(e,t,[&quot;matrix&quot;],16),t._polys=Kl.newInstance({values:Uint16Array.from(ff)}),t._lineCells=Kl.newInstance({values:Uint16Array.from(pf)}),Wt.moveToProtected(e,t,[&quot;polys&quot;,&quot;lineCells&quot;]),Wt.algo(e,t,0,1),function(e,t){t.classHierarchy.push(&quot;vtkCubeSource&quot;),e.requestData=(e,n)=>{const r=n[0]?.initialize()||gu.newInstance();n[0]=r;const o=Wt.newTypedArray(t.pointType,72);r.getPoints().setData(o,3);const a=Wt.newTypedArray(t.pointType,72),i=xs.newInstance({name:&quot;Normals&quot;,values:a,numberOfComponents:3});r.getPointData().setNormals(i);let s=2;!0===t.generate3DTextureCoordinates&&(s=3);const l=Wt.newTypedArray(t.pointType,24*s),c=xs.newInstance({name:&quot;TextureCoordinates&quot;,values:l,numberOfComponents:s});r.getPointData().setTCoords(c);const u=[0,0,0],d=[0,0,0],p=[0,0];let f=0;u[0]=-t.xLength/2,d[0]=-1,d[1]=0,d[2]=0;for(let e=0;e<2;e++){u[1]=-t.yLength/2;for(let n=0;n<2;n++){p[1]=u[1]+.5,u[2]=-t.zLength/2;for(let r=0;r<2;r++)p[0]=(u[2]+.5)*(1-2*e),o[3*f]=u[0],o[3*f+1]=u[1],o[3*f+2]=u[2],a[3*f]=d[0],a[3*f+1]=d[1],a[3*f+2]=d[2],2===s?(l[f*s]=p[0],l[f*s+1]=p[1]):(l[f*s]=2*e-1,l[f*s+1]=2*n-1,l[f*s+2]=2*r-1),f++,u[2]+=t.zLength;u[1]+=t.yLength}u[0]+=t.xLength,d[0]+=2}u[1]=-t.yLength/2,d[1]=-1,d[0]=0,d[2]=0;for(let e=0;e<2;e++){u[0]=-t.xLength/2;for(let n=0;n<2;n++){p[0]=(u[0]+.5)*(2*e-1),u[2]=-t.zLength/2;for(let r=0;r<2;r++)p[1]=-1*(u[2]+.5),o[3*f]=u[0],o[3*f+1]=u[1],o[3*f+2]=u[2],a[3*f]=d[0],a[3*f+1]=d[1],a[3*f+2]=d[2],2===s?(l[f*s]=p[0],l[f*s+1]=p[1]):(l[f*s]=2*n-1,l[f*s+1]=2*e-1,l[f*s+2]=2*r-1),f++,u[2]+=t.zLength;u[0]+=t.xLength}u[1]+=t.yLength,d[1]+=2}u[2]=-t.zLength/2,d[2]=-1,d[0]=0,d[1]=0;for(let e=0;e<2;e++){u[1]=-t.yLength/2;for(let n=0;n<2;n++){p[1]=u[1]+.5,u[0]=-t.xLength/2;for(let r=0;r<2;r++)p[0]=(u[0]+.5)*(2*e-1),o[3*f]=u[0],o[3*f+1]=u[1],o[3*f+2]=u[2],a[3*f]=d[0],a[3*f+1]=d[1],a[3*f+2]=d[2],2===s?(l[f*s]=p[0],l[f*s+1]=p[1]):(l[f*s]=2*r-1,l[f*s+1]=2*n-1,l[f*s+2]=2*e-1),f++,u[0]+=t.xLength;u[1]+=t.yLength}u[2]+=t.zLength,d[2]+=2}if(t.rotations&&uf().rotateX(t.rotations[0]).rotateY(t.rotations[1]).rotateZ(t.rotations[2]).apply(o).apply(a),t.center&&df().translate(...t.center).apply(o),t.matrix){df().setMatrix(t.matrix).apply(o);const e=[t.matrix[0],t.matrix[1],t.matrix[2],0,t.matrix[4],t.matrix[5],t.matrix[6],0,t.matrix[8],t.matrix[9],t.matrix[10],0,0,0,0,1];df().setMatrix(e).apply(a)}t.generateFaces?r.getPolys().deepCopy(t._polys):r.getPolys().initialize(),t.generateLines?(r.getLines().deepCopy(t._lineCells),r.getPointData().setNormals(null)):r.getLines().initialize(),r.modified()},e.setBounds=function(){let t=[];if(Array.isArray(arguments.length<=0?void 0:arguments[0]))t=arguments.length<=0?void 0:arguments[0];else for(let e=0;e<arguments.length;e++)t.push(e<0||arguments.length<=e?void 0:arguments[e]);6===t.length&&(e.setXLength(t[1]-t[0]),e.setYLength(t[3]-t[2]),e.setZLength(t[5]-t[4]),e.setCenter([(t[0]+t[1])/2,(t[2]+t[3])/2,(t[4]+t[5])/2]))}}(e,t)}var hf={newInstance:Wt.newInstance(mf,&quot;vtkCubeSource&quot;),extend:mf};const{vtkErrorMacro:vf}=Wt,Tf={};function yf(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Tf,n),Wt.obj(e,t),Wt.algo(e,t,1,1),t._cubeSource=hf.newInstance(),Wt.moveToProtected(e,t,[&quot;cubeSource&quot;,&quot;tmpOut&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkImageDataOutlineFilter&quot;);const n={...e};e.requestData=(e,n)=>{const r=e[0];if(!r||!r.isA(&quot;vtkImageData&quot;))return void vf(&quot;Invalid or missing input&quot;);const o=r.getSpatialExtent();o?(t._cubeSource.setBounds(o),t._cubeSource.setMatrix(r.getIndexToWorld()),n[0]=t._cubeSource.getOutputData()):vf(&quot;Unable to fetch spatial extents of input image.&quot;)},e.getMTime=()=>Math.max(n.getMTime(),t._cubeSource.getMTime()),e.setGenerateFaces=t._cubeSource.setGenerateFaces,e.setGenerateLines=t._cubeSource.setGenerateLines,e.getGenerateFaces=t._cubeSource.getGenerateFaces,e.getGenerateLines=t._cubeSource.getGenerateLines}(e,t)}var bf={newInstance:Wt.newInstance(yf,&quot;vtkImageDataOutlineFilter&quot;),extend:yf};const{vtkWarningMacro:xf}=Wt;let Cf;const Sf={preMultiplyFlag:!1,matrix:[...ao]};function Af(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Sf,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;preMultiplyFlag&quot;]),Wt.setGetArray(e,t,[&quot;matrix&quot;],16),function(e,t){t.classHierarchy.push(&quot;vtkAbstractTransform&quot;,&quot;vtkHomogeneousTransform&quot;,&quot;vtkTransform&quot;),e.transformPoint=(e,n)=>(In(n,e,t.matrix),n),e.transformPoints=(e,n)=>{const r=new Float64Array(3),o=new Float64Array(3);for(let a=0;a<e.length;a+=3)r[0]=e[a],r[1]=e[a+1],r[2]=e[a+2],In(o,r,t.matrix),n[a]=o[0],n[a+1]=o[1],n[a+2]=o[2];return n},e.preMultiply=()=>{e.setPreMultiplyFlag(!0)},e.postMultiply=()=>{e.setPreMultiplyFlag(!1)},e.transformMatrix=(e,n)=>(t.preMultiplyFlag?b(n,t.matrix,e):b(n,e,t.matrix),n),e.transformMatrices=(e,n)=>{const r=new Float64Array(16),o=new Float64Array(16),a=t.preMultiplyFlag?()=>b(o,t.matrix,r):()=>b(o,r,t.matrix);for(let t=0;t<e.length;t+=16){for(let n=0;n<16;++n)r[n]=e[t+n];a();for(let e=0;e<16;++e)n[t+e]=o[e]}return n},e.getInverse=()=>Cf({matrix:Da.invertMatrix(Array.from(t.matrix),[],4),preMultiplyFlag:t.preMultiplyFlag}),e.translate=(n,r,o)=>{if(0===n&&0===r&&0===o)return;const a=u();O(a,[n,r,o]),t.preMultiplyFlag?b(t.matrix,t.matrix,a):b(t.matrix,a,t.matrix),e.modified()},e.rotateWXYZ=(n,r,o,a)=>{if(0===r&&0===o&&0===a)return void xf(&quot;No rotation applied, axis is zero vector.&quot;);if(0===n)return;const i=Da.radiansFromDegrees(n),s=Ba();Na(s,[r,o,a],i);const l=new Float64Array(16);G(l,s),t.preMultiplyFlag?b(t.matrix,t.matrix,l):b(t.matrix,l,t.matrix),e.modified()},e.rotateX=t=>{e.rotateWXYZ(t,1,0,0)},e.rotateY=t=>{e.rotateWXYZ(t,0,1,0)},e.rotateZ=t=>{e.rotateWXYZ(t,0,0,1)},e.scale=(n,r,o)=>{if(1===n&&1===r&&1===o)return;const a=u();P(a,[n,r,o]),t.preMultiplyFlag?b(t.matrix,t.matrix,a):b(t.matrix,a,t.matrix),e.modified()},e.transformNormal=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];const o=le(se(),t.matrix),a=se();me(a,o);const i=se();return ge(i,a),e.transformVector(n,r,i),Da.normalize(r),r},e.transformNormals=(n,r)=>{const o=n.getData(),a=r.getData(),i=[0,0,0],s=le(se(),t.matrix),l=se();me(l,s);const c=se();ge(c,l);for(let t=0;t<o.length;t+=3)i[0]=o[t],i[1]=o[t+1],i[2]=o[t+2],e.transformVector(i,i,c),Da.normalize(i),a[t]=i[0],a[t+1]=i[1],a[t+2]=i[2]},e.transformVector=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return wn(n,e,(arguments.length>2&&void 0!==arguments[2]?arguments[2]:null)||le(se(),t.matrix)),n},e.transformVectors=(t,n)=>{const r=t.getData(),o=n.getData(),a=[0,0,0];for(let t=0;t<r.length;t+=3)a[0]=r[t],a[1]=r[t+1],a[2]=r[t+2],e.transformVector(a,a),Da.normalize(a),o[t]=a[0],o[t+1]=a[1],o[t+2]=a[2]},e.transformPointsNormalsVectors=function(t,n,r,o,a,i){let s=arguments.length>6&&void 0!==arguments[6]?arguments[6]:null,l=arguments.length>7&&void 0!==arguments[7]?arguments[7]:null;const c=t.getNumberOfPoints(),u=s?.length??0,d=new Float64Array(3),p=new Float64Array(3),f=new Float64Array(3),g=new Float64Array(3);let m=!1,h=!1,v=!1;const T=[];for(let y=0;y<c;y++){if(t.getPoint(y,d),p.set(d),e.transformPoint(d,d),n.setPoint(y,...d),Da.areEquals(p,d)||(m=!0),a){const t=a.getData(),n=i.getData();d[0]=t[3*y],d[1]=t[3*y+1],d[2]=t[3*y+2],f.set(d),e.transformVector(d,d),n[3*y]=d[0],n[3*y+1]=d[1],n[3*y+2]=d[2],Da.areEquals(f,d)||(h=!0)}if(r){const t=r.getData(),n=o.getData();d[0]=t[3*y],d[1]=t[3*y+1],d[2]=t[3*y+2],g.set(d),e.transformNormal(d,d),n[3*y]=d[0],n[3*y+1]=d[1],n[3*y+2]=d[2],Da.areEquals(g,d)||(v=!0)}if(s)for(let t=0;t<u;t++){const n=s[t].getData(),r=l[t].getData();d[0]=n[3*y],d[1]=n[3*y+1],d[2]=n[3*y+2],f.set(d),e.transformVector(d,d),r[3*y]=d[0],r[3*y+1]=d[1],r[3*y+2]=d[2],Da.arrayEqual(f,d)||T.includes(t)||T.push(t)}}m&&n.modified(),h&&i.modified(),v&&o.modified(),T.forEach((e=>l[e].modified()))}}(e,t)}Cf=Wt.newInstance(Af,&quot;vtkTransform&quot;);var If={newInstance:Cf,extend:Af};function wf(e,t,n){return e.length>0?`${e.map((e=>e?.getMTime()??&quot;x&quot;)).join(&quot;/&quot;)}-${t}-${n}`:&quot;0&quot;}function Of(e,t){return`${t.getMTime()}`}const Pf={NEAREST:0,LINEAR:1};var Rf={InterpolationType:Pf};const{vtkErrorMacro:Mf}=Ht;function Ef(e,t,n){return t.identity(n),e.reduce(((e,n,r)=>0===r?n?t.copy(e,n):t.identity(e):n?t.multiply(e,e,n):e),n)}const Vf={VBOBuildTime:{},VBOBuildString:null,haveSeenDepthRequest:!1,lastHaveSeenDepthRequest:!1,lastIndependentComponents:!1,lastNumberOfComponents:0,lastMultiTexturePerVolumeEnabled:!1,lastSlabThickness:0,lastSlabTrapezoidIntegration:0,lastSlabType:-1,scalarTextures:[],_scalarTexturesCore:[],colorTexture:null,_colorTextureCore:null,pwfTexture:null,_pwfTextureCore:null,_externalOpenGLTexture:!1,resliceGeom:null,resliceGeomUpdateString:null,tris:null};const Df=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Vf,n),qt.extend(e,t,n),Ed(e,t,n),Vd(e,t,n),t.tris=ld.newInstance(),t.scalarTextures=[],t.colorTexture=null,t.pwfTexture=null,t.VBOBuildTime={},ht(t.VBOBuildTime),t.tmpMat4=m(new Float64Array(16)),t.outlineFilter=bf.newInstance(),t.outlineFilter.setGenerateFaces(!0),t.outlineFilter.setGenerateLines(!1),t.cubePolyData=gu.newInstance(),t.cutter=af.newInstance(),t.lineToSurfaceFilter=ef.newInstance(),t.transform=If.newInstance(),Tt(e,t,[&quot;scalarTextures&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLImageResliceMapper&quot;);const n=new Map;function o(t,r,o){r!==o&&(function(t,r){if(!r)return;const o=(n.get(r)??0)-1;o<=0?(t.unregisterGraphicsResourceUser(r,e),n.delete(r)):n.set(r,o)}(t,r),function(t,r){if(!r)return;const o=n.get(r)??0,a=o+1;n.set(r,a),o<=0&&t.registerGraphicsResourceUser(r,e)}(t,o))}function a(t){[...n.keys()].forEach((n=>t.unregisterGraphicsResourceUser(n,e)))}e.buildPass=n=>{if(n){t.currentRenderPass=null,t._openGLImageSlice=e.getFirstAncestorOfType(&quot;vtkOpenGLImageSlice&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;);const n=t._openGLRenderer.getRenderable();t._openGLCamera=t._openGLRenderer.getViewNodeFor(n.getActiveCamera());const r=t._openGLRenderWindow;t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),r&&!r.isDeleted()&&r!==t._openGLRenderWindow&&a(r),t.context=t._openGLRenderWindow.getContext(),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow)}},e.translucentPass=(n,r)=>{n&&(t.currentRenderPass=r,e.render())},e.zBufferPass=n=>{n&&(t.haveSeenDepthRequest=!0,t.renderDepth=!0,e.render(),t.renderDepth=!1)},e.opaqueZBufferPass=t=>e.zBufferPass(t),e.opaquePass=t=>{t&&e.render()},e.getCoincidentParameters=(e,n)=>t.renderable.getResolveCoincidentTopology()==gl.PolygonOffset?t.renderable.getCoincidentTopologyPolygonOffsetParameters():null,e.render=()=>{const n=t._openGLImageSlice.getRenderable(),r=t._openGLRenderer.getRenderable();e.renderPiece(r,n)},e.renderPiece=(n,r)=>{e.invokeEvent({type:&quot;StartEvent&quot;}),t.renderable.update();const o=t.renderable.getNumberOfInputPorts();t.currentValidInputs=[];for(let e=0;e<o;++e){const n=t.renderable.getInputData(e);n&&!n.isDeleted()&&t.currentValidInputs.push({imageData:n,inputIndex:e})}const a=t.currentValidInputs.length;if(a<=0)return void Mf(&quot;No input!&quot;);const i=t.currentValidInputs[0].imageData.getPointData().getScalars();t.multiTexturePerVolumeEnabled=a>1,t.numberOfComponents=t.multiTexturePerVolumeEnabled?a:i.getNumberOfComponents(),e.updateResliceGeometry(),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r),e.invokeEvent({type:&quot;EndEvent&quot;})},e.renderPieceStart=(n,r)=>{e.updateBufferObjects(n,r);const o=r.getProperties();t.currentValidInputs.forEach((e=>{let{inputIndex:n}=e;const r=o[n].getInterpolationType(),a=t.scalarTextures[n];r===Pf.NEAREST?(a.setMinificationFilter(ud.NEAREST),a.setMagnificationFilter(ud.NEAREST)):(a.setMinificationFilter(ud.LINEAR),a.setMagnificationFilter(ud.LINEAR))}));const a=t.currentValidInputs[0];o[a.inputIndex].getInterpolationType()===Pf.NEAREST?(t.colorTexture.setMinificationFilter(ud.NEAREST),t.colorTexture.setMagnificationFilter(ud.NEAREST),t.pwfTexture.setMinificationFilter(ud.NEAREST),t.pwfTexture.setMagnificationFilter(ud.NEAREST)):(t.colorTexture.setMinificationFilter(ud.LINEAR),t.colorTexture.setMagnificationFilter(ud.LINEAR),t.pwfTexture.setMinificationFilter(ud.LINEAR),t.pwfTexture.setMagnificationFilter(ud.LINEAR)),t.lastBoundBO=null},e.renderPieceDraw=(n,r)=>{const o=t.context,a=[...t.scalarTextures,t.colorTexture,t.pwfTexture];a.forEach((e=>e.activate())),e.updateShaders(t.tris,n,r),o.drawArrays(o.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release(),a.forEach((e=>e.deactivate()))},e.renderPieceFinish=(e,t)=>{},e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n)},e.getNeedToRebuildBufferObjects=(n,r)=>t.VBOBuildTime.getMTime()<e.getMTime()||t.VBOBuildTime.getMTime()<r.getMTime()||t.VBOBuildTime.getMTime()<t.renderable.getMTime()||t.VBOBuildTime.getMTime()<r.getProperty(t.currentValidInputs[0].inputIndex)?.getMTime()||t.currentValidInputs.some((e=>{let{imageData:n}=e;return t.VBOBuildTime.getMTime()<n.getMTime()}))||t.VBOBuildTime.getMTime()<t.resliceGeom.getMTime()||t.scalarTextures.length!==t.currentValidInputs.length||!t.scalarTextures.every((e=>!!e?.getHandle()))||!t.colorTexture?.getHandle()||!t.pwfTexture?.getHandle(),e.buildBufferObjects=(e,n)=>{const r=n.getProperties();t.currentValidInputs.forEach(((e,n)=>{let{imageData:a}=e;const i=a.getPointData().getScalars(),s=t._openGLRenderWindow.getGraphicsResourceForObject(i),l=Of(0,i),c=!s?.oglObject?.getHandle()||s?.hash!==l,u=r[n],d=u.getUpdatedExtents(),p=!!d.length;if(c&&!p){const e=Pd.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow);const r=a.getDimensions();e.setOglNorm16Ext(t.context.getExtension(&quot;EXT_texture_norm16&quot;)),e.resetFormatAndType(),e.create3DFilterableFromDataArray({width:r[0],height:r[1],depth:r[2],dataArray:i}),t._openGLRenderWindow.setGraphicsResourceForObject(i,e,l),t.scalarTextures[n]=e}else t.scalarTextures[n]=s.oglObject;if(p){u.setUpdatedExtents([]);const e=a.getDimensions();t.scalarTextures[n].create3DFilterableFromDataArray({width:e[0],height:e[1],depth:e[2],dataArray:i,updatedExtents:d})}o(t._openGLRenderWindow,t._scalarTexturesCore[n],i),t._scalarTexturesCore[n]=i}));const a=t.currentValidInputs[0],i=r[a.inputIndex],s=i.getIndependentComponents(),l=s?t.numberOfComponents:1,c=s?2*l:1,u=[];for(let e=0;e<l;++e)u.push(i.getRGBTransferFunction(e));const d=wf(u,s,l),p=i.getRGBTransferFunction(),f=t._openGLRenderWindow.getGraphicsResourceForObject(p);if(f?.oglObject?.getHandle()&&f?.hash===d)t.colorTexture=f.oglObject;else{let e=t.renderable.getColorTextureWidth();e<=0&&(e=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const n=new Uint8ClampedArray(e*c*3),r=Pd.newInstance();if(r.setOpenGLRenderWindow(t._openGLRenderWindow),p){const t=new Float32Array(3*e);for(let r=0;r<l;r++){const o=i.getRGBTransferFunction(r),a=o.getRange();if(o.getTable(a[0],a[1],e,t,1),s)for(let o=0;o<3*e;o++)n[r*e*6+o]=255*t[o],n[r*e*6+o+3*e]=255*t[o];else for(let o=0;o<3*e;o++)n[r*e*3+o]=255*t[o]}r.resetFormatAndType(),r.create2DFromRaw({width:e,height:c,numComps:3,dataType:cs.UNSIGNED_CHAR,data:n})}else{for(let t=0;t<3*e;++t){const r=255*t/(3*(e-1));for(let o=0;o<c;++o)n[o*e*3+t+0]=r,n[o*e*3+t+1]=r,n[o*e*3+t+2]=r}r.resetFormatAndType(),r.create2DFromRaw({width:e,height:1,numComps:3,dataType:cs.UNSIGNED_CHAR,data:n})}p&&t._openGLRenderWindow.setGraphicsResourceForObject(p,r,d),t.colorTexture=r}o(t._openGLRenderWindow,t._colorTextureCore,p),t._colorTextureCore=p;const g=[];for(let e=0;e<l;++e)g.push(i.getPiecewiseFunction(e));const m=wf(g,s,l),h=i.getPiecewiseFunction(),v=t._openGLRenderWindow.getGraphicsResourceForObject(h);if(v?.oglObject?.getHandle()&&v?.hash===m)t.pwfTexture=v.oglObject;else{let e=t.renderable.getOpacityTextureWidth();e<=0&&(e=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const n=e*c,r=new Uint8ClampedArray(n),o=Pd.newInstance();if(o.setOpenGLRenderWindow(t._openGLRenderWindow),h){const t=new Float32Array(n),r=new Float32Array(e);for(let n=0;n<l;++n){const o=i.getPiecewiseFunction(n);if(null===o)t.fill(1);else{const a=o.getRange();if(o.getTable(a[0],a[1],e,r,1),s)for(let o=0;o<e;o++)t[n*e*2+o]=r[o],t[n*e*2+o+e]=r[o];else for(let n=0;n<e;n++)t[n]=r[n]}}o.resetFormatAndType(),o.create2DFromRaw({width:e,height:c,numComps:1,dataType:cs.FLOAT,data:t})}else r.fill(255),o.resetFormatAndType(),o.create2DFromRaw({width:e,height:c,numComps:1,dataType:cs.UNSIGNED_CHAR,data:r});h&&t._openGLRenderWindow.setGraphicsResourceForObject(h,o,m),t.pwfTexture=o}o(t._openGLRenderWindow,t._pwfTextureCore,h),t._pwfTextureCore=h;const T=`${t.resliceGeom.getMTime()}A${t.renderable.getSlabThickness()}`;if(!t.tris.getCABO().getElementCount()||t.VBOBuildString!==T){const e=xs.newInstance({numberOfComponents:3,values:t.resliceGeom.getPoints().getData()});e.setName(&quot;points&quot;);const n=xs.newInstance({numberOfComponents:1,values:t.resliceGeom.getPolys().getData()}),r={points:e,cellOffset:0};if(t.renderable.getSlabThickness()>0){const e=t.resliceGeom.getPointData().getNormals();e?r.normals=e:Mf(&quot;Slab mode requested without normals&quot;)}t.tris.getCABO().createVBO(n,&quot;polys&quot;,Zi.SURFACE,r)}t.VBOBuildString=T,t.VBOBuildTime.modified()},e.updateShaders=(n,r,o)=>{if(t.lastBoundBO=n,e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};e.buildShaders(a,r,o);const i=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==n.getProgram()&&(n.setProgram(i),n.getVAO().releaseGraphicsResources()),n.getShaderSourceTime().modified()}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(n.getProgram());n.getVAO().bind(),e.setMapperShaderParameters(n,r,o),e.setCameraShaderParameters(n,r,o),e.setPropertyShaderParameters(n,r,o)},e.setMapperShaderParameters=(n,r,o)=>{const a=n.getProgram(),i=t.currentValidInputs[0].imageData;if(n.getCABO().getElementCount()&&(t.VBOBuildTime.getMTime()>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())){t.scalarTextures.forEach(((e,t)=>{a.setUniformi(`volumeTexture[${t}]`,e.getTextureUnit())})),a.isAttributeUsed(&quot;vertexWC&quot;)&&(n.getVAO().addAttributeArray(a,n.getCABO(),&quot;vertexWC&quot;,n.getCABO().getVertexOffset(),n.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||Mf(&quot;Error setting vertexWC in shader VAO.&quot;)),a.isAttributeUsed(&quot;normalWC&quot;)&&(n.getVAO().addAttributeArray(a,n.getCABO(),&quot;normalWC&quot;,n.getCABO().getNormalOffset(),n.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||Mf(&quot;Error setting normalWC in shader VAO.&quot;)),a.isUniformUsed(&quot;slabThickness&quot;)&&a.setUniformf(&quot;slabThickness&quot;,t.renderable.getSlabThickness()),a.isUniformUsed(&quot;spacing&quot;)&&a.setUniform3fv(&quot;spacing&quot;,i.getSpacing()),a.isUniformUsed(&quot;slabType&quot;)&&a.setUniformi(&quot;slabType&quot;,t.renderable.getSlabType()),a.isUniformUsed(&quot;slabType&quot;)&&a.setUniformi(&quot;slabType&quot;,t.renderable.getSlabType()),a.isUniformUsed(&quot;slabTrapezoid&quot;)&&a.setUniformi(&quot;slabTrapezoid&quot;,t.renderable.getSlabTrapezoidIntegration());const e=n.getCABO().getCoordShiftAndScaleEnabled()?n.getCABO().getInverseShiftAndScaleMatrix():null;if(a.isUniformUsed(&quot;WCTCMatrix&quot;)){const n=i.getDimensions();p(t.tmpMat4,i.getIndexToWorld()),x(t.tmpMat4,t.tmpMat4,[-.5,-.5,-.5]),C(t.tmpMat4,t.tmpMat4,n),v(t.tmpMat4,t.tmpMat4),e&&b(t.tmpMat4,t.tmpMat4,e),a.setUniformMatrix(&quot;WCTCMatrix&quot;,t.tmpMat4)}a.isUniformUsed(&quot;vboScaling&quot;)&&a.setUniform3fv(&quot;vboScaling&quot;,n.getCABO().getCoordScale()??[1,1,1]),n.getAttributeUpdateTime().modified()}if(t.haveSeenDepthRequest&&n.getProgram().setUniformi(&quot;depthRequest&quot;,t.renderDepth?1:0),n.getProgram().isUniformUsed(&quot;coffset&quot;)){const t=e.getCoincidentParameters(r,o);n.getProgram().setUniformf(&quot;coffset&quot;,t.offset),n.getProgram().isUniformUsed(&quot;cfactor&quot;)&&n.getProgram().setUniformf(&quot;cfactor&quot;,t.factor)}},e.setCameraShaderParameters=(e,n,o)=>{const a=t._openGLCamera.getKeyMatrices(n),i=t._openGLImageSlice.getKeyMatrices(),s=e.getCABO().getCoordShiftAndScaleEnabled()?e.getCABO().getInverseShiftAndScaleMatrix():null,l=e.getProgram();l.isUniformUsed(&quot;MCPCMatrix&quot;)&&(m(t.tmpMat4),l.setUniformMatrix(&quot;MCPCMatrix&quot;,Ef([a.wcpc,i.mcwc,s],r,t.tmpMat4))),l.isUniformUsed(&quot;MCVCMatrix&quot;)&&(m(t.tmpMat4),l.setUniformMatrix(&quot;MCVCMatrix&quot;,Ef([a.wcvc,i.mcwc,s],r,t.tmpMat4)))},e.setPropertyShaderParameters=(e,n,r)=>{const o=e.getProgram(),a=r.getProperty(t.currentValidInputs[0].inputIndex),i=a.getOpacity();o.setUniformf(&quot;opacity&quot;,i);const s=t.numberOfComponents,l=a.getIndependentComponents();if(l)for(let e=0;e<s;++e)o.setUniformf(`mix${e}`,a.getComponentWeight(e));for(let e=0;e<s;e++){const n=t.multiTexturePerVolumeEnabled,r=n?e:0,i=n?0:e,s=t.scalarTextures[r].getVolumeInfo(),c=s.scale[i],u=s.offset[i],d=l?e:0;let p=a.getColorWindow(),f=a.getColorLevel();const g=a.getRGBTransferFunction(d);if(g&&a.getUseLookupTableScalarRange()){const e=g.getRange();p=e[1]-e[0],f=.5*(e[1]+e[0])}const m=c/p,h=(u-f)/p+.5;o.setUniformf(`cshift${e}`,h),o.setUniformf(`cscale${e}`,m);let v=1,T=0;const y=a.getPiecewiseFunction(d);if(y){const e=y.getRange(),t=e[1]-e[0];v=c/t,T=(u-.5*(e[0]+e[1]))/t+.5}o.setUniformf(`pwfshift${e}`,T),o.setUniformf(`pwfscale${e}`,v)}const c=t.colorTexture.getTextureUnit();o.setUniformi(&quot;colorTexture1&quot;,c);const u=t.pwfTexture.getTextureUnit();o.setUniformi(&quot;pwfTexture1&quot;,u),o.setUniform4fv(&quot;backgroundColor&quot;,t.renderable.getBackgroundColor())},e.getNeedToRebuildShaders=(e,n,r)=>{const o=r.getProperty(t.currentValidInputs[0].inputIndex).getIndependentComponents(),a=t.renderable.getSlabThickness(),i=t.renderable.getSlabType(),s=t.renderable.getSlabTrapezoidIntegration();let l=!1;return(!t.currentRenderPass&&t.lastRenderPassShaderReplacement||t.currentRenderPass&&t.currentRenderPass.getShaderReplacement()!==t.lastRenderPassShaderReplacement)&&(l=!0),!(!l&&t.lastHaveSeenDepthRequest===t.haveSeenDepthRequest&&t.lastNumberOfComponents===t.numberOfComponents&&t.lastMultiTexturePerVolumeEnabled===t.multiTexturePerVolumeEnabled&&0!==e.getProgram()?.getHandle()&&t.lastIndependentComponents===o&&t.lastSlabThickness===a&&t.lastSlabType===i&&t.lastSlabTrapezoidIntegration===s||(t.lastHaveSeenDepthRequest=t.haveSeenDepthRequest,t.lastNumberOfComponents=t.numberOfComponents,t.lastMultiTexturePerVolumeEnabled=t.multiTexturePerVolumeEnabled,t.lastIndependentComponents=o,t.lastSlabThickness=a,t.lastSlabType=i,t.lastSlabTrapezoidIntegration=s,0))},e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkImageResliceMapperVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\n// all variables that represent positions or directions have a suffix\\n// indicating the coordinate system they are in. The possible values are\\n// MC - Model coordinates\\n// WC - World coordinates\\n// VC - View coordinates\\n// DC - Display coordinates\\n// TC - Texture coordinates\\n\\n// frag position in VC\\n//VTK::PositionVC::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\n// camera and actor matrix values\\n//VTK::Camera::Dec\\n\\nvoid main()\\n{\\n  //VTK::PositionVC::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Picking::Impl\\n}\\n&quot;,e.Fragment=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkImageResliceMapperFS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// Template for the gpu image mapper fragment shader\\n\\n// VC position of this fragment\\n//VTK::PositionVC::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\n// picking support\\n//VTK::Picking::Dec\\n\\n// handle coincident offsets\\n//VTK::Coincident::Dec\\n\\n//VTK::ZBuffer::Dec\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nvoid main()\\n{\\n  // VC position of this fragment. This should not branch/return/discard.\\n  //VTK::PositionVC::Impl\\n\\n  // Place any calls that require uniform flow (e.g. dFdx) here.\\n  //VTK::UniformFlow::Impl\\n\\n  // Set gl_FragDepth here (gl_FragCoord.z by default)\\n  //VTK::Depth::Impl\\n\\n  // Early depth peeling abort:\\n  //VTK::DepthPeeling::PreColor\\n\\n  //VTK::TCoord::Impl\\n\\n  if (gl_FragData[0].a <= 0.0)\\n    {\\n    discard;\\n    }\\n\\n  //VTK::DepthPeeling::Impl\\n\\n  //VTK::Picking::Impl\\n\\n  // handle coincident offsets\\n  //VTK::Coincident::Impl\\n\\n  //VTK::ZBuffer::Impl\\n\\n  //VTK::RenderPassFragmentShader::Impl\\n}\\n&quot;,e.Geometry=&quot;&quot;},e.replaceShaderValues=(n,r,o)=>{if(e.replaceShaderTCoord(n,r,o),e.replaceShaderPositionVC(n,r,o),t.haveSeenDepthRequest){let e=n.Fragment;e=td.substitute(e,&quot;//VTK::ZBuffer::Dec&quot;,&quot;uniform int depthRequest;&quot;).result,e=td.substitute(e,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float iz = floor(gl_FragCoord.z*65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result,n.Fragment=e}e.replaceShaderCoincidentOffset(n,r,o)},e.replaceShaderTCoord=(e,n,r)=>{let o=e.Vertex;const a=e.Geometry;let i=e.Fragment;const s=t.renderable.getSlabThickness();o=td.substitute(o,&quot;//VTK::TCoord::Dec&quot;,[&quot;uniform mat4 WCTCMatrix;&quot;,&quot;out vec3 fragTexCoord;&quot;]).result,o=td.substitute(o,&quot;//VTK::TCoord::Impl&quot;,[&quot;fragTexCoord = (WCTCMatrix * vertexWC).xyz;&quot;]).result;const l=t.numberOfComponents,c=r.getProperty(t.currentValidInputs[0].inputIndex).getIndependentComponents();let u=[&quot;in vec3 fragTexCoord;&quot;,`uniform highp sampler3D volumeTexture[${t.scalarTextures.length}];`,&quot;uniform mat4 WCTCMatrix;&quot;,&quot;uniform float cshift0;&quot;,&quot;uniform float cscale0;&quot;,&quot;uniform float pwfshift0;&quot;,&quot;uniform float pwfscale0;&quot;,&quot;uniform sampler2D colorTexture1;&quot;,&quot;uniform sampler2D pwfTexture1;&quot;,&quot;uniform float opacity;&quot;,&quot;uniform vec4 backgroundColor;&quot;];if(u.push(&quot;vec4 rawSampleTexture(vec3 pos) {&quot;),t.multiTexturePerVolumeEnabled){u.push(&quot;vec4 rawSample;&quot;);for(let e=0;e<t.scalarTextures.length;++e)u.push(`rawSample[${e}] = texture(volumeTexture[${e}], pos)[0];`);u.push(&quot;return rawSample;&quot;,&quot;}&quot;)}else u.push(&quot;return texture(volumeTexture[0], pos);&quot;,&quot;}&quot;);if(c){for(let e=1;e<l;e++)u=u.concat([`uniform float cshift${e};`,`uniform float cscale${e};`,`uniform float pwfshift${e};`,`uniform float pwfscale${e};`]);switch(l){case 1:u=u.concat([&quot;uniform float mix0;&quot;,&quot;#define height0 0.5&quot;]);break;case 2:u=u.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;#define height0 0.25&quot;,&quot;#define height1 0.75&quot;]);break;case 3:u=u.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;#define height0 0.17&quot;,&quot;#define height1 0.5&quot;,&quot;#define height2 0.83&quot;]);break;case 4:u=u.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;uniform float mix3;&quot;,&quot;#define height0 0.125&quot;,&quot;#define height1 0.375&quot;,&quot;#define height2 0.625&quot;,&quot;#define height3 0.875&quot;]);break;default:Mf(&quot;Unsupported number of independent coordinates.&quot;)}}s>0&&(u=u.concat([&quot;uniform vec3 spacing;&quot;,&quot;uniform float slabThickness;&quot;,&quot;uniform int slabType;&quot;,&quot;uniform int slabTrapezoid;&quot;,&quot;uniform vec3 vboScaling;&quot;]),u=u.concat([&quot;vec4 compositeValue(vec4 currVal, vec4 valToComp, int trapezoid)&quot;,&quot;{&quot;,&quot;  vec4 retVal = vec4(1.0);&quot;,&quot;  if (slabType == 0) // min&quot;,&quot;  {&quot;,&quot;    retVal = min(currVal, valToComp);&quot;,&quot;  }&quot;,&quot;  else if (slabType == 1) // max&quot;,&quot;  {&quot;,&quot;    retVal = max(currVal, valToComp);&quot;,&quot;  }&quot;,&quot;  else if (slabType == 3) // sum&quot;,&quot;  {&quot;,&quot;    retVal = currVal + (trapezoid > 0 ? 0.5 * valToComp : valToComp); &quot;,&quot;  }&quot;,&quot;  else // mean&quot;,&quot;  {&quot;,&quot;    retVal = currVal + (trapezoid > 0 ? 0.5 * valToComp : valToComp); &quot;,&quot;  }&quot;,&quot;  return retVal;&quot;,&quot;}&quot;])),i=td.substitute(i,&quot;//VTK::TCoord::Dec&quot;,u).result;let d=[&quot;if (any(greaterThan(fragTexCoord, vec3(1.0))) || any(lessThan(fragTexCoord, vec3(0.0))))&quot;,&quot;{&quot;,&quot;  // set the background color and exit&quot;,&quot;  gl_FragData[0] = backgroundColor;&quot;,&quot;  return;&quot;,&quot;}&quot;,&quot;vec4 tvalue = rawSampleTexture(fragTexCoord);&quot;];if(s>0&&(d=d.concat([&quot;// Get the first and last samples&quot;,&quot;int numSlices = 1;&quot;,&quot;float scaling = min(min(spacing.x, spacing.y), spacing.z) * 0.5;&quot;,&quot;vec3 normalxspacing = scaling * normalWCVSOutput;&quot;,&quot;float distTraveled = length(normalxspacing);&quot;,&quot;int trapezoid = 0;&quot;,&quot;while (distTraveled < slabThickness * 0.5)&quot;,&quot;{&quot;,&quot;  distTraveled += length(normalxspacing);&quot;,&quot;  float fnumSlices = float(numSlices);&quot;,&quot;  if (distTraveled > slabThickness * 0.5)&quot;,&quot;  {&quot;,&quot;    // Before stepping outside the slab, sample at the boundaries&quot;,&quot;    normalxspacing = normalWCVSOutput * slabThickness * 0.5 / fnumSlices;&quot;,&quot;    trapezoid = slabTrapezoid;&quot;,&quot;  }&quot;,&quot;  vec3 fragTCoordNeg = (WCTCMatrix * vec4(vertexWCVSOutput.xyz - fnumSlices * normalxspacing * vboScaling, 1.0)).xyz;&quot;,&quot;  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))&quot;,&quot;  {&quot;,&quot;    vec4 newVal = rawSampleTexture(fragTCoordNeg);&quot;,&quot;    tvalue = compositeValue(tvalue, newVal, trapezoid);&quot;,&quot;    numSlices += 1;&quot;,&quot;  }&quot;,&quot;  vec3 fragTCoordPos = (WCTCMatrix * vec4(vertexWCVSOutput.xyz + fnumSlices * normalxspacing * vboScaling, 1.0)).xyz;&quot;,&quot;  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))&quot;,&quot;  {&quot;,&quot;    vec4 newVal = rawSampleTexture(fragTCoordPos);&quot;,&quot;    tvalue = compositeValue(tvalue, newVal, trapezoid);&quot;,&quot;    numSlices += 1;&quot;,&quot;  }&quot;,&quot;}&quot;,&quot;// Finally, if slab type is *mean*, divide the sum by the numSlices&quot;,&quot;if (slabType == 2)&quot;,&quot;{&quot;,&quot;  tvalue = tvalue / float(numSlices);&quot;,&quot;}&quot;])),c){const e=[&quot;r&quot;,&quot;g&quot;,&quot;b&quot;,&quot;a&quot;];for(let t=0;t<l;++t)d=d.concat([`vec3 tcolor${t} = texture2D(colorTexture1, vec2(tvalue.${e[t]} * cscale${t} + cshift${t}, height${t})).rgb;`,`float compWeight${t} = mix${t} * texture2D(pwfTexture1, vec2(tvalue.${e[t]} * pwfscale${t} + pwfshift${t}, height${t})).r;`]);switch(l){case 1:d=d.concat([&quot;gl_FragData[0] = vec4(tcolor0.rgb, compWeight0 * opacity);&quot;]);break;case 2:d=d.concat([&quot;float weightSum = compWeight0 + compWeight1;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum))), opacity);&quot;]);break;case 3:d=d.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum))), opacity);&quot;]);break;case 4:d=d.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2 + compWeight3;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum)) + (tcolor3.rgb * (compWeight3 / weightSum))), opacity);&quot;]);break;default:Mf(&quot;Unsupported number of independent coordinates.&quot;)}}else switch(l){case 1:d=d.concat([&quot;// Dependent components&quot;,&quot;float intensity = tvalue.r;&quot;,&quot;vec3 tcolor = texture2D(colorTexture1, vec2(intensity * cscale0 + cshift0, 0.5)).rgb;&quot;,&quot;float scalarOpacity = texture2D(pwfTexture1, vec2(intensity * pwfscale0 + pwfshift0, 0.5)).r;&quot;,&quot;gl_FragData[0] = vec4(tcolor, scalarOpacity * opacity);&quot;]);break;case 2:d=d.concat([&quot;float intensity = tvalue.r*cscale0 + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(intensity, 0.5)).rgb, pwfscale0*tvalue.g + pwfshift0);&quot;]);break;case 3:d=d.concat([&quot;vec4 tcolor = cscale0*tvalue + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, opacity);&quot;]);break;default:d=d.concat([&quot;vec4 tcolor = cscale0*tvalue + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, tcolor.a);&quot;])}i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,d).result,e.Vertex=o,e.Fragment=i,e.Geometry=a},e.replaceShaderPositionVC=(n,r,o)=>{let a=n.Vertex;const i=n.Geometry;let s=n.Fragment;const l=t.renderable.getSlabThickness();let c=[&quot;attribute vec4 vertexWC;&quot;];c=c.concat([`//${e.getMTime()}${t.resliceGeomUpdateString}`]),l>0&&(c=c.concat([&quot;attribute vec3 normalWC;&quot;,&quot;varying vec3 normalWCVSOutput;&quot;,&quot;varying vec4 vertexWCVSOutput;&quot;])),a=td.substitute(a,&quot;//VTK::PositionVC::Dec&quot;,c).result;let u=[&quot;gl_Position = MCPCMatrix * vertexWC;&quot;];l>0&&(u=u.concat([&quot;normalWCVSOutput = normalWC;&quot;,&quot;vertexWCVSOutput = vertexWC;&quot;])),a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,u).result,a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result;let d=[];l>0&&(d=d.concat([&quot;varying vec3 normalWCVSOutput;&quot;,&quot;varying vec4 vertexWCVSOutput;&quot;])),s=td.substitute(s,&quot;//VTK::PositionVC::Dec&quot;,d).result,n.Vertex=a,n.Geometry=i,n.Fragment=s},e.updateResliceGeometry=()=>{let e=&quot;&quot;;const n=t.currentValidInputs[0].imageData,r=n?.getBounds();let o=!0,a=2;const i=t.renderable.getSlicePolyData(),s=t.renderable.getSlicePlane();if(i)e=e.concat(`PolyData${i.getMTime()}`);else if(s){e=e.concat(`Plane${s.getMTime()}`);const t=se();n&&(e=e.concat(`Image${n.getMTime()}`),pe(t,...n.getDirection()),me(t,t));const r=[...s.getNormal()];wn(r,r,t),[o,a]=function(e){Da.normalize(e);const t=[0,0,0];for(let r=0;r<3;++r){(n=t)[0]=0,n[1]=0,n[2]=0,t[r]=1;const o=Da.dot(e,t);if(o<-.999999||o>.999999)return[!0,r]}var n;return[!1,2]}(r)}else{const o=ei.newInstance();o.setNormal(0,0,1);let a=[0,1,0,1,0,1];n&&(a=r),o.setOrigin(a[0],a[2],.5*(a[5]+a[4])),t.renderable.setSlicePlane(o),e=e.concat(`Plane${s?.getMTime()}`),n&&(e=e.concat(`Image${n.getMTime()}`))}if(!t.resliceGeom||t.resliceGeomUpdateString!==e){if(i)t.resliceGeom||(t.resliceGeom=gu.newInstance()),t.resliceGeom.getPoints().setData(i.getPoints().getData(),3),t.resliceGeom.getPolys().setData(i.getPolys().getData(),1),t.resliceGeom.getPointData().setNormals(i.getPointData().getNormals());else if(s)if(o){const e=new Float32Array(12),r=n.worldToIndex(s.getOrigin(),[0,0,0]),o=[(a+1)%3,(a+2)%3].sort(),i=n.getSpatialExtent();let l=0;for(let t=0;t<2;++t)for(let n=0;n<2;++n)e[l+a]=r[a],e[l+o[0]]=i[2*o[0]+n],e[l+o[1]]=i[2*o[1]+t],l+=3;t.transform.setMatrix(n.getIndexToWorld()),t.transform.transformPoints(e,e);const c=new Uint16Array(8);c[0]=3,c[1]=0,c[2]=1,c[3]=3,c[4]=3,c[5]=0,c[6]=3,c[7]=2;const u=s.getNormal();Da.normalize(u);const d=new Float32Array(12);for(let e=0;e<4;++e)d[3*e]=u[0],d[3*e+1]=u[1],d[3*e+2]=u[2];t.resliceGeom||(t.resliceGeom=gu.newInstance()),t.resliceGeom.getPoints().setData(e,3),t.resliceGeom.getPolys().setData(c,1);const p=xs.newInstance({numberOfComponents:3,values:d,name:&quot;Normals&quot;});t.resliceGeom.getPointData().setNormals(p)}else{t.outlineFilter.setInputData(n),t.cutter.setInputConnection(t.outlineFilter.getOutputPort()),t.cutter.setCutFunction(s),t.lineToSurfaceFilter.setInputConnection(t.cutter.getOutputPort()),t.lineToSurfaceFilter.update(),t.resliceGeom||(t.resliceGeom=gu.newInstance());const e=t.lineToSurfaceFilter.getOutputData();t.resliceGeom.getPoints().setData(e.getPoints().getData(),3),t.resliceGeom.getPolys().setData(e.getPolys().getData(),1),t.resliceGeom.getPointData().setNormals(e.getPointData().getNormals());const r=s.getNormal(),o=t.resliceGeom.getNumberOfPoints();Da.normalize(r);const a=new Float32Array(3*o);for(let e=0;e<o;++e)a[3*e]=r[0],a[3*e+1]=r[1],a[3*e+2]=r[2];const i=xs.newInstance({numberOfComponents:3,values:a,name:&quot;Normals&quot;});t.resliceGeom.getPointData().setNormals(i)}else Mf(&quot;Something went wrong.&quot;,&quot;A default slice plane should have been created in the beginning of&quot;,&quot;updateResliceGeometry.&quot;);t.resliceGeomUpdateString=e,t.resliceGeom?.modified()}},e.setScalarTextures=e=>{t.scalarTextures=[...e],t._externalOpenGLTexture=!0},e.delete=Et((()=>{t._openGLRenderWindow&&a(t._openGLRenderWindow)}),e.delete)}(e,t)}),&quot;vtkOpenGLImageResliceMapper&quot;);Jt(&quot;vtkImageResliceMapper&quot;,Df);var Lf={SlicingMode:{NONE:-1,I:0,J:1,K:2,X:3,Y:4,Z:5}};const{vtkErrorMacro:Bf}=Ht,{SlicingMode:Nf}=Lf;function Ff(e){const t=e.split(&quot;\\n&quot;),n=[];for(let e=0;e<t.length;++e){const r=t[e].trim();r.length>0&&n.push(r)}return n}const _f={VBOBuildTime:0,VBOBuildString:null,openGLTexture:null,tris:null,imagemat:null,imagematinv:null,colorTexture:null,pwfTexture:null,labelOutlineThicknessTexture:null,labelOutlineOpacityTexture:null,lastHaveSeenDepthRequest:!1,haveSeenDepthRequest:!1,lastTextureComponents:0};const kf=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,_f,n),qt.extend(e,t,n),Ed(e,t,n),Vd(e,t,n),t.tris=ld.newInstance(),t.imagemat=m(new Float64Array(16)),t.imagematinv=m(new Float64Array(16)),t.projectionToWorld=m(new Float64Array(16)),t.idxToView=m(new Float64Array(16)),t.idxNormalMatrix=fe(new Float64Array(9)),t.modelToView=m(new Float64Array(16)),t.projectionToView=m(new Float64Array(16)),Ct(e,t,[]),t.VBOBuildTime={},ht(t.VBOBuildTime),function(e,t){function n(n){t.openGLTexture.releaseGraphicsResources(n),[t._colorTransferFunc,t._pwFunc,t._labelOutlineThicknessArray,t._labelOutlineOpacity].forEach((t=>n.unregisterGraphicsResourceUser(t,e)))}t.classHierarchy.push(&quot;vtkOpenGLImageMapper&quot;),e.buildPass=r=>{if(r){t.currentRenderPass=null,t.openGLImageSlice=e.getFirstAncestorOfType(&quot;vtkOpenGLImageSlice&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;);const r=t._openGLRenderWindow;t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),r&&!r.isDeleted()&&r!==t._openGLRenderWindow&&n(r),t.context=t._openGLRenderWindow.getContext(),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow);const o=t._openGLRenderer.getRenderable();t.openGLCamera=t._openGLRenderer.getViewNodeFor(o.getActiveCamera()),t.renderable.isA(&quot;vtkImageMapper&quot;)&&t.renderable.getSliceAtFocalPoint()&&t.renderable.setSliceFromCamera(o.getActiveCamera())}},e.translucentPass=(n,r)=>{n&&(t.currentRenderPass=r,e.render())},e.zBufferPass=n=>{n&&(t.haveSeenDepthRequest=!0,t.renderDepth=!0,e.render(),t.renderDepth=!1)},e.opaqueZBufferPass=t=>e.zBufferPass(t),e.opaquePass=t=>{t&&e.render()},e.getCoincidentParameters=(e,n)=>t.renderable.getResolveCoincidentTopology()==gl.PolygonOffset?t.renderable.getCoincidentTopologyPolygonOffsetParameters():null,e.render=()=>{const n=t.openGLImageSlice.getRenderable(),r=t._openGLRenderer.getRenderable();e.renderPiece(r,n)},e.getShaderTemplate=(e,t,n)=>{e.Vertex=Rd,e.Fragment=Md,e.Geometry=&quot;&quot;},e.replaceShaderValues=(n,r,o)=>{let a=n.Vertex,i=n.Fragment;a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;  gl_Position = MCPCMatrix * vertexMC;&quot;]).result,a=td.substitute(a,&quot;//VTK::TCoord::Impl&quot;,&quot;tcoordVCVSOutput = tcoordMC;&quot;).result,a=td.substitute(a,&quot;//VTK::TCoord::Dec&quot;,&quot;attribute vec2 tcoordMC; varying vec2 tcoordVCVSOutput;&quot;).result;const s=t.openGLTexture.getComponents(),l=o.getProperty().getIndependentComponents();let c=[&quot;varying vec2 tcoordVCVSOutput;&quot;,&quot;uniform float cshift0;&quot;,&quot;uniform float cscale0;&quot;,&quot;uniform float pwfshift0;&quot;,&quot;uniform float pwfscale0;&quot;,&quot;uniform sampler2D texture1;&quot;,&quot;uniform sampler2D colorTexture1;&quot;,&quot;uniform sampler2D pwfTexture1;&quot;,&quot;uniform float opacity;&quot;];if(o.getProperty().getUseLabelOutline()&&(c=c.concat([&quot;uniform sampler2D labelOutlineTexture1;&quot;,&quot;uniform sampler2D labelOutlineOpacityTexture1;&quot;])),l){for(let e=1;e<s;e++)c=c.concat([`uniform float cshift${e};`,`uniform float cscale${e};`,`uniform float pwfshift${e};`,`uniform float pwfscale${e};`]);switch(s){case 1:c=c.concat([&quot;uniform float mix0;&quot;,&quot;#define height0 0.5&quot;]);break;case 2:c=c.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;#define height0 0.25&quot;,&quot;#define height1 0.75&quot;]);break;case 3:c=c.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;#define height0 0.17&quot;,&quot;#define height1 0.5&quot;,&quot;#define height2 0.83&quot;]);break;case 4:c=c.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;uniform float mix3;&quot;,&quot;#define height0 0.125&quot;,&quot;#define height1 0.375&quot;,&quot;#define height2 0.625&quot;,&quot;#define height3 0.875&quot;]);break;default:Bf(&quot;Unsupported number of independent coordinates.&quot;)}}if(i=td.substitute(i,&quot;//VTK::TCoord::Dec&quot;,c).result,!0===o.getProperty().getUseLabelOutline()&&(i=td.substitute(i,&quot;//VTK::LabelOutline::Dec&quot;,[&quot;uniform float vpWidth;&quot;,&quot;uniform float vpHeight;&quot;,&quot;uniform float vpOffsetX;&quot;,&quot;uniform float vpOffsetY;&quot;,&quot;uniform mat4 PCWCMatrix;&quot;,&quot;uniform mat4 vWCtoIDX;&quot;,&quot;uniform ivec3 imageDimensions;&quot;,&quot;uniform int sliceAxis;&quot;]).result,i=td.substitute(i,&quot;//VTK::ImageLabelOutlineOn&quot;,&quot;#define vtkImageLabelOutlineOn&quot;).result,i=td.substitute(i,&quot;//VTK::LabelOutlineHelperFunction&quot;,[&quot;#ifdef vtkImageLabelOutlineOn&quot;,&quot;vec3 fragCoordToIndexSpace(vec4 fragCoord) {&quot;,&quot;  vec4 pcPos = vec4(&quot;,&quot;    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,&quot;,&quot;    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,&quot;,&quot;    (fragCoord.z - 0.5) * 2.0,&quot;,&quot;    1.0);&quot;,&quot;&quot;,&quot;  vec4 worldCoord = PCWCMatrix * pcPos;&quot;,&quot;  vec4 vertex = (worldCoord/worldCoord.w);&quot;,&quot;&quot;,&quot;  vec3 index = (vWCtoIDX * vertex).xyz;&quot;,&quot;&quot;,&quot;  // half voxel fix for labelmapOutline&quot;,&quot;  return (index + vec3(0.5)) / vec3(imageDimensions);&quot;,&quot;}&quot;,&quot;vec2 getSliceCoords(vec3 coord, int axis) {&quot;,&quot;  if (axis == 0) return coord.yz;&quot;,&quot;  if (axis == 1) return coord.xz;&quot;,&quot;  if (axis == 2) return coord.xy;&quot;,&quot;}&quot;,&quot;#endif&quot;]).result),l){const e=[&quot;r&quot;,&quot;g&quot;,&quot;b&quot;,&quot;a&quot;];let t=[&quot;vec4 tvalue = texture2D(texture1, tcoordVCVSOutput);&quot;];for(let n=0;n<s;n++)t=t.concat([`vec3 tcolor${n} = mix${n} * texture2D(colorTexture1, vec2(tvalue.${e[n]} * cscale${n} + cshift${n}, height${n})).rgb;`,`float compWeight${n} = mix${n} * texture2D(pwfTexture1, vec2(tvalue.${e[n]} * pwfscale${n} + pwfshift${n}, height${n})).r;`]);switch(s){case 1:t=t.concat([&quot;gl_FragData[0] = vec4(tcolor0.rgb, opacity);&quot;]);break;case 2:t=t.concat([&quot;float weightSum = compWeight0 + compWeight1;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum))), opacity);&quot;]);break;case 3:t=t.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum))), opacity);&quot;]);break;case 4:t=t.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2 + compWeight3;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum)) + (tcolor3.rgb * (compWeight3 / weightSum))), opacity);&quot;]);break;default:Bf(&quot;Unsupported number of independent coordinates.&quot;)}i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,t).result}else switch(s){case 1:i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[...Ff(&quot;\\n                #ifdef vtkImageLabelOutlineOn\\n                  vec3 centerPosIS = fragCoordToIndexSpace(gl_FragCoord);\\n                  float centerValue = texture2D(texture1, getSliceCoords(centerPosIS, sliceAxis)).r;\\n                  bool pixelOnBorder = false;\\n                  vec3 tColor = texture2D(colorTexture1, vec2(centerValue * cscale0 + cshift0, 0.5)).rgb;\\n                  float scalarOpacity = texture2D(pwfTexture1, vec2(centerValue * pwfscale0 + pwfshift0, 0.5)).r;\\n                  float opacityToUse = scalarOpacity * opacity;\\n                  int segmentIndex = int(centerValue * 255.0);\\n                  float textureCoordinate = float(segmentIndex - 1) / 1024.0;\\n                  float textureValue = texture2D(labelOutlineTexture1, vec2(textureCoordinate, 0.5)).r;\\n                  float outlineOpacity = texture2D(labelOutlineOpacityTexture1, vec2(textureCoordinate, 0.5)).r;\\n                  int actualThickness = int(textureValue * 255.0);\\n\\n                  if (segmentIndex == 0){\\n                    gl_FragData[0] = vec4(0.0, 0.0, 0.0, 0.0);\\n                    return;\\n                  }\\n\\n                  for (int i = -actualThickness; i <= actualThickness; i++) {\\n                    for (int j = -actualThickness; j <= actualThickness; j++) {\\n                      if (i == 0 || j == 0) {\\n                        continue;\\n                      }\\n                      vec4 neighborPixelCoord = vec4(gl_FragCoord.x + float(i),\\n                        gl_FragCoord.y + float(j),\\n                        gl_FragCoord.z, gl_FragCoord.w);\\n                      vec3 neighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);\\n                      float value = texture2D(texture1, getSliceCoords(neighborPosIS, sliceAxis)).r;\\n                      if (value != centerValue) {\\n                        pixelOnBorder = true;\\n                        break;\\n                      }\\n                    }\\n                    if (pixelOnBorder == true) {\\n                      break;\\n                    }\\n                  }\\n                  if (pixelOnBorder == true) {\\n                    gl_FragData[0] = vec4(tColor, outlineOpacity);\\n                  }\\n                  else {\\n                    gl_FragData[0] = vec4(tColor, opacityToUse);\\n                  }\\n                #else\\n                  float intensity = texture2D(texture1, tcoordVCVSOutput).r;\\n                  vec3 tcolor = texture2D(colorTexture1, vec2(intensity * cscale0 + cshift0, 0.5)).rgb;\\n                  float scalarOpacity = texture2D(pwfTexture1, vec2(intensity * pwfscale0 + pwfshift0, 0.5)).r;\\n                  gl_FragData[0] = vec4(tcolor, scalarOpacity * opacity);\\n                #endif\\n                &quot;)]).result;break;case 2:i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[&quot;vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);&quot;,&quot;float intensity = tcolor.r*cscale0 + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(intensity, 0.5)).rgb, pwfscale0*tcolor.g + pwfshift0);&quot;]).result;break;case 3:i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[&quot;vec4 tcolor = cscale0*texture2D(texture1, tcoordVCVSOutput.st) + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, opacity);&quot;]).result;break;default:i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[&quot;vec4 tcolor = cscale0*texture2D(texture1, tcoordVCVSOutput.st) + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, tcolor.a);&quot;]).result}t.haveSeenDepthRequest&&(i=td.substitute(i,&quot;//VTK::ZBuffer::Dec&quot;,&quot;uniform int depthRequest;&quot;).result,i=td.substitute(i,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float iz = floor(gl_FragCoord.z*65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result),n.Vertex=a,n.Fragment=i,e.replaceShaderClip(n,r,o),e.replaceShaderCoincidentOffset(n,r,o)},e.replaceShaderClip=(e,n,r)=>{let o=e.Vertex,a=e.Fragment;if(t.renderable.getNumberOfClippingPlanes()){let e=t.renderable.getNumberOfClippingPlanes();e>6&&(et(&quot;OpenGL has a limit of 6 clipping planes&quot;),e=6),o=td.substitute(o,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,&quot;uniform vec4 clipPlanes[6];&quot;,&quot;varying float clipDistancesVSOutput[6];&quot;]).result,o=td.substitute(o,&quot;//VTK::Clip::Impl&quot;,[&quot;for (int planeNum = 0; planeNum < 6; planeNum++)&quot;,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], vertexMC);&quot;,&quot;    }&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,&quot;varying float clipDistancesVSOutput[6];&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Impl&quot;,[&quot;for (int planeNum = 0; planeNum < 6; planeNum++)&quot;,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    if (clipDistancesVSOutput[planeNum] < 0.0) discard;&quot;,&quot;    }&quot;]).result}e.Vertex=o,e.Fragment=a},e.getNeedToRebuildShaders=(e,n,r)=>{const o=t.openGLTexture.getComponents(),a=r.getProperty().getIndependentComponents();let i=!1;return(!t.currentRenderPass&&t.lastRenderPassShaderReplacement||t.currentRenderPass&&t.currentRenderPass.getShaderReplacement()!==t.lastRenderPassShaderReplacement)&&(i=!0),!!(i||t.lastHaveSeenDepthRequest!==t.haveSeenDepthRequest||0===e.getProgram()?.getHandle()||e.getShaderSourceTime().getMTime()<t.renderable.getMTime()||e.getShaderSourceTime().getMTime()<t.currentInput.getMTime()||e.getShaderSourceTime().getMTime()<r.getProperty().getMTime()||t.lastTextureComponents!==o||t.lastIndependentComponents!==a)&&(t.lastHaveSeenDepthRequest=t.haveSeenDepthRequest,t.lastTextureComponents=o,t.lastIndependentComponents=a,!0)},e.updateShaders=(n,r,o)=>{if(t.lastBoundBO=n,e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};e.buildShaders(a,r,o);const i=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==n.getProgram()&&(n.setProgram(i),n.getVAO().releaseGraphicsResources()),n.getShaderSourceTime().modified()}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(n.getProgram());n.getVAO().bind(),e.setMapperShaderParameters(n,r,o),e.setCameraShaderParameters(n,r,o),e.setPropertyShaderParameters(n,r,o)},e.setMapperShaderParameters=(n,r,o)=>{n.getCABO().getElementCount()&&(t.VBOBuildTime>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())&&(n.getProgram().isAttributeUsed(&quot;vertexMC&quot;)&&(n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;vertexMC&quot;,n.getCABO().getVertexOffset(),n.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||Bf(&quot;Error setting vertexMC in shader VAO.&quot;)),n.getProgram().isAttributeUsed(&quot;tcoordMC&quot;)&&n.getCABO().getTCoordOffset()&&(n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),&quot;tcoordMC&quot;,n.getCABO().getTCoordOffset(),n.getCABO().getStride(),t.context.FLOAT,n.getCABO().getTCoordComponents(),t.context.FALSE)||Bf(&quot;Error setting tcoordMC in shader VAO.&quot;)),n.getAttributeUpdateTime().modified());const a=t.openGLTexture.getTextureUnit();n.getProgram().setUniformi(&quot;texture1&quot;,a);const i=t.openGLTexture.getComponents(),s=o.getProperty().getIndependentComponents();if(s)for(let e=0;e<i;e++)n.getProgram().setUniformf(`mix${e}`,o.getProperty().getComponentWeight(e));const l=t.openGLTexture.getShiftAndScale();for(let e=0;e<i;e++){let t=o.getProperty().getColorWindow(),r=o.getProperty().getColorLevel();const a=s?e:0,i=o.getProperty().getRGBTransferFunction(a);if(i&&o.getProperty().getUseLookupTableScalarRange()){const e=i.getRange();t=e[1]-e[0],r=.5*(e[1]+e[0])}const c=l.scale/t,u=(l.shift-r)/t+.5;n.getProgram().setUniformf(`cshift${e}`,u),n.getProgram().setUniformf(`cscale${e}`,c)}for(let e=0;e<i;e++){let t=1,r=0;const a=s?e:0,i=o.getProperty().getPiecewiseFunction(a);if(i){const e=i.getRange(),n=e[1]-e[0],o=.5*(e[0]+e[1]);t=l.scale/n,r=(l.shift-o)/n+.5}n.getProgram().setUniformf(`pwfshift${e}`,r),n.getProgram().setUniformf(`pwfscale${e}`,t)}if(t.haveSeenDepthRequest&&n.getProgram().setUniformi(&quot;depthRequest&quot;,t.renderDepth?1:0),n.getProgram().isUniformUsed(&quot;coffset&quot;)){const t=e.getCoincidentParameters(r,o);n.getProgram().setUniformf(&quot;coffset&quot;,t.offset),n.getProgram().isUniformUsed(&quot;cfactor&quot;)&&n.getProgram().setUniformf(&quot;cfactor&quot;,t.factor)}const c=t.colorTexture.getTextureUnit();n.getProgram().setUniformi(&quot;colorTexture1&quot;,c);const u=t.pwfTexture.getTextureUnit();if(n.getProgram().setUniformi(&quot;pwfTexture1&quot;,u),o.getProperty().getUseLabelOutline()){const e=t.labelOutlineThicknessTexture.getTextureUnit();n.getProgram().setUniformi(&quot;labelOutlineTexture1&quot;,e);const r=t.labelOutlineOpacityTexture.getTextureUnit();n.getProgram().setUniformi(&quot;labelOutlineOpacityTexture1&quot;,r)}if(t.renderable.getNumberOfClippingPlanes()){let e=t.renderable.getNumberOfClippingPlanes();e>6&&(et(&quot;OpenGL has a limit of 6 clipping planes&quot;),e=6);const r=n.getCABO().getCoordShiftAndScaleEnabled()?n.getCABO().getInverseShiftAndScaleMatrix():null,a=r?p(t.imagematinv,o.getMatrix()):o.getMatrix();r&&(h(a,a),b(a,a,r),h(a,a)),h(t.imagemat,t.currentInput.getIndexToWorld()),b(t.imagematinv,a,t.imagemat);const i=[];for(let n=0;n<e;n++){const e=[];t.renderable.getClippingPlaneInDataCoords(t.imagematinv,n,e);for(let t=0;t<4;t++)i.push(e[t])}n.getProgram().setUniformi(&quot;numClipPlanes&quot;,e),n.getProgram().setUniform4fv(&quot;clipPlanes&quot;,i)}},e.setCameraShaderParameters=(n,r,o)=>{const a=n.getProgram(),i=t.openGLImageSlice.getKeyMatrices(),s=t.currentInput,l=s.getIndexToWorld();b(t.imagemat,i.mcwc,l);const c=t.openGLCamera.getKeyMatrices(r);if(b(t.imagemat,c.wcpc,t.imagemat),n.getCABO().getCoordShiftAndScaleEnabled()){const e=n.getCABO().getInverseShiftAndScaleMatrix();b(t.imagemat,t.imagemat,e)}if(a.setUniformMatrix(&quot;MCPCMatrix&quot;,t.imagemat),!0===o.getProperty().getUseLabelOutline()){const n=s.getWorldToIndex(),o=s.getDimensions();let i=t.renderable.getClosestIJKAxis().ijkMode;i===Nf.NONE&&(i=Nf.K),a.setUniform3i(&quot;imageDimensions&quot;,o[0],o[1],o[2]),a.setUniformi(&quot;sliceAxis&quot;,i),a.setUniformMatrix(&quot;vWCtoIDX&quot;,n);const l=t.openGLCamera.getKeyMatrices(r);v(t.projectionToWorld,l.wcpc),t.openGLCamera.getKeyMatrices(r),a.setUniformMatrix(&quot;PCWCMatrix&quot;,t.projectionToWorld);const c=e.getRenderTargetSize();a.setUniformf(&quot;vpWidth&quot;,c[0]),a.setUniformf(&quot;vpHeight&quot;,c[1]);const u=e.getRenderTargetOffset();a.setUniformf(&quot;vpOffsetX&quot;,u[0]/c[0]),a.setUniformf(&quot;vpOffsetY&quot;,u[1]/c[1])}},e.setPropertyShaderParameters=(e,t,n)=>{const r=e.getProgram(),o=n.getProperty().getOpacity();r.setUniformf(&quot;opacity&quot;,o)},e.renderPieceStart=(n,r)=>{e.updateBufferObjects(n,r),t.lastBoundBO=null},e.renderPieceDraw=(n,r)=>{const o=t.context;t.openGLTexture.activate(),t.colorTexture.activate(),r.getProperty().getUseLabelOutline()&&(t.labelOutlineThicknessTexture.activate(),t.labelOutlineOpacityTexture.activate()),t.pwfTexture.activate(),t.tris.getCABO().getElementCount()&&(e.updateShaders(t.tris,n,r),o.drawArrays(o.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release()),t.openGLTexture.deactivate(),t.colorTexture.deactivate(),r.getProperty().getUseLabelOutline()&&(t.labelOutlineThicknessTexture.deactivate(),t.labelOutlineOpacityTexture.deactivate()),t.pwfTexture.deactivate()},e.renderPieceFinish=(e,t)=>{},e.renderPiece=(n,r)=>{e.invokeEvent({type:&quot;StartEvent&quot;}),t.renderable.update(),t.currentInput=t.renderable.getCurrentImage(),e.invokeEvent({type:&quot;EndEvent&quot;}),t.currentInput?(e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r)):Bf(&quot;No input!&quot;)},e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n)},e.getNeedToRebuildBufferObjects=(n,r)=>t.VBOBuildTime.getMTime()<e.getMTime()||t.VBOBuildTime.getMTime()<r.getMTime()||t.VBOBuildTime.getMTime()<t.renderable.getMTime()||t.VBOBuildTime.getMTime()<r.getProperty().getMTime()||t.VBOBuildTime.getMTime()<t.currentInput.getMTime()||!t.openGLTexture?.getHandle()||!t.colorTexture?.getHandle()||r.getProperty().getUseLabelOutline()&&(!t.labelOutlineThicknessTexture?.getHandle()||!t.labelOutlineOpacityTexture?.getHandle())||!t.pwfTexture?.getHandle(),e.buildBufferObjects=(n,r)=>{const o=t.currentInput;if(!o)return;const a=o.getPointData()&&o.getPointData().getScalars();if(!a)return;const i=a.getDataType(),s=a.getNumberOfComponents(),l=r.getProperty(),c=l.getInterpolationType(),u=l.getIndependentComponents(),d=u?s:1,p=u?2*d:1,f=[];for(let e=0;e<d;++e)f.push(l.getRGBTransferFunction(e));const g=wf(f,u,d),m=l.getRGBTransferFunction(),h=t._openGLRenderWindow.getGraphicsResourceForObject(m);if(h?.oglObject?.getHandle()&&h?.hash===g)t.colorTexture=h.oglObject;else{t.colorTexture=Pd.newInstance({resizable:!0}),t.colorTexture.setOpenGLRenderWindow(t._openGLRenderWindow);let n=t.renderable.getColorTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=new Uint8ClampedArray(n*p*3);if(c===Pf.NEAREST?(t.colorTexture.setMinificationFilter(ud.NEAREST),t.colorTexture.setMagnificationFilter(ud.NEAREST)):(t.colorTexture.setMinificationFilter(ud.LINEAR),t.colorTexture.setMagnificationFilter(ud.LINEAR)),m){const e=new Float32Array(3*n);for(let t=0;t<d;t++){const o=l.getRGBTransferFunction(t),a=o.getRange();if(o.getTable(a[0],a[1],n,e,1),u)for(let o=0;o<3*n;o++)r[t*n*6+o]=255*e[o],r[t*n*6+o+3*n]=255*e[o];else for(let o=0;o<3*n;o++)r[t*n*6+o]=255*e[o]}t.colorTexture.resetFormatAndType(),t.colorTexture.create2DFromRaw({width:n,height:p,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r})}else{for(let e=0;e<3*n;++e)r[e]=255*e/(3*(n-1)),r[e+1]=255*e/(3*(n-1)),r[e+2]=255*e/(3*(n-1));t.colorTexture.create2DFromRaw({width:n,height:1,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r})}m&&(t._openGLRenderWindow.setGraphicsResourceForObject(m,t.colorTexture,g),m!==t._colorTransferFunc&&(t._openGLRenderWindow.registerGraphicsResourceUser(m,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._colorTransferFunc,e)),t._colorTransferFunc=m)}const v=[];for(let e=0;e<d;++e)v.push(l.getPiecewiseFunction(e));const T=wf(v,u,d),y=l.getPiecewiseFunction(),b=t._openGLRenderWindow.getGraphicsResourceForObject(y);if(b?.oglObject?.getHandle()&&b?.hash===T)t.pwfTexture=b.oglObject;else{let n=t.renderable.getOpacityTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=n*p,o=new Uint8ClampedArray(r);if(t.pwfTexture=Pd.newInstance({resizable:!0}),t.pwfTexture.setOpenGLRenderWindow(t._openGLRenderWindow),c===Pf.NEAREST?(t.pwfTexture.setMinificationFilter(ud.NEAREST),t.pwfTexture.setMagnificationFilter(ud.NEAREST)):(t.pwfTexture.setMinificationFilter(ud.LINEAR),t.pwfTexture.setMagnificationFilter(ud.LINEAR)),y){const e=new Float32Array(r),o=new Float32Array(n);for(let t=0;t<d;++t){const r=l.getPiecewiseFunction(t);if(null===r)e.fill(1);else{const a=r.getRange();if(r.getTable(a[0],a[1],n,o,1),u)for(let r=0;r<n;r++)e[t*n*2+r]=o[r],e[t*n*2+r+n]=o[r];else for(let r=0;r<n;r++)e[t*n*2+r]=o[r]}}t.pwfTexture.resetFormatAndType(),t.pwfTexture.create2DFromRaw({width:n,height:p,numComps:1,dataType:cs.FLOAT,data:e})}else o.fill(255),t.pwfTexture.create2DFromRaw({width:n,height:1,numComps:1,dataType:cs.UNSIGNED_CHAR,data:o});y&&(t._openGLRenderWindow.setGraphicsResourceForObject(y,t.pwfTexture,T),y!==t._pwFunc&&(t._openGLRenderWindow.registerGraphicsResourceUser(y,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._pwFunc,e)),t._pwFunc=y)}r.getProperty().getUseLabelOutline()&&(e.updatelabelOutlineThicknessTexture(r),e.updateLabelOutlineOpacityTexture(r));const{ijkMode:x}=t.renderable.getClosestIJKAxis();let C=t.renderable.getSlice();x!==t.renderable.getSlicingMode()&&(C=t.renderable.getSliceAtPosition(C));const S=t.renderable.isA(&quot;vtkImageArrayMapper&quot;)?t.renderable.getSubSlice():Math.round(C),A=o.getExtent();let I;x===Nf.I&&(I=S-A[0]),x===Nf.J&&(I=S-A[2]),x!==Nf.K&&x!==Nf.NONE||(I=S-A[4]);const w=`${C}A${o.getMTime()}A${a.getMTime()}B${e.getMTime()}C${t.renderable.getSlicingMode()}D${r.getProperty().getInterpolationType()}`;if(t.VBOBuildString!==w){const e=o.getDimensions();t.openGLTexture||(t.openGLTexture=Pd.newInstance({resizable:!0})),t.openGLTexture.setOpenGLRenderWindow(t._openGLRenderWindow),t.openGLTexture.setOglNorm16Ext(t.context.getExtension(&quot;EXT_texture_norm16&quot;)),c===Pf.NEAREST?(new Set([1,3,4]).has(s)&&i===cs.UNSIGNED_CHAR&&!u?(t.openGLTexture.setGenerateMipmap(!0),t.openGLTexture.setMinificationFilter(ud.NEAREST)):t.openGLTexture.setMinificationFilter(ud.NEAREST),t.openGLTexture.setMagnificationFilter(ud.NEAREST)):(4!==s||i!==cs.UNSIGNED_CHAR||u?t.openGLTexture.setMinificationFilter(ud.LINEAR):(t.openGLTexture.setGenerateMipmap(!0),t.openGLTexture.setMinificationFilter(ud.LINEAR_MIPMAP_LINEAR)),t.openGLTexture.setMagnificationFilter(ud.LINEAR)),t.openGLTexture.setWrapS(cd.CLAMP_TO_EDGE),t.openGLTexture.setWrapT(cd.CLAMP_TO_EDGE);const n=e[0]*e[1]*s,r=new Float32Array(12),l=new Float32Array(8);for(let e=0;e<4;e++)l[2*e]=e%2?1:0,l[2*e+1]=e>1?1:0;const d=[Nf.X,Nf.Y,Nf.Z].includes(t.renderable.getSlicingMode())?C:S,p=o.getSpatialExtent(),f=a.getData();let g=null;if(x===Nf.I){g=new f.constructor(e[2]*e[1]*s);let t=0;for(let n=0;n<e[2];n++)for(let r=0;r<e[1];r++){let o=(I+r*e[0]+n*e[0]*e[1])*s;t=(n*e[1]+r)*s;const a=o+s;for(;o<a;)g[t++]=f[o++]}e[0]=e[1],e[1]=e[2],r[0]=d,r[1]=p[2],r[2]=p[4],r[3]=d,r[4]=p[3],r[5]=p[4],r[6]=d,r[7]=p[2],r[8]=p[5],r[9]=d,r[10]=p[3],r[11]=p[5]}else if(x===Nf.J){g=new f.constructor(e[2]*e[0]*s);let t=0;for(let n=0;n<e[2];n++)for(let r=0;r<e[0];r++){let o=(r+I*e[0]+n*e[0]*e[1])*s;t=(n*e[0]+r)*s;const a=o+s;for(;o<a;)g[t++]=f[o++]}e[1]=e[2],r[0]=p[0],r[1]=d,r[2]=p[4],r[3]=p[1],r[4]=d,r[5]=p[4],r[6]=p[0],r[7]=d,r[8]=p[5],r[9]=p[1],r[10]=d,r[11]=p[5]}else x===Nf.K||x===Nf.NONE?(g=f.subarray(I*n,(I+1)*n),r[0]=p[0],r[1]=p[2],r[2]=d,r[3]=p[1],r[4]=p[2],r[5]=d,r[6]=p[0],r[7]=p[3],r[8]=d,r[9]=p[1],r[10]=p[3],r[11]=d):Bf(&quot;Reformat slicing not yet supported.&quot;);const m=a.getRanges();t.openGLTexture.resetFormatAndType(),t.openGLTexture.create2DFilterableFromRaw({width:e[0],height:e[1],numComps:s,dataType:a.getDataType(),data:g,preferSizeOverAccuracy:!!t.renderable.getPreferSizeOverAccuracy?.(),ranges:m}),t.openGLTexture.activate(),t.openGLTexture.sendParameters(),t.openGLTexture.deactivate();const h=xs.newInstance({numberOfComponents:3,values:r});h.setName(&quot;points&quot;);const v=xs.newInstance({numberOfComponents:2,values:l});v.setName(&quot;tcoords&quot;);const T=new Uint16Array(8);T[0]=3,T[1]=0,T[2]=1,T[3]=3,T[4]=3,T[5]=0,T[6]=3,T[7]=2;const y=xs.newInstance({numberOfComponents:1,values:T});t.tris.getCABO().createVBO(y,&quot;polys&quot;,Zi.SURFACE,{points:h,tcoords:v,cellOffset:0}),t.VBOBuildTime.modified(),t.VBOBuildString=w}},e.updateLabelOutlineOpacityTexture=n=>{let r=n.getProperty().getLabelOutlineOpacity();&quot;number&quot;==typeof r&&(r=t._cachedLabelOutlineOpacityObj?.[0]===r?t._cachedLabelOutlineOpacityObj:[r],t._cachedLabelOutlineOpacityObj=r);const o=t._openGLRenderWindow.getGraphicsResourceForObject(r),a=`${r.join(&quot;-&quot;)}`;if(o?.oglObject?.getHandle()&&o?.hash===a)t.labelOutlineOpacityTexture=o.oglObject;else{let n=t.renderable.getLabelOutlineTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const o=1,i=new Float32Array(n*o);for(let e=0;e<n;++e)i[e]=r[e]??r[0];t.labelOutlineOpacityTexture=Pd.newInstance({resizable:!1}),t.labelOutlineOpacityTexture.setOpenGLRenderWindow(t._openGLRenderWindow),t.labelOutlineOpacityTexture.resetFormatAndType(),t.labelOutlineOpacityTexture.setMinificationFilter(ud.NEAREST),t.labelOutlineOpacityTexture.setMagnificationFilter(ud.NEAREST),t.labelOutlineOpacityTexture.create2DFromRaw({width:n,height:o,numComps:1,dataType:cs.FLOAT,data:i}),r&&(t._openGLRenderWindow.setGraphicsResourceForObject(r,t.labelOutlineOpacityTexture,a),r!==t._labelOutlineOpacity&&(t._openGLRenderWindow.registerGraphicsResourceUser(r,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._labelOutlineOpacity,e)),t._labelOutlineOpacity=r)}},e.updatelabelOutlineThicknessTexture=n=>{const r=n.getProperty().getLabelOutlineThicknessByReference(),o=t._openGLRenderWindow.getGraphicsResourceForObject(r),a=`${r.join(&quot;-&quot;)}`;if(o?.oglObject?.getHandle()&&o?.hash===a)t.labelOutlineThicknessTexture=o.oglObject;else{let n=t.renderable.getLabelOutlineTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const o=1,i=new Uint8Array(n*o);for(let e=0;e<n;++e){const t=void 0!==r[e]?r[e]:r[0];i[e]=t}t.labelOutlineThicknessTexture=Pd.newInstance({resizable:!1}),t.labelOutlineThicknessTexture.setOpenGLRenderWindow(t._openGLRenderWindow),t.labelOutlineThicknessTexture.resetFormatAndType(),t.labelOutlineThicknessTexture.setMinificationFilter(ud.NEAREST),t.labelOutlineThicknessTexture.setMagnificationFilter(ud.NEAREST),t.labelOutlineThicknessTexture.create2DFromRaw({width:n,height:o,numComps:1,dataType:cs.UNSIGNED_CHAR,data:i}),r&&(t._openGLRenderWindow.setGraphicsResourceForObject(r,t.labelOutlineThicknessTexture,a),r!==t._labelOutlineThicknessArray&&(t._openGLRenderWindow.registerGraphicsResourceUser(r,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._labelOutlineThicknessArray,e)),t._labelOutlineThicknessArray=r)}},e.getRenderTargetSize=()=>{if(t._useSmallViewport)return[t._smallViewportWidth,t._smallViewportHeight];const{usize:e,vsize:n}=t._openGLRenderer.getTiledSizeAndOrigin();return[e,n]},e.getRenderTargetOffset=()=>{const{lowerLeftU:e,lowerLeftV:n}=t._openGLRenderer.getTiledSizeAndOrigin();return[e,n]},e.delete=Et((()=>{t._openGLRenderWindow&&n(t._openGLRenderWindow)}),e.delete)}(e,t)}),&quot;vtkOpenGLImageMapper&quot;);Jt(&quot;vtkAbstractImageMapper&quot;,kf);const Gf=0,Uf=1,zf=2,{vtkErrorMacro:Wf}=Wt,Hf={currentRenderPass:null,volumeTexture:null,colorTexture:null,pwfTexture:null,tris:null,lastHaveSeenDepthRequest:!1,haveSeenDepthRequest:!1,lastTextureComponents:0,lastIndependentComponents:0,imagemat:null,imagematinv:null};const jf=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Hf,n),qt.extend(e,t,n),Ed(e,t,n),Wt.algo(e,t,2,0),t.tris=ld.newInstance(),t.volumeTexture=null,t.colorTexture=null,t.pwfTexture=null,t.imagemat=m(new Float64Array(16)),t.imagematinv=m(new Float64Array(16)),t.VBOBuildTime={},Wt.obj(t.VBOBuildTime,{mtime:0}),function(e,t){function n(n){[t._scalars,t._colorTransferFunc,t._pwFunc].forEach((t=>n.unregisterGraphicsResourceUser(t,e)))}t.classHierarchy.push(&quot;vtkOpenGLImageCPRMapper&quot;),e.buildPass=r=>{if(r){t.currentRenderPass=null,t.openGLImageSlice=e.getFirstAncestorOfType(&quot;vtkOpenGLImageSlice&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;);const r=t._openGLRenderWindow;t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),r&&!r.isDeleted()&&r!==t._openGLRenderWindow&&n(r),t.context=t._openGLRenderWindow.getContext(),t.openGLCamera=t._openGLRenderer.getViewNodeFor(t._openGLRenderer.getRenderable().getActiveCamera()),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow)}},e.opaquePass=(n,r)=>{n&&(t.currentRenderPass=r,e.render())},e.opaqueZBufferPass=n=>{n&&(t.haveSeenDepthRequest=!0,t.renderDepth=!0,e.render(),t.renderDepth=!1)},e.getCoincidentParameters=(e,n)=>t.renderable.getResolveCoincidentTopology()===gl.PolygonOffset?t.renderable.getCoincidentTopologyPolygonOffsetParameters():null,e.render=()=>{const n=t.openGLImageSlice.getRenderable(),r=t._openGLRenderer.getRenderable();e.renderPiece(r,n)},e.renderPiece=(n,r)=>{e.invokeEvent({type:&quot;StartEvent&quot;}),t.renderable.update(),e.invokeEvent({type:&quot;EndEvent&quot;}),t.renderable.preRenderCheck()&&(t.currentImageDataInput=t.renderable.getInputData(0),t.currentCenterlineInput=t.renderable.getOrientedCenterline(),e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r))},e.renderPieceStart=(t,n)=>{e.updateBufferObjects(t,n)},e.renderPieceDraw=(n,r)=>{const o=t.context;t.volumeTexture.activate(),t.colorTexture.activate(),t.pwfTexture.activate(),t.tris.getCABO().getElementCount()&&(e.updateShaders(t.tris,n,r),o.drawArrays(o.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release()),t.volumeTexture.deactivate(),t.colorTexture.deactivate(),t.pwfTexture.deactivate()},e.renderPieceFinish=(e,t)=>{},e.updateBufferObjects=(n,r)=>{e.getNeedToRebuildBufferObjects(n,r)&&e.buildBufferObjects(n,r),r.getProperty().getInterpolationType()===Pf.NEAREST?(t.volumeTexture.setMinificationFilter(ud.NEAREST),t.volumeTexture.setMagnificationFilter(ud.NEAREST),t.colorTexture.setMinificationFilter(ud.NEAREST),t.colorTexture.setMagnificationFilter(ud.NEAREST),t.pwfTexture.setMinificationFilter(ud.NEAREST),t.pwfTexture.setMagnificationFilter(ud.NEAREST)):(t.volumeTexture.setMinificationFilter(ud.LINEAR),t.volumeTexture.setMagnificationFilter(ud.LINEAR),t.colorTexture.setMinificationFilter(ud.LINEAR),t.colorTexture.setMagnificationFilter(ud.LINEAR),t.pwfTexture.setMinificationFilter(ud.LINEAR),t.pwfTexture.setMagnificationFilter(ud.LINEAR))},e.getNeedToRebuildBufferObjects=(n,r)=>{const o=t.VBOBuildTime.getMTime();return o<e.getMTime()||o<t.renderable.getMTime()||o<r.getMTime()||o<t.currentImageDataInput.getMTime()||o<t.currentCenterlineInput.getMTime()||!t.volumeTexture?.getHandle()},e.buildBufferObjects=(n,r)=>{const o=t.currentImageDataInput,a=t.currentCenterlineInput,i=r.getProperty(),s=o?.getPointData()?.getScalars();if(!s)return;const l=t._openGLRenderWindow.getGraphicsResourceForObject(s),c=Of(0,s),u=!l?.oglObject?.getHandle()||l?.hash!==c,d=i.getUpdatedExtents(),p=!!d.length;if(u){t.volumeTexture=Pd.newInstance(),t.volumeTexture.setOpenGLRenderWindow(t._openGLRenderWindow);const n=o.getDimensions();t.volumeTexture.setOglNorm16Ext(t.context.getExtension(&quot;EXT_texture_norm16&quot;)),t.volumeTexture.resetFormatAndType(),t.volumeTexture.create3DFilterableFromDataArray({width:n[0],height:n[1],depth:n[2],dataArray:s,preferSizeOverAccuracy:t.renderable.getPreferSizeOverAccuracy()}),t._openGLRenderWindow.setGraphicsResourceForObject(s,t.volumeTexture,c),s!==t._scalars&&(t._openGLRenderWindow.registerGraphicsResourceUser(s,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._scalars,e)),t._scalars=s}else t.volumeTexture=l.oglObject;if(p){i.setUpdatedExtents([]);const e=o.getDimensions();t.volumeTexture.create3DFilterableFromDataArray({width:e[0],height:e[1],depth:e[2],dataArray:s,updatedExtents:d})}const f=s.getNumberOfComponents(),g=r.getProperty(),m=g.getIndependentComponents(),h=m?f:1,v=m?2*h:1,T=[];for(let e=0;e<h;++e)T.push(g.getRGBTransferFunction(e));const y=wf(T,m,h),b=g.getRGBTransferFunction(),x=t._openGLRenderWindow.getGraphicsResourceForObject(b);if(x?.oglObject?.getHandle()&&x?.hash===y)t.colorTexture=x.oglObject;else{let n=t.renderable.getColorTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=new Uint8ClampedArray(n*v*3);if(t.colorTexture=Pd.newInstance(),t.colorTexture.setOpenGLRenderWindow(t._openGLRenderWindow),b){const e=new Float32Array(3*n);for(let t=0;t<h;t++){const o=g.getRGBTransferFunction(t),a=o.getRange();if(o.getTable(a[0],a[1],n,e,1),m)for(let o=0;o<3*n;o++)r[t*n*6+o]=255*e[o],r[t*n*6+o+3*n]=255*e[o];else for(let o=0;o<3*n;o++)r[t*n*6+o]=255*e[o]}t.colorTexture.resetFormatAndType(),t.colorTexture.create2DFromRaw({width:n,height:v,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r})}else{for(let e=0;e<3*n;++e)r[e]=255*e/(3*(n-1)),r[e+1]=255*e/(3*(n-1)),r[e+2]=255*e/(3*(n-1));t.colorTexture.resetFormatAndType(),t.colorTexture.create2DFromRaw({width:n,height:1,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r})}b&&(t._openGLRenderWindow.setGraphicsResourceForObject(b,t.colorTexture,y),b!==t._colorTransferFunc&&(t._openGLRenderWindow.registerGraphicsResourceUser(b,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._colorTransferFunc,e)),t._colorTransferFunc=b)}const C=[];for(let e=0;e<h;++e)C.push(g.getPiecewiseFunction(e));const S=wf(C,m,h),A=g.getPiecewiseFunction(),I=t._openGLRenderWindow.getGraphicsResourceForObject(A);if(I?.oglObject?.getHandle()&&I?.hash===S)t.pwfTexture=I.oglObject;else{let n=t.renderable.getOpacityTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=n*v,o=new Uint8ClampedArray(r);if(t.pwfTexture=Pd.newInstance(),t.pwfTexture.setOpenGLRenderWindow(t._openGLRenderWindow),A){const e=new Float32Array(r),o=new Float32Array(n);for(let t=0;t<h;++t){const r=g.getPiecewiseFunction(t);if(null===r)e.fill(1);else{const a=r.getRange();if(r.getTable(a[0],a[1],n,o,1),m)for(let r=0;r<n;r++)e[t*n*2+r]=o[r],e[t*n*2+r+n]=o[r];else for(let r=0;r<n;r++)e[t*n*2+r]=o[r]}}t.pwfTexture.resetFormatAndType(),t.pwfTexture.create2DFromRaw({width:n,height:v,numComps:1,dataType:cs.FLOAT,data:e})}else o.fill(255),t.pwfTexture.resetFormatAndType(),t.pwfTexture.create2DFromRaw({width:n,height:1,numComps:1,dataType:cs.UNSIGNED_CHAR,data:o});A&&(t._openGLRenderWindow.setGraphicsResourceForObject(A,t.pwfTexture,S),A!==t._pwFunc&&(t._openGLRenderWindow.registerGraphicsResourceUser(A,e),t._openGLRenderWindow.unregisterGraphicsResourceUser(t._pwFunc,e)),t._pwFunc=A)}if(t.VBOBuildTime.getMTime()<t.renderable.getMTime()||t.VBOBuildTime.getMTime()<a.getMTime()){const e=a.getNumberOfPoints(),n=e<=1?0:e-1,r=a.getDistancesToFirstPoint(),o=t.renderable.getHeight(),i=4*n,s=new Float32Array(3*i),l=t.renderable.getWidth();for(let e=0,t=0;e<n;++e)s.set([0,o-r[e],0],t),t+=3,s.set([l,o-r[e],0],t),t+=3,s.set([l,o-r[e+1],0],t),t+=3,s.set([0,o-r[e+1],0],t),t+=3;const c=xs.newInstance({numberOfComponents:3,values:s});c.setName(&quot;points&quot;);const u=new Uint16Array(5*n);for(let e=0,t=0,r=0;e<n;++e)u.set([4,r+3,r+2,r+1,r],t),t+=5,r+=4;const d=xs.newInstance({numberOfComponents:1,values:u}),p=a.getPoints(),f=new Float32Array(3*i),g=new Array(3),m=new Array(3);for(let e=0,t=0;e<n;++e)p.getPoint(e,g),p.getPoint(e+1,m),f.set(g,t),t+=3,f.set(g,t),t+=3,f.set(m,t),t+=3,f.set(m,t),t+=3;const h=xs.newInstance({numberOfComponents:3,values:f,name:&quot;centerlinePosition&quot;}),v=new Float32Array(i);for(let e=0,t=0;e<n;++e)v.set([0,1,3,2],t),t+=4;const T=[h,xs.newInstance({numberOfComponents:1,values:v,name:&quot;quadIndex&quot;})];if(!t.renderable.getUseUniformOrientation()){const e=t.renderable.getOrientedCenterline().getOrientations()??[],r=new Float32Array(4*i),o=new Float32Array(4*i);for(let t=0;t<n;++t){const n=e[t],a=e[t+1];for(let e=0;e<4;++e){const i=4*(e+4*t);r.set(n,i),o.set(a,i)}}const a=xs.newInstance({numberOfComponents:4,values:r,name:&quot;centerlineTopOrientation&quot;}),s=xs.newInstance({numberOfComponents:4,values:o,name:&quot;centerlineBotOrientation&quot;});T.push(a,s)}t.tris.getCABO().createVBO(d,&quot;polys&quot;,Zi.SURFACE,{points:c,customAttributes:T}),t.VBOBuildTime.modified()}},e.getNeedToRebuildShaders=(e,n,r)=>{const o=t.volumeTexture.getComponents(),a=r.getProperty().getIndependentComponents(),i=!!t.renderable.getCenterPoint(),s=t.renderable.getUseUniformOrientation(),l=t.renderable.isProjectionEnabled()&&t.renderable.getProjectionMode();return(0===e.getProgram()||t.lastUseCenterPoint!==i||t.lastUseUniformOrientation!==s||t.lastProjectionMode!==l||t.lastHaveSeenDepthRequest!==t.haveSeenDepthRequest||t.lastTextureComponents!==o||t.lastIndependentComponents!==a)&&(t.lastUseCenterPoint=i,t.lastUseUniformOrientation=s,t.lastProjectionMode=l,t.lastHaveSeenDepthRequest=t.haveSeenDepthRequest,t.lastTextureComponents=o,t.lastIndependentComponents=a,!0)},e.buildShaders=(t,n,r)=>{e.getShaderTemplate(t,n,r),e.replaceShaderValues(t,n,r)},e.replaceShaderValues=(n,r,o)=>{let a=n.Vertex,i=n.Fragment;const s=[&quot;vec3 applyQuaternionToVec(vec4 q, vec3 v) {&quot;,&quot;  float uvx = q.y * v.z - q.z * v.y;&quot;,&quot;  float uvy = q.z * v.x - q.x * v.z;&quot;,&quot;  float uvz = q.x * v.y - q.y * v.x;&quot;,&quot;  float uuvx = q.y * uvz - q.z * uvy;&quot;,&quot;  float uuvy = q.z * uvx - q.x * uvz;&quot;,&quot;  float uuvz = q.x * uvy - q.y * uvx;&quot;,&quot;  float w2 = q.w * 2.0;&quot;,&quot;  uvx *= w2;&quot;,&quot;  uvy *= w2;&quot;,&quot;  uvz *= w2;&quot;,&quot;  uuvx *= 2.0;&quot;,&quot;  uuvy *= 2.0;&quot;,&quot;  uuvz *= 2.0;&quot;,&quot;  return vec3(v.x + uvx + uuvx, v.y + uvy + uuvy, v.z + uvz + uuvz);&quot;,&quot;}&quot;];a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 MCPCMatrix;&quot;]).result,a=td.substitute(a,&quot;//VTK::PositionVC::Impl&quot;,[&quot;  gl_Position = MCPCMatrix * vertexMC;&quot;]).result;const l=[&quot;attribute vec3 centerlinePosition;&quot;,&quot;attribute float quadIndex;&quot;,&quot;uniform float width;&quot;,&quot;out vec2 quadOffsetVSOutput;&quot;,&quot;out vec3 centerlinePosVSOutput;&quot;],c=t.renderable.isProjectionEnabled(),u=t.renderable.getUseUniformOrientation();u?(l.push(&quot;out vec3 samplingDirVSOutput;&quot;,&quot;uniform vec4 centerlineOrientation;&quot;,&quot;uniform vec3 tangentDirection;&quot;,...s),c&&l.push(&quot;out vec3 projectionDirVSOutput;&quot;,&quot;uniform vec3 bitangentDirection;&quot;)):l.push(&quot;out vec4 centerlineTopOrientationVSOutput;&quot;,&quot;out vec4 centerlineBotOrientationVSOutput;&quot;,&quot;attribute vec4 centerlineTopOrientation;&quot;,&quot;attribute vec4 centerlineBotOrientation;&quot;),a=td.substitute(a,&quot;//VTK::Color::Dec&quot;,l).result;const d=[&quot;quadOffsetVSOutput = vec2(width * (mod(quadIndex, 2.0) == 0.0 ? -0.5 : 0.5), quadIndex > 1.0 ? 0.0 : 1.0);&quot;,&quot;centerlinePosVSOutput = centerlinePosition;&quot;];u?(d.push(&quot;samplingDirVSOutput = applyQuaternionToVec(centerlineOrientation, tangentDirection);&quot;),c&&d.push(&quot;projectionDirVSOutput = applyQuaternionToVec(centerlineOrientation, bitangentDirection);&quot;)):d.push(&quot;centerlineTopOrientationVSOutput = centerlineTopOrientation;&quot;,&quot;centerlineBotOrientationVSOutput = centerlineBotOrientation;&quot;),a=td.substitute(a,&quot;//VTK::Color::Impl&quot;,d).result;const p=t.volumeTexture.getComponents(),f=o.getProperty().getIndependentComponents();let g=[&quot;uniform mat4 MCTCMatrix; // Model coordinates to texture coordinates&quot;,&quot;in vec2 quadOffsetVSOutput;&quot;,&quot;in vec3 centerlinePosVSOutput;&quot;,&quot;uniform highp sampler3D volumeTexture;&quot;,&quot;uniform sampler2D colorTexture1;&quot;,&quot;uniform sampler2D pwfTexture1;&quot;,&quot;uniform float opacity;&quot;,&quot;uniform vec4 backgroundColor;&quot;,&quot;uniform float cshift0;&quot;,&quot;uniform float cscale0;&quot;,&quot;uniform float pwfshift0;&quot;,&quot;uniform float pwfscale0;&quot;];c&&g.push(&quot;uniform vec3 volumeSizeMC;&quot;,&quot;uniform int projectionSlabNumberOfSamples;&quot;,&quot;uniform float projectionConstantOffset;&quot;,&quot;uniform float projectionStepLength;&quot;),u?(g.push(&quot;in vec3 samplingDirVSOutput;&quot;),c&&g.push(&quot;in vec3 projectionDirVSOutput;&quot;)):(g.push(&quot;uniform vec3 tangentDirection;&quot;,&quot;in vec4 centerlineTopOrientationVSOutput;&quot;,&quot;in vec4 centerlineBotOrientationVSOutput;&quot;,...s),c&&g.push(&quot;uniform vec3 bitangentDirection;&quot;));const m=t.renderable.getCenterPoint();if(m&&g.push(&quot;uniform vec3 globalCenterPoint;&quot;),f){for(let e=1;e<p;e++)g=g.concat([`uniform float cshift${e};`,`uniform float cscale${e};`,`uniform float pwfshift${e};`,`uniform float pwfscale${e};`]);switch(p){case 1:g=g.concat([&quot;uniform float mix0;&quot;,&quot;#define height0 0.5&quot;]);break;case 2:g=g.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;#define height0 0.25&quot;,&quot;#define height1 0.75&quot;]);break;case 3:g=g.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;#define height0 0.17&quot;,&quot;#define height1 0.5&quot;,&quot;#define height2 0.83&quot;]);break;case 4:g=g.concat([&quot;uniform float mix0;&quot;,&quot;uniform float mix1;&quot;,&quot;uniform float mix2;&quot;,&quot;uniform float mix3;&quot;,&quot;#define height0 0.125&quot;,&quot;#define height1 0.375&quot;,&quot;#define height2 0.625&quot;,&quot;#define height3 0.875&quot;]);break;default:Wf(&quot;Unsupported number of independent coordinates.&quot;)}}i=td.substitute(i,&quot;//VTK::TCoord::Dec&quot;,g).result;let h=[];if(u?(h.push(&quot;vec3 samplingDirection = samplingDirVSOutput;&quot;),c&&h.push(&quot;vec3 projectionDirection = projectionDirVSOutput;&quot;)):(h.push(&quot;vec4 q0 = centerlineBotOrientationVSOutput;&quot;,&quot;vec4 q1 = centerlineTopOrientationVSOutput;&quot;,&quot;float qCosAngle = dot(q0, q1);&quot;,&quot;vec4 interpolatedOrientation;&quot;,&quot;if (qCosAngle > 0.999 || qCosAngle < -0.999) {&quot;,&quot;  // Use LERP instead of SLERP when the two quaternions are close or opposite&quot;,&quot;  interpolatedOrientation = normalize(mix(q0, q1, quadOffsetVSOutput.y));&quot;,&quot;} else {&quot;,&quot;  float omega = acos(qCosAngle);&quot;,&quot;  interpolatedOrientation = normalize(sin((1.0 - quadOffsetVSOutput.y) * omega) * q0 + sin(quadOffsetVSOutput.y * omega) * q1);&quot;,&quot;}&quot;,&quot;vec3 samplingDirection = applyQuaternionToVec(interpolatedOrientation, tangentDirection);&quot;),c&&h.push(&quot;vec3 projectionDirection = applyQuaternionToVec(interpolatedOrientation, bitangentDirection);&quot;)),m?h.push(&quot;float baseOffset = dot(samplingDirection, globalCenterPoint - centerlinePosVSOutput);&quot;,&quot;float horizontalOffset = quadOffsetVSOutput.x + baseOffset;&quot;):h.push(&quot;float horizontalOffset = quadOffsetVSOutput.x;&quot;),h.push(&quot;vec3 volumePosMC = centerlinePosVSOutput + horizontalOffset * samplingDirection;&quot;,&quot;vec3 volumePosTC = (MCTCMatrix * vec4(volumePosMC, 1.0)).xyz;&quot;,&quot;if (any(lessThan(volumePosTC, vec3(0.0))) || any(greaterThan(volumePosTC, vec3(1.0))))&quot;,&quot;{&quot;,&quot;  // set the background color and exit&quot;,&quot;  gl_FragData[0] = backgroundColor;&quot;,&quot;  return;&quot;,&quot;}&quot;),c){const e=t.renderable.getProjectionMode();switch(e===Uf?h.push(&quot;const vec4 initialProjectionTextureValue = vec4(1.0);&quot;):h.push(&quot;const vec4 initialProjectionTextureValue = vec4(0.0);&quot;),h.push(&quot;vec3 projectionScaledDirection = projectionDirection / volumeSizeMC;&quot;,&quot;vec3 projectionStep = projectionStepLength * projectionScaledDirection;&quot;,&quot;vec3 projectionStartPosition = volumePosTC + projectionConstantOffset * projectionScaledDirection;&quot;,&quot;vec4 tvalue = initialProjectionTextureValue;&quot;,&quot;for (int projectionSampleIdx = 0; projectionSampleIdx < projectionSlabNumberOfSamples; ++projectionSampleIdx) {&quot;,&quot;  vec3 projectionSamplePosition = projectionStartPosition + float(projectionSampleIdx) * projectionStep;&quot;,&quot;  vec4 sampledTextureValue = texture(volumeTexture, projectionSamplePosition);&quot;),e){case Gf:h.push(&quot;  tvalue = max(tvalue, sampledTextureValue);&quot;);break;case Uf:h.push(&quot;  tvalue = min(tvalue, sampledTextureValue);&quot;);break;default:h.push(&quot;  tvalue = tvalue + sampledTextureValue;&quot;)}h.push(&quot;}&quot;),e===zf&&h.push(&quot;tvalue = tvalue / float(projectionSlabNumberOfSamples);&quot;)}else h.push(&quot;vec4 tvalue = texture(volumeTexture, volumePosTC);&quot;);if(f){const e=[&quot;r&quot;,&quot;g&quot;,&quot;b&quot;,&quot;a&quot;];for(let t=0;t<p;++t)h=h.concat([`vec3 tcolor${t} = mix${t} * texture2D(colorTexture1, vec2(tvalue.${e[t]} * cscale${t} + cshift${t}, height${t})).rgb;`,`float compWeight${t} = mix${t} * texture2D(pwfTexture1, vec2(tvalue.${e[t]} * pwfscale${t} + pwfshift${t}, height${t})).r;`]);switch(p){case 1:h=h.concat([&quot;gl_FragData[0] = vec4(tcolor0.rgb, compWeight0 * opacity);&quot;]);break;case 2:h=h.concat([&quot;float weightSum = compWeight0 + compWeight1;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum))), opacity);&quot;]);break;case 3:h=h.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum))), opacity);&quot;]);break;case 4:h=h.concat([&quot;float weightSum = compWeight0 + compWeight1 + compWeight2 + compWeight3;&quot;,&quot;gl_FragData[0] = vec4(vec3((tcolor0.rgb * (compWeight0 / weightSum)) + (tcolor1.rgb * (compWeight1 / weightSum)) + (tcolor2.rgb * (compWeight2 / weightSum)) + (tcolor3.rgb * (compWeight3 / weightSum))), opacity);&quot;]);break;default:Wf(&quot;Unsupported number of independent coordinates.&quot;)}}else switch(p){case 1:h=h.concat([&quot;// Dependent components&quot;,&quot;float intensity = tvalue.r;&quot;,&quot;vec3 tcolor = texture2D(colorTexture1, vec2(intensity * cscale0 + cshift0, 0.5)).rgb;&quot;,&quot;float scalarOpacity = texture2D(pwfTexture1, vec2(intensity * pwfscale0 + pwfshift0, 0.5)).r;&quot;,&quot;gl_FragData[0] = vec4(tcolor, scalarOpacity * opacity);&quot;]);break;case 2:h=h.concat([&quot;float intensity = tvalue.r*cscale0 + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(intensity, 0.5)).rgb, pwfscale0*tvalue.g + pwfshift0);&quot;]);break;case 3:h=h.concat([&quot;vec4 tcolor = cscale0*tvalue + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, opacity);&quot;]);break;default:h=h.concat([&quot;vec4 tcolor = cscale0*tvalue + cshift0;&quot;,&quot;gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,&quot;,&quot;  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, tcolor.a);&quot;])}i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,h).result,t.haveSeenDepthRequest&&(i=td.substitute(i,&quot;//VTK::ZBuffer::Dec&quot;,&quot;uniform int depthRequest;&quot;).result,i=td.substitute(i,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float iz = floor(gl_FragCoord.z*65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result),n.Vertex=a,n.Fragment=i,e.replaceShaderClip(n,r,o),e.replaceShaderCoincidentOffset(n,r,o)},e.replaceShaderClip=(e,n,r)=>{let o=e.Vertex,a=e.Fragment;if(t.renderable.getNumberOfClippingPlanes()){let e=t.renderable.getNumberOfClippingPlanes();e>6&&(Wt.vtkErrorMacro(&quot;OpenGL has a limit of 6 clipping planes&quot;),e=6),o=td.substitute(o,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,&quot;uniform vec4 clipPlanes[6];&quot;,&quot;varying float clipDistancesVSOutput[6];&quot;]).result,o=td.substitute(o,&quot;//VTK::Clip::Impl&quot;,[&quot;for (int planeNum = 0; planeNum < 6; planeNum++)&quot;,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], vertexMC);&quot;,&quot;    }&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Dec&quot;,[&quot;uniform int numClipPlanes;&quot;,&quot;varying float clipDistancesVSOutput[6];&quot;]).result,a=td.substitute(a,&quot;//VTK::Clip::Impl&quot;,[&quot;for (int planeNum = 0; planeNum < 6; planeNum++)&quot;,&quot;    {&quot;,&quot;    if (planeNum >= numClipPlanes)&quot;,&quot;        {&quot;,&quot;        break;&quot;,&quot;        }&quot;,&quot;    if (clipDistancesVSOutput[planeNum] < 0.0) discard;&quot;,&quot;    }&quot;]).result}e.Vertex=o,e.Fragment=a},e.getShaderTemplate=(e,t,n)=>{e.Vertex=Rd,e.Fragment=Md,e.Geometry=&quot;&quot;},e.setMapperShaderParameters=(n,r,o)=>{const a=n.getProgram(),i=n.getCABO();i.getElementCount()&&(t.VBOBuildTime.getMTime()>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())&&(a.isAttributeUsed(&quot;vertexMC&quot;)&&(n.getVAO().addAttributeArray(a,i,&quot;vertexMC&quot;,i.getVertexOffset(),i.getStride(),t.context.FLOAT,3,t.context.FALSE)||Wf(&quot;Error setting vertexMC in shader VAO.&quot;)),n.getCABO().getCustomData().forEach((e=>{e&&a.isAttributeUsed(e.name)&&!n.getVAO().addAttributeArray(a,i,e.name,e.offset,i.getStride(),t.context.FLOAT,e.components,t.context.FALSE)&&Wf(`Error setting ${e.name} in shader VAO.`)})),n.getAttributeUpdateTime().modified());const s=t.volumeTexture.getTextureUnit();if(a.setUniformi(&quot;volumeTexture&quot;,s),a.setUniformf(&quot;width&quot;,t.renderable.getWidth()),n.getProgram().setUniform4fv(&quot;backgroundColor&quot;,t.renderable.getBackgroundColor()),a.isUniformUsed(&quot;tangentDirection&quot;)){const e=t.renderable.getTangentDirection();n.getProgram().setUniform3fArray(&quot;tangentDirection&quot;,e)}if(a.isUniformUsed(&quot;bitangentDirection&quot;)){const e=t.renderable.getBitangentDirection();n.getProgram().setUniform3fArray(&quot;bitangentDirection&quot;,e)}if(a.isUniformUsed(&quot;centerlineOrientation&quot;)){const e=t.renderable.getUniformOrientation();n.getProgram().setUniform4fv(&quot;centerlineOrientation&quot;,e)}if(a.isUniformUsed(&quot;globalCenterPoint&quot;)){const e=t.renderable.getCenterPoint();a.setUniform3fArray(&quot;globalCenterPoint&quot;,e)}if(t.renderable.isProjectionEnabled()){const e=t.currentImageDataInput,n=e.getSpacing(),r=e.getDimensions(),o=t.renderable.getProjectionSlabThickness(),i=t.renderable.getProjectionSlabNumberOfSamples(),s=Mn([],n,r);a.setUniform3fArray(&quot;volumeSizeMC&quot;,s),a.setUniformi(&quot;projectionSlabNumberOfSamples&quot;,i);const l=-.5*o;a.setUniformf(&quot;projectionConstantOffset&quot;,l);const c=o/(i-1);a.setUniformf(&quot;projectionStepLength&quot;,c)}const l=t.currentImageDataInput,c=l.getWorldToIndex(),u=P(new Float32Array(16),xn([],l.getDimensions())),d=ae(u,u,c);if(a.setUniformMatrix(&quot;MCTCMatrix&quot;,d),t.haveSeenDepthRequest&&n.getProgram().setUniformi(&quot;depthRequest&quot;,t.renderDepth?1:0),t.renderable.getNumberOfClippingPlanes()){let e=t.renderable.getNumberOfClippingPlanes();e>6&&(Wt.vtkErrorMacro(&quot;OpenGL has a limit of 6 clipping planes&quot;),e=6);const n=i.getCoordShiftAndScaleEnabled()?i.getInverseShiftAndScaleMatrix():null,r=n?p(t.imagematinv,o.getMatrix()):o.getMatrix();n&&(h(r,r),b(r,r,n),h(r,r)),h(t.imagemat,t.currentImageDataInput.getIndexToWorld()),b(t.imagematinv,r,t.imagemat);const s=[];for(let n=0;n<e;n++){const e=[];t.renderable.getClippingPlaneInDataCoords(t.imagematinv,n,e);for(let t=0;t<4;t++)s.push(e[t])}a.setUniformi(&quot;numClipPlanes&quot;,e),a.setUniform4fv(&quot;clipPlanes&quot;,s)}if(a.isUniformUsed(&quot;coffset&quot;)){const t=e.getCoincidentParameters(r,o);a.setUniformf(&quot;coffset&quot;,t.offset),a.isUniformUsed(&quot;cfactor&quot;)&&a.setUniformf(&quot;cfactor&quot;,t.factor)}},e.setCameraShaderParameters=(e,n,r)=>{const o=t.openGLImageSlice.getKeyMatrices().mcwc,a=t.openGLCamera.getKeyMatrices(n).wcpc;if(b(t.imagemat,a,o),e.getCABO().getCoordShiftAndScaleEnabled()){const n=e.getCABO().getInverseShiftAndScaleMatrix();b(t.imagemat,t.imagemat,n)}e.getProgram().setUniformMatrix(&quot;MCPCMatrix&quot;,t.imagemat)},e.setPropertyShaderParameters=(e,n,r)=>{const o=e.getProgram(),a=r.getProperty(),i=a.getOpacity();o.setUniformf(&quot;opacity&quot;,i);const s=t.volumeTexture.getComponents(),l=a.getIndependentComponents();if(l)for(let e=0;e<s;++e)o.setUniformf(`mix${e}`,a.getComponentWeight(e));const c=t.volumeTexture.getVolumeInfo();for(let e=0;e<s;e++){let t=a.getColorWindow(),n=a.getColorLevel();const r=l?e:0,i=a.getRGBTransferFunction(r);if(i&&a.getUseLookupTableScalarRange()){const e=i.getRange();t=e[1]-e[0],n=.5*(e[1]+e[0])}const s=c.scale[e]/t,u=(c.offset[e]-n)/t+.5;o.setUniformf(`cshift${e}`,u),o.setUniformf(`cscale${e}`,s)}const u=t.colorTexture.getTextureUnit();o.setUniformi(&quot;colorTexture1&quot;,u);for(let e=0;e<s;e++){let t=1,n=0;const r=l?e:0,i=a.getPiecewiseFunction(r);if(i){const r=i.getRange(),o=r[1]-r[0],a=.5*(r[0]+r[1]);t=c.scale[e]/o,n=(c.offset[e]-a)/o+.5}o.setUniformf(`pwfshift${e}`,n),o.setUniformf(`pwfscale${e}`,t)}const d=t.pwfTexture.getTextureUnit();o.setUniformi(&quot;pwfTexture1&quot;,d)},e.updateShaders=(n,r,o)=>{if(e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};e.buildShaders(a,r,o);const i=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==n.getProgram()&&(n.setProgram(i),n.getVAO().releaseGraphicsResources()),n.getShaderSourceTime().modified()}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(n.getProgram());n.getVAO().bind(),e.setMapperShaderParameters(n,r,o),e.setCameraShaderParameters(n,r,o),e.setPropertyShaderParameters(n,r,o)},e.delete=Wt.chain((()=>{t._openGLRenderWindow&&n(t._openGLRenderWindow)}),e.delete)}(e,t)}),&quot;vtkOpenGLImageCPRMapper&quot;);Jt(&quot;vtkImageCPRMapper&quot;,jf);const Kf={context:null,keyMatrixTime:null,keyMatrices:null};const $f=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Kf,n),qt.extend(e,t,n),t.keyMatrixTime={},ht(t.keyMatrixTime,{mtime:0}),t.keyMatrices={mcwc:m(new Float64Array(16))},Ct(e,t,[&quot;context&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLImageSlice&quot;),e.buildPass=n=>{if(t.renderable&&t.renderable.getVisibility()&&n){if(!t.renderable)return;t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t.context=t._openGLRenderWindow.getContext(),e.prepareNodes(),e.addMissingNode(t.renderable.getMapper()),e.removeUnusedNodes()}},e.traverseZBufferPass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.children.forEach((e=>{e.traverse(n)})),e.apply(n,!1))},e.traverseOpaqueZBufferPass=t=>e.traverseOpaquePass(t),e.traverseOpaquePass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&t.renderable.getIsOpaque()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.children.forEach((e=>{e.traverse(n)})),e.apply(n,!1))},e.traverseTranslucentPass=n=>{!t.renderable||!t.renderable.getNestedVisibility()||t.renderable.getIsOpaque()||t._openGLRenderer.getSelector()&&!t.renderable.getNestedPickable()||(e.apply(n,!0),t.children.forEach((e=>{e.traverse(n)})),e.apply(n,!1))},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;t.renderable.getIsOpaque()?n.incrementOpaqueActorCount():n.incrementTranslucentActorCount()}},e.zBufferPass=(t,n)=>e.opaquePass(t,n),e.opaqueZBufferPass=(t,n)=>e.opaquePass(t,n),e.opaquePass=(e,n)=>{e&&t.context.depthMask(!0)},e.translucentPass=(e,n)=>{t.context.depthMask(!e)},e.getKeyMatrices=()=>(t.renderable.getMTime()>t.keyMatrixTime.getMTime()&&(p(t.keyMatrices.mcwc,t.renderable.getMatrix()),h(t.keyMatrices.mcwc,t.keyMatrices.mcwc),t.keyMatrixTime.modified()),t.keyMatrices)}(e,t)}),&quot;vtkOpenGLImageSlice&quot;);Jt(&quot;vtkImageSlice&quot;,$f);const qf={};const Xf=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,qf,n),qt.extend(e,t,n),t.keyMatrixTime={},ht(t.keyMatrixTime,{mtime:0}),t.normalMatrix=new Float64Array(9),t.MCWCMatrix=new Float64Array(16),Ct(e,t,[&quot;context&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLVolume&quot;),e.buildPass=n=>{t.renderable&&t.renderable.getVisibility()&&n&&(t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t.context=t._openGLRenderWindow.getContext(),e.prepareNodes(),e.addMissingNode(t.renderable.getMapper()),e.removeUnusedNodes())},e.queryPass=(e,n)=>{if(e){if(!t.renderable||!t.renderable.getVisibility())return;n.incrementVolumeCount()}},e.traverseVolumePass=n=>{t.renderable&&t.renderable.getNestedVisibility()&&(!t._openGLRenderer.getSelector()||t.renderable.getNestedPickable())&&(e.apply(n,!0),t.children[0].traverse(n),e.apply(n,!1))},e.volumePass=e=>{t.renderable&&t.renderable.getVisibility()&&t.context.depthMask(!e)},e.getKeyMatrices=()=>(t.renderable.getMTime()>t.keyMatrixTime.getMTime()&&(t.renderable.computeMatrix(),p(t.MCWCMatrix,t.renderable.getMatrix()),h(t.MCWCMatrix,t.MCWCMatrix),t.renderable.getIsIdentity()?fe(t.normalMatrix):(le(t.normalMatrix,t.MCWCMatrix),me(t.normalMatrix,t.normalMatrix),ge(t.normalMatrix,t.normalMatrix)),t.keyMatrixTime.modified()),{mcwc:t.MCWCMatrix,normalMatrix:t.normalMatrix})}(e,t)}),&quot;vtkOpenGLVolume&quot;);Jt(&quot;vtkVolume&quot;,Xf);const Yf={NEAREST:0,LINEAR:1,FAST_LINEAR:2},Zf={FRACTIONAL:0,PROPORTIONAL:1},Qf={DEFAULT:0,ADDITIVE:1,COLORIZE:2,CUSTOM:3};var Jf={InterpolationType:Yf,OpacityMode:Zf,ColorMixPreset:Qf,FilterMode:{OFF:0,NORMALIZED:1,RAW:2}};const eg={COMPOSITE_BLEND:0,MAXIMUM_INTENSITY_BLEND:1,MINIMUM_INTENSITY_BLEND:2,AVERAGE_INTENSITY_BLEND:3,ADDITIVE_INTENSITY_BLEND:4,RADON_TRANSFORM_BLEND:5,LABELMAP_EDGE_PROJECTION_BLEND:6};var tg={BlendMode:eg};const{vtkWarningMacro:ng,vtkErrorMacro:rg}=Ht,og={idxToView:m(new Float64Array(16)),vecISToVCMatrix:fe(new Float64Array(9)),modelToView:m(new Float64Array(16)),projectionToView:m(new Float64Array(16)),projectionToWorld:m(new Float64Array(16))};const ag={context:null,VBOBuildTime:null,scalarTextures:[],_scalarTexturesCore:[],opacityTexture:null,_opacityTextureCore:null,colorTexture:null,_colorTextureCore:null,labelOutlineThicknessTexture:null,_labelOutlineThicknessTextureCore:null,jitterTexture:null,tris:null,framebuffer:null,copyShader:null,copyVAO:null,lastXYF:1,targetXYF:1,zBufferTexture:null,lastZBufferTexture:null,fullViewportTime:1,idxToView:null,vecISToVCMatrix:null,modelToView:null,projectionToView:null,avgWindowArea:0,avgFrameTime:0};const ig=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ag,n),qt.extend(e,t,n),Vd(e,t,n),t.VBOBuildTime={},ht(t.VBOBuildTime,{mtime:0}),t.tris=ld.newInstance(),t.jitterTexture=Pd.newInstance(),t.jitterTexture.setWrapS(cd.REPEAT),t.jitterTexture.setWrapT(cd.REPEAT),t.framebuffer=Sp.newInstance(),Ct(e,t,[&quot;context&quot;]),function(e,t){function n(e){return e.getUseLabelOutline()||t.renderable.getBlendMode()===eg.LABELMAP_EDGE_PROJECTION_BLEND}t.classHierarchy.push(&quot;vtkOpenGLVolumeMapper&quot;);const r=new Map;function o(t,n,o){n!==o&&(function(t,n){if(!n)return;const o=(r.get(n)??0)-1;o<=0?(t.unregisterGraphicsResourceUser(n,e),r.delete(n)):r.set(n,o)}(t,n),function(t,n){if(!n)return;const o=r.get(n)??0,a=o+1;r.set(n,a),o<=0&&t.registerGraphicsResourceUser(n,e)}(t,o))}function a(t){[...r.keys()].forEach((n=>t.unregisterGraphicsResourceUser(n,e)))}e.buildPass=()=>{t.zBufferTexture=null},e.zBufferPass=(e,n)=>{if(e){const e=n.getZBufferTexture();e!==t.zBufferTexture&&(t.zBufferTexture=e)}},e.opaqueZBufferPass=(t,n)=>e.zBufferPass(t,n),e.volumePass=(n,r)=>{if(n){const n=t._openGLRenderWindow;t._openGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),n&&!n.isDeleted()&&n!==t._openGLRenderWindow&&a(n),t.context=t._openGLRenderWindow.getContext(),t.tris.setOpenGLRenderWindow(t._openGLRenderWindow),t.jitterTexture.setOpenGLRenderWindow(t._openGLRenderWindow),t.framebuffer.setOpenGLRenderWindow(t._openGLRenderWindow),t.openGLVolume=e.getFirstAncestorOfType(&quot;vtkOpenGLVolume&quot;);const r=t.openGLVolume.getRenderable();t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;);const o=t._openGLRenderer.getRenderable();t.openGLCamera=t._openGLRenderer.getViewNodeFor(o.getActiveCamera()),e.renderPiece(o,r)}},e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkVolumeVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\nattribute vec4 vertexDC;\\n\\nvarying vec3 vertexVCVSOutput;\\nuniform mat4 PCVCMatrix;\\n\\nuniform float dcxmin;\\nuniform float dcxmax;\\nuniform float dcymin;\\nuniform float dcymax;\\n\\nvoid main()\\n{\\n  // dcsmall is the device coords reduced to the\\n  // x y area covered by the volume\\n  vec4 dcsmall = vec4(\\n    dcxmin + 0.5 * (vertexDC.x + 1.0) * (dcxmax - dcxmin),\\n    dcymin + 0.5 * (vertexDC.y + 1.0) * (dcymax - dcymin),\\n    vertexDC.z,\\n    vertexDC.w);\\n  vec4 vcpos = PCVCMatrix * dcsmall;\\n  vertexVCVSOutput = vcpos.xyz/vcpos.w;\\n  gl_Position = dcsmall;\\n}\\n&quot;,e.Fragment=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkVolumeFS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// Template for the volume mappers fragment shader\\n\\nconst float infinity = 3.402823466e38;\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nin vec3 vertexVCVSOutput;\\n\\n// From Sources\\\\Rendering\\\\Core\\\\VolumeProperty\\\\Constants.js\\n#define COMPOSITE_BLEND 0\\n#define MAXIMUM_INTENSITY_BLEND 1\\n#define MINIMUM_INTENSITY_BLEND 2\\n#define AVERAGE_INTENSITY_BLEND 3\\n#define ADDITIVE_INTENSITY_BLEND 4\\n#define RADON_TRANSFORM_BLEND 5\\n#define LABELMAP_EDGE_PROJECTION_BLEND 6\\n\\n#define vtkNumberOfLights //VTK::NumberOfLights\\n#define vtkMaxLaoKernelSize //VTK::MaxLaoKernelSize\\n#define vtkNumberOfComponents //VTK::NumberOfComponents\\n#define vtkBlendMode //VTK::BlendMode\\n#define vtkMaximumNumberOfSamples //VTK::MaximumNumberOfSamples\\n\\n//VTK::EnabledColorFunctions\\n\\n//VTK::EnabledLightings\\n\\n//VTK::EnabledMultiTexturePerVolume\\n\\n//VTK::EnabledGradientOpacity\\n\\n//VTK::EnabledIndependentComponents\\n\\n//VTK::vtkProportionalComponents\\n\\n//VTK::vtkForceNearestComponents\\n\\nuniform int twoSidedLighting;\\n\\n#if vtkMaxLaoKernelSize > 0\\n  vec2 kernelSample[vtkMaxLaoKernelSize];\\n#endif\\n\\n// Textures\\n#ifdef EnabledMultiTexturePerVolume\\n  #define vtkNumberOfVolumeTextures vtkNumberOfComponents\\n#else\\n  #define vtkNumberOfVolumeTextures 1\\n#endif\\nuniform highp sampler3D volumeTexture[vtkNumberOfVolumeTextures];\\nuniform sampler2D colorTexture;\\nuniform sampler2D opacityTexture;\\nuniform sampler2D jtexture;\\nuniform sampler2D labelOutlineThicknessTexture;\\n\\nstruct Volume {\\n  // ---- Volume geometry settings ----\\n\\n  vec3 originVC;          // in VC\\n  vec3 spacing;           // in VC per IC\\n  vec3 inverseSpacing;    // 1/spacing\\n  ivec3 dimensions;       // in IC\\n  vec3 inverseDimensions; // 1/vec3(dimensions)\\n  mat3 vecISToVCMatrix;   // convert from IS to VC without translation\\n  mat3 vecVCToISMatrix;   // convert from VC to IS without translation\\n  mat4 PCWCMatrix;\\n  mat4 worldToIndex;\\n  float diagonalLength; // in VC, this is: length(size)\\n\\n  // ---- Texture settings ----\\n\\n  // Texture shift and scale\\n  vec4 colorTextureScale;\\n  vec4 colorTextureShift;\\n  vec4 opacityTextureScale;\\n  vec4 opacityTextureShift;\\n\\n  // The heights defined below are the locations for the up to four components\\n  // of the transfer functions. The transfer functions have a height of (2 *\\n  // numberOfComponents) pixels so the values are computed to hit the middle of\\n  // the two rows for that component\\n  vec4 transferFunctionsSampleHeight;\\n\\n  // ---- Mode specific settings ----\\n\\n  // Independent component default preset settings per component\\n  vec4 independentComponentMix;\\n\\n  // Additive / average blending mode settings\\n  vec4 ipScalarRangeMin;\\n  vec4 ipScalarRangeMax;\\n\\n  // ---- Rendering settings ----\\n\\n  // Lighting\\n  float ambient;\\n  float diffuse;\\n  float specular;\\n  float specularPower;\\n  int computeNormalFromOpacity;\\n\\n  // Gradient opacity\\n  vec4 gradientOpacityScale;\\n  vec4 gradientOpacityShift;\\n  vec4 gradientOpacityMin;\\n  vec4 gradientOpacityMax;\\n\\n  // Volume shadow\\n  float volumetricScatteringBlending;\\n  float globalIlluminationReach;\\n  float anisotropy;\\n  float anisotropySquared;\\n\\n  // LAO\\n  int kernelSize;\\n  int kernelRadius;\\n\\n  // Label outline\\n  float outlineOpacity;\\n};\\nuniform Volume volume;\\n\\nstruct Light {\\n  vec3 color;\\n  vec3 positionVC;\\n  vec3 directionVC; // normalized\\n  vec3 halfAngleVC;\\n  vec3 attenuation;\\n  float exponent;\\n  float coneAngle;\\n  int isPositional;\\n};\\n#if vtkNumberOfLights > 0\\n  uniform Light lights[vtkNumberOfLights];\\n#endif\\n\\nuniform float vpWidth;\\nuniform float vpHeight;\\nuniform float vpOffsetX;\\nuniform float vpOffsetY;\\n\\n// Bitmasks for label outline\\nconst int MAX_SEGMENT_INDEX = 256; // Define as per expected maximum\\n#define MAX_SEGMENTS 256\\n#define UINT_SIZE 32\\n// We add UINT_SIZE - 1, as we want the ceil of the division instead of the\\n// floor\\n#define BITMASK_SIZE ((MAX_SEGMENTS + UINT_SIZE - 1) / UINT_SIZE)\\nuint labelOutlineBitmasks[BITMASK_SIZE];\\n\\n// Set the corresponding bit in the bitmask\\nvoid setLabelOutlineBit(int segmentIndex) {\\n  int arrayIndex = segmentIndex / UINT_SIZE;\\n  int bitIndex = segmentIndex % UINT_SIZE;\\n  labelOutlineBitmasks[arrayIndex] |= 1u << bitIndex;\\n}\\n\\n// Check if a bit is set in the bitmask\\nbool isLabelOutlineBitSet(int segmentIndex) {\\n  int arrayIndex = segmentIndex / UINT_SIZE;\\n  int bitIndex = segmentIndex % UINT_SIZE;\\n  return ((labelOutlineBitmasks[arrayIndex] & (1u << bitIndex)) != 0u);\\n}\\n\\n// if you want to see the raw tiled\\n// data in webgl1 uncomment the following line\\n// #define debugtile\\n\\n// camera values\\nuniform float camThick;\\nuniform float camNear;\\nuniform float camFar;\\nuniform int cameraParallel;\\n\\n//VTK::ClipPlane::Dec\\n\\n// A random number between 0 and 1 that only depends on the fragment\\n// It uses the jtexture, so this random seed repeats by blocks of 32 fragments\\n// in screen space\\nfloat fragmentSeed;\\n\\n// sample texture is global\\nuniform float sampleDistance;\\nuniform float volumeShadowSampleDistance;\\n\\n// declaration for intermixed geometry\\n//VTK::ZBuffer::Dec\\n\\n//=======================================================================\\n// global and custom variables (a temporary section before photorealistics\\n// rendering module is complete)\\nvec3 rayDirVC;\\n\\n#define INV4PI 0.0796\\n#define EPSILON 0.001\\n#define PI 3.1415\\n#define PI2 9.8696\\n\\nvec4 rawSampleTexture(vec3 pos) {\\n  #ifdef EnabledMultiTexturePerVolume\\n    vec4 rawSample;\\n    rawSample[0] = texture(volumeTexture[0], pos)[0];\\n  #if vtkNumberOfComponents > 1\\n    rawSample[1] = texture(volumeTexture[1], pos)[0];\\n  #endif\\n  #if vtkNumberOfComponents > 2\\n    rawSample[2] = texture(volumeTexture[2], pos)[0];\\n  #endif\\n  #if vtkNumberOfComponents > 3\\n    rawSample[3] = texture(volumeTexture[3], pos)[0];\\n  #endif\\n    return rawSample;\\n  #else\\n    return texture(volumeTexture[0], pos);\\n  #endif\\n}\\n\\nvec4 rawFetchTexture(ivec3 pos) {\\n  #ifdef EnabledMultiTexturePerVolume\\n    vec4 rawSample;\\n    #if vtkNumberOfComponents > 0\\n      rawSample[0] = texelFetch(volumeTexture[0], pos, 0)[0];\\n    #endif\\n    #if vtkNumberOfComponents > 1\\n      rawSample[1] = texelFetch(volumeTexture[1], pos, 0)[0];\\n    #endif\\n    #if vtkNumberOfComponents > 2\\n      rawSample[2] = texelFetch(volumeTexture[2], pos, 0)[0];\\n    #endif\\n    #if vtkNumberOfComponents > 3\\n      rawSample[3] = texelFetch(volumeTexture[3], pos, 0)[0];\\n    #endif\\n    return rawSample;\\n  #else\\n    return texelFetch(volumeTexture[0], pos, 0);\\n  #endif\\n}\\n\\nvec4 getTextureValue(vec3 pos) {\\n  vec4 tmp = rawSampleTexture(pos);\\n\\n  // Force nearest\\n  #if defined(vtkComponent0ForceNearest) || \\\\\\n      defined(vtkComponent1ForceNearest) || \\\\\\n      defined(vtkComponent2ForceNearest) || \\\\\\n      defined(vtkComponent3ForceNearest)\\n    vec3 nearestPos = (floor(pos * vec3(volume.dimensions)) + 0.5) *\\n                      volume.inverseDimensions;\\n    vec4 nearestValue = rawSampleTexture(nearestPos);\\n    #ifdef vtkComponent0ForceNearest\\n      tmp[0] = nearestValue[0];\\n    #endif\\n    #ifdef vtkComponent1ForceNearest\\n      tmp[1] = nearestValue[1];\\n    #endif\\n    #ifdef vtkComponent2ForceNearest\\n      tmp[2] = nearestValue[2];\\n    #endif\\n    #ifdef vtkComponent3ForceNearest\\n      tmp[3] = nearestValue[3];\\n    #endif\\n  #endif\\n\\n  // Set alpha when using dependent components\\n  #ifndef EnabledIndependentComponents\\n    #if vtkNumberOfComponents == 1\\n      tmp.a = tmp.r;\\n    #endif\\n    #if vtkNumberOfComponents == 2\\n      tmp.a = tmp.g;\\n    #endif\\n    #if vtkNumberOfComponents == 3\\n      tmp.a = length(tmp.rgb);\\n    #endif\\n  #endif\\n\\n  return tmp;\\n}\\n\\n// `height` is usually `volume.transferFunctionsSampleHeight[component]`\\n// when using independent component and `0.5` otherwise. Don't move the if\\n// statement in these function, as the callers usually already knows if it is\\n// using independent component or not\\nfloat getOpacityFromTexture(float scalar, int component, float height) {\\n  float scaledScalar = scalar * volume.opacityTextureScale[component] +\\n                       volume.opacityTextureShift[component];\\n  return texture2D(opacityTexture, vec2(scaledScalar, height)).r;\\n}\\nvec3 getColorFromTexture(float scalar, int component, float height) {\\n  float scaledScalar = scalar * volume.colorTextureScale[component] +\\n                       volume.colorTextureShift[component];\\n  return texture2D(colorTexture, vec2(scaledScalar, height)).rgb;\\n}\\n\\n//=======================================================================\\n// transformation between VC and IS space\\n\\n// convert vector position from idx to vc\\nvec3 posIStoVC(vec3 posIS) {\\n  return volume.vecISToVCMatrix * posIS + volume.originVC;\\n}\\n\\n// convert vector position from vc to idx\\nvec3 posVCtoIS(vec3 posVC) {\\n  return volume.vecVCToISMatrix * (posVC - volume.originVC);\\n}\\n\\n// Rotate vector to view coordinate\\nvec3 vecISToVC(vec3 dirIS) {\\n  return volume.vecISToVCMatrix * dirIS;\\n}\\n\\n// Rotate vector to idx coordinate\\nvec3 vecVCToIS(vec3 dirVC) {\\n  return volume.vecVCToISMatrix * dirVC;\\n}\\n\\n//=======================================================================\\n// Given a normal compute the gradient opacity factors\\nfloat computeGradientOpacityFactor(float normalMag, int component) {\\n  float goscale = volume.gradientOpacityScale[component];\\n  float goshift = volume.gradientOpacityShift[component];\\n  float gomin = volume.gradientOpacityMin[component];\\n  float gomax = volume.gradientOpacityMax[component];\\n  return clamp(normalMag * goscale + goshift, gomin, gomax);\\n}\\n\\n#ifdef vtkClippingPlanesOn\\n  bool isPointClipped(vec3 posVC) {\\n    for (int i = 0; i < clip_numPlanes; ++i) {\\n      if (dot(vec3(vClipPlaneOrigins[i] - posVC), vClipPlaneNormals[i]) > 0.0) {\\n        return true;\\n      }\\n    }\\n    return false;\\n  }\\n#endif\\n\\n//=======================================================================\\n// compute the normal and gradient magnitude for a position, uses forward\\n// difference\\n\\n// The output normal is in VC\\nvec4 computeDensityNormal(vec3 opacityUCoords[2], float opacityTextureHeight,\\n                          float gradientOpacity, int component) {\\n  // Pass the scalars through the opacity functions\\n  vec4 opacityG;\\n  opacityG.x += getOpacityFromTexture(opacityUCoords[0].x, component,\\n                                      opacityTextureHeight);\\n  opacityG.y += getOpacityFromTexture(opacityUCoords[0].y, component,\\n                                      opacityTextureHeight);\\n  opacityG.z += getOpacityFromTexture(opacityUCoords[0].z, component,\\n                                      opacityTextureHeight);\\n  opacityG.x -= getOpacityFromTexture(opacityUCoords[1].x, component,\\n                                      opacityTextureHeight);\\n  opacityG.y -= getOpacityFromTexture(opacityUCoords[1].y, component,\\n                                      opacityTextureHeight);\\n  opacityG.z -= getOpacityFromTexture(opacityUCoords[1].z, component,\\n                                      opacityTextureHeight);\\n\\n  // Divide by spacing and convert to VC\\n  opacityG.xyz *= gradientOpacity * volume.inverseSpacing;\\n  opacityG.w = length(opacityG.xyz);\\n  if (opacityG.w == 0.0) {\\n    return vec4(0.0);\\n  }\\n\\n  // Normalize\\n  opacityG.xyz = normalize(vecISToVC(opacityG.xyz));\\n\\n  return opacityG;\\n}\\n\\n// The output normal is in VC\\nvec4 computeNormalForDensity(vec3 posIS, out vec3 scalarInterp[2],\\n                             const int opacityComponent) {\\n  vec3 offsetedPosIS;\\n  for (int axis = 0; axis < 3; ++axis) {\\n    // Positive direction\\n    offsetedPosIS = posIS;\\n    offsetedPosIS[axis] += volume.inverseDimensions[axis];\\n    scalarInterp[0][axis] =\\n        getTextureValue(offsetedPosIS)[opacityComponent];\\n    #ifdef vtkClippingPlanesOn\\n      if (isPointClipped(posIStoVC(offsetedPosIS))) {\\n        scalarInterp[0][axis] = 0.0;\\n      }\\n    #endif\\n\\n    // Negative direction\\n    offsetedPosIS = posIS;\\n    offsetedPosIS[axis] -= volume.inverseDimensions[axis];\\n    scalarInterp[1][axis] =\\n        getTextureValue(offsetedPosIS)[opacityComponent];\\n    #ifdef vtkClippingPlanesOn\\n      if (isPointClipped(posIStoVC(offsetedPosIS))) {\\n        scalarInterp[1][axis] = 0.0;\\n      }\\n    #endif\\n  }\\n\\n  vec4 result;\\n  result.xyz = (scalarInterp[0] - scalarInterp[1]) * volume.inverseSpacing;\\n  result.w = length(result.xyz);\\n  if (result.w == 0.0) {\\n    return vec4(0.0);\\n  }\\n  result.xyz = normalize(vecISToVC(result.xyz));\\n  return result;\\n}\\n\\nvec4 fragCoordToPCPos(vec4 fragCoord) {\\n  return vec4((fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,\\n              (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,\\n              (fragCoord.z - 0.5) * 2.0, 1.0);\\n}\\n\\nvec4 pcPosToWorldCoord(vec4 pcPos) {\\n  return volume.PCWCMatrix * pcPos;\\n}\\n\\nvec3 fragCoordToIndexSpace(vec4 fragCoord) {\\n  vec4 pcPos = fragCoordToPCPos(fragCoord);\\n  vec4 worldCoord = pcPosToWorldCoord(pcPos);\\n  vec4 vertex = (worldCoord / worldCoord.w);\\n\\n  vec3 index = (volume.worldToIndex * vertex).xyz;\\n\\n  // half voxel fix for labelmapOutline\\n  return (index + vec3(0.5)) * volume.inverseDimensions;\\n}\\n\\nvec3 fragCoordToWorld(vec4 fragCoord) {\\n  vec4 pcPos = fragCoordToPCPos(fragCoord);\\n  vec4 worldCoord = pcPosToWorldCoord(pcPos);\\n  return worldCoord.xyz;\\n}\\n\\n//=======================================================================\\n// Compute the normals and gradient magnitudes for a position for independent\\n// components The output normals are in VC\\nmat4 computeMat4Normal(vec3 posIS, vec4 tValue) {\\n  vec3 xvec = vec3(volume.inverseDimensions.x, 0.0, 0.0);\\n  vec3 yvec = vec3(0.0, volume.inverseDimensions.y, 0.0);\\n  vec3 zvec = vec3(0.0, 0.0, volume.inverseDimensions.z);\\n\\n  vec4 distX = getTextureValue(posIS + xvec) - getTextureValue(posIS - xvec);\\n  vec4 distY = getTextureValue(posIS + yvec) - getTextureValue(posIS - yvec);\\n  vec4 distZ = getTextureValue(posIS + zvec) - getTextureValue(posIS - zvec);\\n\\n  // divide by spacing\\n  distX *= 0.5 * volume.inverseSpacing.x;\\n  distY *= 0.5 * volume.inverseSpacing.y;\\n  distZ *= 0.5 * volume.inverseSpacing.z;\\n\\n  mat4 result;\\n\\n  // optionally compute the 1st component\\n  #if vtkNumberOfComponents > 0 && !defined(vtkComponent0Proportional)\\n    {\\n      const int component = 0;\\n      vec3 normal = vec3(distX[component], distY[component], distZ[component]);\\n      float normalLength = length(normal);\\n      if (normalLength > 0.0) {\\n        normal = normalize(vecISToVC(normal));\\n      }\\n      result[component] = vec4(normal, normalLength);\\n    }\\n  #endif\\n\\n  // optionally compute the 2nd component\\n  #if vtkNumberOfComponents > 1 && !defined(vtkComponent1Proportional)\\n    {\\n      const int component = 1;\\n      vec3 normal = vec3(distX[component], distY[component], distZ[component]);\\n      float normalLength = length(normal);\\n      if (normalLength > 0.0) {\\n        normal = normalize(vecISToVC(normal));\\n      }\\n      result[component] = vec4(normal, normalLength);\\n    }\\n  #endif\\n\\n  // optionally compute the 3rd component\\n  #if vtkNumberOfComponents > 2 && !defined(vtkComponent2Proportional)\\n    {\\n      const int component = 2;\\n      vec3 normal = vec3(distX[component], distY[component], distZ[component]);\\n      float normalLength = length(normal);\\n      if (normalLength > 0.0) {\\n        normal = normalize(vecISToVC(normal));\\n      }\\n      result[component] = vec4(normal, normalLength);\\n    }\\n  #endif\\n\\n  // optionally compute the 4th component\\n  #if vtkNumberOfComponents > 3 && !defined(vtkComponent3Proportional)\\n    {\\n      const int component = 3;\\n      vec3 normal = vec3(distX[component], distY[component], distZ[component]);\\n      float normalLength = length(normal);\\n      if (normalLength > 0.0) {\\n        normal = normalize(vecISToVC(normal));\\n      }\\n      result[component] = vec4(normal, normalLength);\\n    }\\n  #endif\\n\\n  return result;\\n}\\n\\n//=======================================================================\\n// global shadow - secondary ray\\n\\n// henyey greenstein phase function\\nfloat phaseFunction(float cos_angle) {\\n  // divide by 2.0 instead of 4pi to increase intensity\\n  float anisotropy = volume.anisotropy;\\n  if (abs(anisotropy) <= EPSILON) {\\n    // isotropic scatter returns 0.5 instead of 1/4pi to increase intensity\\n    return 0.5;\\n  }\\n  float anisotropy2 = volume.anisotropySquared;\\n  return ((1.0 - anisotropy2) /\\n          pow(1.0 + anisotropy2 - 2.0 * anisotropy * cos_angle, 1.5)) /\\n         2.0;\\n}\\n\\n// Compute the two intersection distances of the ray with the volume in VC\\n// The entry point is `rayOriginVC + distanceMin * rayDirVC` and the exit point\\n// is `rayOriginVC + distanceMax * rayDirVC` If distanceMin < distanceMax, the\\n// volume is not intersected The ray origin is inside the box when distanceMin <\\n// 0.0 < distanceMax\\nvec2 rayIntersectVolumeDistances(vec3 rayOriginVC, vec3 rayDirVC) {\\n  // Compute origin and direction in IS\\n  vec3 rayOriginIS = posVCtoIS(rayOriginVC);\\n  vec3 rayDirIS = vecVCToIS(rayDirVC);\\n  // Don't check for infinity as the min/max combination afterward will always\\n  // find an intersection before infinity\\n  vec3 invDir = 1.0 / rayDirIS;\\n\\n  // We have: bound = origin + t * dir\\n  // So: t = (1/dir) * (bound - origin)\\n  vec3 distancesTo0 = invDir * (vec3(0.0) - rayOriginIS);\\n  vec3 distancesTo1 = invDir * (vec3(1.0) - rayOriginIS);\\n  // Min and max distances to plane intersection per plane\\n  vec3 dMinPerAxis = min(distancesTo0, distancesTo1);\\n  vec3 dMaxPerAxis = max(distancesTo0, distancesTo1);\\n  // Overall first and last intersection\\n  float distanceMin = max(dMinPerAxis.x, max(dMinPerAxis.y, dMinPerAxis.z));\\n  float distanceMax = min(dMaxPerAxis.x, min(dMaxPerAxis.y, dMaxPerAxis.z));\\n  return vec2(distanceMin, distanceMax);\\n}\\n\\n//=======================================================================\\n// local ambient occlusion\\n#if vtkMaxLaoKernelSize > 0\\n\\n  // Return a random point on the unit sphere\\n  vec3 sampleDirectionUniform(int rayIndex) {\\n    // Each ray of each fragment should be different, two sources of randomness\\n    // are used. Only depends on ray index\\n    vec2 rayRandomness = kernelSample[rayIndex];\\n    // Only depends on fragment\\n    float fragmentRandomness = fragmentSeed;\\n    // Merge both source of randomness in a single uniform random variable using\\n    // the formula (x+y < 1 ? x+y : x+y-1). The simpler formula (x+y)/2 doesn't\\n    // result in a uniform distribution\\n    vec2 mergedRandom = rayRandomness + vec2(fragmentRandomness);\\n    mergedRandom -= vec2(greaterThanEqual(mergedRandom, vec2(1.0)));\\n\\n    // Insipred by:\\n    // https://karthikkaranth.me/blog/generating-random-points-in-a-sphere/#better-choice-of-spherical-coordinates\\n    float u = mergedRandom[0];\\n    float v = mergedRandom[1];\\n    float theta = u * 2.0 * PI;\\n    float phi = acos(2.0 * v - 1.0);\\n    float sinTheta = sin(theta);\\n    float cosTheta = cos(theta);\\n    float sinPhi = sin(phi);\\n    float cosPhi = cos(phi);\\n    return vec3(sinPhi * cosTheta, sinPhi * sinTheta, cosPhi);\\n  }\\n\\n  float computeLAO(vec3 posVC, vec4 normalVC, float originalOpacity) {\\n    // apply LAO only at selected locations, otherwise return full brightness\\n    if (normalVC.w <= 0.0 || originalOpacity <= 0.05) {\\n      return 1.0;\\n    }\\n\\n    #ifdef EnabledGradientOpacity\\n      float gradientOpacityFactor = computeGradientOpacityFactor(normalVC.w, 0);\\n    #endif\\n\\n    float visibilitySum = 0.0;\\n    float weightSum = 0.0;\\n    for (int i = 0; i < volume.kernelSize; i++) {\\n      // Only sample on an hemisphere around the normalVC.xyz axis, so\\n      // normalDotRay should be negative\\n      vec3 rayDirectionVC = sampleDirectionUniform(i);\\n      float normalDotRay = dot(normalVC.xyz, rayDirectionVC);\\n      if (normalDotRay > 0.0) {\\n        // Flip rayDirectionVC when it is in the wrong hemisphere\\n        rayDirectionVC = -rayDirectionVC;\\n        normalDotRay = -normalDotRay;\\n      }\\n\\n      vec3 currPosIS = posVCtoIS(posVC);\\n      float visibility = 1.0;\\n      vec3 randomDirStepIS = vecVCToIS(rayDirectionVC * sampleDistance);\\n      for (int j = 0; j < volume.kernelRadius; j++) {\\n        currPosIS += randomDirStepIS;\\n        // If out of the volume, we are done\\n        if (any(lessThan(currPosIS, vec3(0.0))) ||\\n            any(greaterThan(currPosIS, vec3(1.0)))) {\\n          break;\\n        }\\n        float opacity = getOpacityFromTexture(getTextureValue(currPosIS).r, 0, 0.5);\\n        #ifdef EnabledGradientOpacity\\n          opacity *= gradientOpacityFactor;\\n        #endif\\n        visibility *= 1.0 - opacity;\\n        // If visibility is less than EPSILON, consider it to be 0\\n        if (visibility < EPSILON) {\\n          visibility = 0.0;\\n          break;\\n        }\\n      }\\n      float rayWeight = -normalDotRay;\\n      visibilitySum += visibility * rayWeight;\\n      weightSum += rayWeight;\\n    }\\n\\n    // If no sample, LAO factor is one\\n    if (weightSum == 0.0) {\\n      return 1.0;\\n    }\\n\\n    // LAO factor is the average visibility:\\n    // - visibility low => ambient low\\n    // - visibility high => ambient high\\n    float lao = visibilitySum / weightSum;\\n\\n    // Reduce variance by clamping\\n    return clamp(lao, 0.3, 1.0);\\n  }\\n#endif\\n\\n//=======================================================================\\n// Volume shadows\\n#if vtkNumberOfLights > 0\\n\\n  // Non-memoised version\\n  float computeVolumeShadowWithoutCache(vec3 posVC, vec3 lightDirNormVC) {\\n    // modify sample distance with a random number between 1.5 and 3.0\\n    float rayStepLength =\\n        volumeShadowSampleDistance * mix(1.5, 3.0, fragmentSeed);\\n\\n    // in case the first sample near surface has a very tiled light ray, we need\\n    // to offset start position\\n    vec3 initialPosVC = posVC + rayStepLength * lightDirNormVC;\\n\\n    #ifdef vtkClippingPlanesOn\\n      float clippingPlanesMaxDistance = infinity;\\n      for (int i = 0; i < clip_numPlanes; ++i) {\\n        // Find distance of intersection with the plane\\n        // Points are clipped when:\\n        // dot(planeOrigin - (rayOrigin + distance * rayDirection), planeNormal) > 0\\n        // This is equivalent to:\\n        // dot(planeOrigin - rayOrigin, planeNormal) - distance * dot(rayDirection,\\n        // planeNormal) > 0.0\\n        // We precompute the dot products, so we clip ray points when:\\n        // dotOrigin - distance * dotDirection > 0.0\\n        float dotOrigin =\\n            dot(vClipPlaneOrigins[i] - initialPosVC, vClipPlaneNormals[i]);\\n        if (dotOrigin > 0.0) {\\n          // The initialPosVC is clipped by this plane\\n          return 1.0;\\n        }\\n        float dotDirection = dot(lightDirNormVC, vClipPlaneNormals[i]);\\n        if (dotDirection < 0.0) {\\n          // We only hit the plane if dotDirection is negative, as (distance is\\n          // positive)\\n          float intersectionDistance =\\n              dotOrigin / dotDirection; // negative divided by negative => positive\\n          clippingPlanesMaxDistance =\\n              min(clippingPlanesMaxDistance, intersectionDistance);\\n        }\\n      }\\n    #endif\\n\\n    vec2 intersectionDistances =\\n        rayIntersectVolumeDistances(initialPosVC, lightDirNormVC);\\n\\n    if (intersectionDistances[1] <= intersectionDistances[0] ||\\n        intersectionDistances[1] <= 0.0) {\\n      // Volume not hit or behind the ray\\n      return 1.0;\\n    }\\n\\n    // When globalIlluminationReach is 0, no sample at all\\n    // When globalIlluminationReach is 1, the ray will go through the whole\\n    // volume\\n    float maxTravelDistance = mix(0.0, volume.diagonalLength,\\n                                  volume.globalIlluminationReach);\\n    float startDistance = max(intersectionDistances[0], 0.0);\\n    float endDistance = min(intersectionDistances[1], startDistance + maxTravelDistance);\\n    #ifdef vtkClippingPlanesOn\\n      endDistance = min(endDistance, clippingPlanesMaxDistance);\\n    #endif\\n    if (endDistance - startDistance < 0.0) {\\n      return 1.0;\\n    }\\n\\n    // These two variables are used to compute posIS, without having to call\\n    // VCtoIS at each step\\n    vec3 initialPosIS = posVCtoIS(initialPosVC);\\n    // The light dir is scaled and rotated, but not translated, as it is a\\n    // vector (w = 0)\\n    vec3 scaledLightDirIS = vecVCToIS(lightDirNormVC);\\n\\n    float shadow = 1.0;\\n    for (float currentDistance = startDistance; currentDistance <= endDistance;\\n          currentDistance += rayStepLength) {\\n      vec3 posIS = initialPosIS + currentDistance * scaledLightDirIS;\\n      vec4 scalar = getTextureValue(posIS);\\n      float opacity = getOpacityFromTexture(scalar.r, 0, 0.5);\\n      #if defined(EnabledGradientOpacity) && !defined(EnabledIndependentComponents)\\n        vec3 scalarInterp[2];\\n        vec4 normal = computeNormalForDensity(posIS, scalarInterp, 3);\\n        float opacityFactor = computeGradientOpacityFactor(normal.w, 0);\\n        opacity *= opacityFactor;\\n      #endif\\n      shadow *= 1.0 - opacity;\\n\\n      // Early termination if shadow coeff is near 0.0\\n      if (shadow < EPSILON) {\\n        return 0.0;\\n      }\\n    }\\n    return shadow;\\n  }\\n\\n  // Some cache for volume shadows\\n  struct {\\n    vec3 posVC;\\n    float shadow;\\n  } cachedShadows[vtkNumberOfLights];\\n\\n  // Memoised version\\n  float computeVolumeShadow(vec3 posVC, vec3 lightDirNormVC, int lightIdx) {\\n    if (posVC == cachedShadows[lightIdx].posVC) {\\n      return cachedShadows[lightIdx].shadow;\\n    }\\n    float shadow = computeVolumeShadowWithoutCache(posVC, lightDirNormVC);\\n    cachedShadows[lightIdx].posVC = posVC;\\n    cachedShadows[lightIdx].shadow = shadow;\\n    return shadow;\\n  }\\n\\n#endif\\n\\n//=======================================================================\\n// surface light contribution\\n#if vtkNumberOfLights > 0\\n  vec3 applyLighting(vec3 tColor, vec4 normalVC) {\\n    vec3 diffuse = vec3(0.0, 0.0, 0.0);\\n    vec3 specular = vec3(0.0, 0.0, 0.0);\\n    for (int lightIdx = 0; lightIdx < vtkNumberOfLights; lightIdx++) {\\n      float df = dot(normalVC.xyz, lights[lightIdx].directionVC);\\n      if (df > 0.0) {\\n        diffuse += df * lights[lightIdx].color;\\n        float sf = dot(normalVC.xyz, -lights[lightIdx].halfAngleVC);\\n        if (sf > 0.0) {\\n          specular += pow(sf, volume.specularPower) * lights[lightIdx].color;\\n        }\\n      }\\n    }\\n    return tColor * (diffuse * volume.diffuse + volume.ambient) +\\n          specular * volume.specular;\\n  }\\n\\n  vec3 applySurfaceShadowLighting(vec3 tColor, float alpha, vec3 posVC,\\n                                  vec4 normalVC) {\\n    // everything in VC\\n    vec3 diffuse = vec3(0.0);\\n    vec3 specular = vec3(0.0);\\n    for (int ligthIdx = 0; ligthIdx < vtkNumberOfLights; ligthIdx++) {\\n      vec3 vertLightDirection;\\n      float attenuation;\\n      if (lights[ligthIdx].isPositional == 1) {\\n        vertLightDirection = posVC - lights[ligthIdx].positionVC;\\n        float lightDistance = length(vertLightDirection);\\n        // Normalize with precomputed length\\n        vertLightDirection = vertLightDirection / lightDistance;\\n        // Base attenuation\\n        vec3 attenuationPolynom = lights[ligthIdx].attenuation;\\n        attenuation =\\n            1.0 / (attenuationPolynom[0] +\\n                  lightDistance * (attenuationPolynom[1] +\\n                                    lightDistance * attenuationPolynom[2]));\\n        // Cone attenuation\\n        float coneDot = dot(vertLightDirection, lights[ligthIdx].directionVC);\\n        // Per OpenGL standard cone angle is 90 or less for a spot light\\n        if (lights[ligthIdx].coneAngle <= 90.0) {\\n          if (coneDot >= cos(radians(lights[ligthIdx].coneAngle))) {\\n            // Inside the cone\\n            attenuation *= pow(coneDot, lights[ligthIdx].exponent);\\n          } else {\\n            // Outside the cone\\n            attenuation = 0.0;\\n          }\\n        }\\n      } else {\\n        vertLightDirection = lights[ligthIdx].directionVC;\\n        attenuation = 1.0;\\n      }\\n\\n      float ndotL = dot(normalVC.xyz, vertLightDirection);\\n      if (ndotL < 0.0 && twoSidedLighting == 1) {\\n        ndotL = -ndotL;\\n      }\\n      if (ndotL > 0.0) {\\n        // Diffuse\\n        diffuse += ndotL * attenuation * lights[ligthIdx].color;\\n        // Specular\\n        float vdotR =\\n            dot(-rayDirVC, normalize(vertLightDirection - 2.0 * ndotL * normalVC.xyz));\\n        if (vdotR > 0.0) {\\n          specular += pow(vdotR, volume.specularPower) * attenuation *\\n                      lights[ligthIdx].color;\\n        }\\n      }\\n    }\\n    #if vtkMaxLaoKernelSize > 0\\n      float laoFactor = computeLAO(posVC, normalVC, alpha);\\n    #else\\n      const float laoFactor = 1.0;\\n    #endif\\n    return tColor * (diffuse * volume.diffuse +\\n                    volume.ambient * laoFactor) +\\n          specular * volume.specular;\\n  }\\n\\n  vec3 applyVolumeShadowLighting(vec3 tColor, vec3 posVC) {\\n    // Here we have no effect of cones and no attenuation\\n    vec3 diffuse = vec3(0.0);\\n    for (int lightIdx = 0; lightIdx < vtkNumberOfLights; lightIdx++) {\\n      vec3 lightDirVC = lights[lightIdx].isPositional == 1\\n                            ? normalize(lights[lightIdx].positionVC - posVC)\\n                            : -lights[lightIdx].directionVC;\\n      float shadowCoeff = computeVolumeShadow(posVC, lightDirVC, lightIdx);\\n      float phaseAttenuation = phaseFunction(dot(rayDirVC, lightDirVC));\\n      diffuse += phaseAttenuation * shadowCoeff * lights[lightIdx].color;\\n    }\\n    return tColor * (diffuse * volume.diffuse + volume.ambient);\\n  }\\n#endif\\n\\n// LAO of surface shadows and volume shadows only work with dependent components\\nvec3 applyAllLightning(vec3 tColor, float alpha, vec3 posVC,\\n                       vec4 surfaceNormalVC) {\\n  #if vtkNumberOfLights > 0\\n    // 0 <= volCoeff < EPSILON => only surface shadows\\n    // EPSILON <= volCoeff < 1 - EPSILON => mix of surface and volume shadows\\n    // 1 - EPSILON <= volCoeff => only volume shadows\\n    float volCoeff = volume.volumetricScatteringBlending *\\n                    (1.0 - alpha / 2.0) *\\n                    (1.0 - atan(surfaceNormalVC.w) * INV4PI);\\n\\n    // Compute surface lighting if needed\\n    vec3 surfaceShadedColor = tColor;\\n    #ifdef EnableSurfaceLighting\\n      if (volCoeff < 1.0 - EPSILON) {\\n        surfaceShadedColor =\\n            applySurfaceShadowLighting(tColor, alpha, posVC, surfaceNormalVC);\\n      }\\n    #endif\\n\\n    // Compute volume lighting if needed\\n    vec3 volumeShadedColor = tColor;\\n    #ifdef EnableVolumeLighting\\n      if (volCoeff >= EPSILON) {\\n        volumeShadedColor = applyVolumeShadowLighting(tColor, posVC);\\n      }\\n    #endif\\n\\n    // Return the right mix\\n    if (volCoeff < EPSILON) {\\n      // Surface shadows\\n      return surfaceShadedColor;\\n    }\\n    if (volCoeff >= 1.0 - EPSILON) {\\n      // Volume shadows\\n      return volumeShadedColor;\\n    }\\n    // Mix of surface and volume shadows\\n    return mix(surfaceShadedColor, volumeShadedColor, volCoeff);\\n  #endif\\n  return tColor;\\n}\\n\\nvec4 getColorForLabelOutline() {\\n  vec3 centerPosIS =\\n      fragCoordToIndexSpace(gl_FragCoord); // pos in texture space\\n  vec4 centerValue = getTextureValue(centerPosIS);\\n  bool pixelOnBorder = false;\\n  vec4 tColor = vec4(getColorFromTexture(centerValue.r, 0, 0.5),\\n                     getOpacityFromTexture(centerValue.r, 0, 0.5));\\n\\n  int segmentIndex = int(centerValue.r * 255.0);\\n\\n  // Use texture sampling for outlineThickness\\n  float textureCoordinate = float(segmentIndex - 1) / 1024.0;\\n  float textureValue =\\n      texture2D(labelOutlineThicknessTexture, vec2(textureCoordinate, 0.5)).r;\\n  int actualThickness = int(textureValue * 255.0);\\n\\n  // If it is the background (segment index 0), we should quickly bail out.\\n  // Previously, this was determined by tColor.a, which was incorrect as it\\n  // prevented the outline from appearing when the fill is 0.\\n  if (segmentIndex == 0) {\\n    return vec4(0, 0, 0, 0);\\n  }\\n\\n  // Only perform outline check on fragments rendering voxels that aren't\\n  // invisible. Saves a bunch of needless checks on the background.\\n  // TODO define epsilon when building shader?\\n  for (int i = -actualThickness; i <= actualThickness; i++) {\\n    for (int j = -actualThickness; j <= actualThickness; j++) {\\n      if (i == 0 || j == 0) {\\n        continue;\\n      }\\n\\n      vec4 neighborPixelCoord =\\n          vec4(gl_FragCoord.x + float(i), gl_FragCoord.y + float(j),\\n               gl_FragCoord.z, gl_FragCoord.w);\\n\\n      vec3 neighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);\\n      vec4 value = getTextureValue(neighborPosIS);\\n\\n      // If any of my neighbours are not the same value as I\\n      // am, this means I am on the border of the segment.\\n      // We can break the loops\\n      if (any(notEqual(value, centerValue))) {\\n        pixelOnBorder = true;\\n        break;\\n      }\\n    }\\n\\n    if (pixelOnBorder == true) {\\n      break;\\n    }\\n  }\\n\\n  // If I am on the border, I am displayed at full opacity\\n  if (pixelOnBorder == true) {\\n    tColor.a = volume.outlineOpacity;\\n  }\\n\\n  return tColor;\\n}\\n\\nvec4 getColorForAdditivePreset(vec4 tValue, vec3 posVC, vec3 posIS) {\\n  // compute normals\\n  mat4 normalMat = computeMat4Normal(posIS, tValue);\\n  vec4 normalLights[2];\\n  normalLights[0] = normalMat[0];\\n  normalLights[1] = normalMat[1];\\n  #if vtkNumberOfLights > 0\\n    if (volume.computeNormalFromOpacity == 1) {\\n      for (int component = 0; component < 2; ++component) {\\n        vec3 scalarInterp[2];\\n        float height = volume.transferFunctionsSampleHeight[component];\\n        computeNormalForDensity(posIS, scalarInterp, component);\\n        normalLights[component] =\\n            computeDensityNormal(scalarInterp, height, 1.0, component);\\n      }\\n    }\\n  #endif\\n\\n  // compute opacities\\n  float opacities[2];\\n  opacities[0] = getOpacityFromTexture(\\n      tValue[0], 0, volume.transferFunctionsSampleHeight[0]);\\n  opacities[1] = getOpacityFromTexture(\\n      tValue[1], 1, volume.transferFunctionsSampleHeight[1]);\\n  #ifdef EnabledGradientOpacity\\n    for (int component = 0; component < 2; ++component) {\\n      opacities[component] *=\\n          computeGradientOpacityFactor(normalMat[component].a, component);\\n    }\\n  #endif\\n  float opacitySum = opacities[0] + opacities[1];\\n  if (opacitySum <= 0.0) {\\n    return vec4(0.0);\\n  }\\n\\n  // mix the colors and opacities\\n  vec3 colors[2];\\n  for (int component = 0; component < 2; ++component) {\\n    float sampleHeight = volume.transferFunctionsSampleHeight[component];\\n    vec3 color = getColorFromTexture(tValue[component], component, sampleHeight);\\n    color = applyAllLightning(color, opacities[component], posVC,\\n                              normalLights[component]);\\n    colors[component] = color;\\n  }\\n  vec3 mixedColor =\\n      (opacities[0] * colors[0] + opacities[1] * colors[1]) / opacitySum;\\n  return vec4(mixedColor, min(1.0, opacitySum));\\n}\\n\\nvec4 getColorForColorizePreset(vec4 tValue, vec3 posVC, vec3 posIS) {\\n  // compute normals\\n  mat4 normalMat = computeMat4Normal(posIS, tValue);\\n  vec4 normalLight = normalMat[0];\\n  #if vtkNumberOfLights > 0\\n    if (volume.computeNormalFromOpacity == 1) {\\n      vec3 scalarInterp[2];\\n      float height = volume.transferFunctionsSampleHeight[0];\\n      computeNormalForDensity(posIS, scalarInterp, 0);\\n      normalLight = computeDensityNormal(scalarInterp, height, 1.0, 0);\\n    }\\n  #endif\\n\\n  // compute opacities\\n  float opacity = getOpacityFromTexture(\\n      tValue[0], 0, volume.transferFunctionsSampleHeight[0]);\\n  #ifdef EnabledGradientOpacity\\n    opacity *= computeGradientOpacityFactor(normalMat[0].a, 0);\\n  #endif\\n\\n  // colorizing component\\n  vec3 colorizingColor = getColorFromTexture(\\n      tValue[0], 1, volume.transferFunctionsSampleHeight[1]);\\n  float colorizingOpacity = getOpacityFromTexture(\\n      tValue[1], 1, volume.transferFunctionsSampleHeight[1]);\\n\\n  // mix the colors and opacities\\n  vec3 color =\\n      getColorFromTexture(tValue[0], 0,\\n                          volume.transferFunctionsSampleHeight[0]) *\\n      mix(vec3(1.0), colorizingColor, colorizingOpacity);\\n  color = applyAllLightning(color, opacity, posVC, normalLight);\\n  return vec4(color, opacity);\\n}\\n\\nvec4 getColorForDefaultIndependentPreset(vec4 tValue, vec3 posIS) {\\n\\n  // compute the normal vectors as needed\\n  #if defined(EnabledGradientOpacity) || vtkNumberOfLights > 0\\n    mat4 normalMat = computeMat4Normal(posIS, tValue);\\n  #endif\\n\\n  // process color and opacity for each component\\n  // initial value of alpha is determined by wether the first component is\\n  // proportional or not\\n  #if defined(vtkComponent0Proportional)\\n    // when it is proportional, it starts at 1 (neutral for multiplications)\\n    float alpha = 1.0;\\n  #else\\n    // when it is not proportional, it starts at 0 (neutral for additions)\\n    float alpha = 0.0;\\n  #endif\\n\\n  vec3 mixedColor = vec3(0.0);\\n  #if vtkNumberOfComponents > 0\\n    {\\n      const int component = 0;\\n      vec3 color = getColorFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      float opacity = getOpacityFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      #if !defined(vtkComponent0Proportional)\\n        float alphaContribution = volume.independentComponentMix[component] * opacity;\\n        #ifdef EnabledGradientOpacity\\n          alphaContribution *= computeGradientOpacityFactor(normalMat[component].a, component);\\n        #endif\\n        alpha += alphaContribution;\\n        #if vtkNumberOfLights > 0\\n          color = applyLighting(color, normalMat[component]);\\n        #endif\\n      #else\\n        color *= opacity;\\n        alpha *= mix(opacity, 1.0,\\n                    (1.0 - volume.independentComponentMix[component]));\\n      #endif\\n      mixedColor += volume.independentComponentMix[component] * color;\\n    }\\n  #endif\\n  #if vtkNumberOfComponents > 1\\n    {\\n      const int component = 1;\\n      vec3 color = getColorFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      float opacity = getOpacityFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      #if !defined(vtkComponent1Proportional)\\n        float alphaContribution = volume.independentComponentMix[component] * opacity;\\n        #ifdef EnabledGradientOpacity\\n          alphaContribution *= computeGradientOpacityFactor(normalMat[component].a, component);\\n        #endif\\n        alpha += alphaContribution;\\n        #if vtkNumberOfLights > 0\\n          color = applyLighting(color, normalMat[component]);\\n        #endif\\n      #else\\n        color *= opacity;\\n        alpha *= mix(opacity, 1.0,\\n                    (1.0 - volume.independentComponentMix[component]));\\n      #endif\\n      mixedColor += volume.independentComponentMix[component] * color;\\n    }\\n  #endif\\n  #if vtkNumberOfComponents > 2\\n    {\\n      const int component = 2;\\n      vec3 color = getColorFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      float opacity = getOpacityFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      #if !defined(vtkComponent2Proportional)\\n        float alphaContribution = volume.independentComponentMix[component] * opacity;\\n        #ifdef EnabledGradientOpacity\\n          alphaContribution *= computeGradientOpacityFactor(normalMat[component].a, component);\\n        #endif\\n        alpha += alphaContribution;\\n        #if vtkNumberOfLights > 0\\n          color = applyLighting(color, normalMat[component]);\\n        #endif\\n      #else\\n        color *= opacity;\\n        alpha *= mix(opacity, 1.0,\\n                    (1.0 - volume.independentComponentMix[component]));\\n      #endif\\n      mixedColor += volume.independentComponentMix[component] * color;\\n    }\\n  #endif\\n  #if vtkNumberOfComponents > 3\\n    {\\n      const int component = 3;\\n      vec3 color = getColorFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      float opacity = getOpacityFromTexture(\\n          tValue[component], component,\\n          volume.transferFunctionsSampleHeight[component]);\\n      #if !defined(vtkComponent3Proportional)\\n        float alphaContribution = volume.independentComponentMix[component] * opacity;\\n        #ifdef EnabledGradientOpacity\\n          alphaContribution *= computeGradientOpacityFactor(normalMat[component].a, component);\\n        #endif\\n        alpha += alphaContribution;\\n        #if vtkNumberOfLights > 0\\n          color = applyLighting(color, normalMat[component]);\\n        #endif\\n      #else\\n        color *= opacity;\\n        alpha *= mix(opacity, 1.0,\\n                    (1.0 - volume.independentComponentMix[component]));\\n      #endif\\n      mixedColor += volume.independentComponentMix[component] * color;\\n    }\\n  #endif\\n\\n  return vec4(mixedColor, alpha);\\n}\\n\\nvec4 getColorForDependentComponents(vec4 tValue, vec3 posVC, vec3 posIS) {\\n  #if defined(EnabledGradientOpacity) || vtkNumberOfLights > 0\\n    // use component 3 of the opacity texture as getTextureValue() sets alpha to\\n    // the opacity value\\n    vec3 scalarInterp[2];\\n    vec4 normal0 = computeNormalForDensity(posIS, scalarInterp, 3);\\n    float gradientOpacity = computeGradientOpacityFactor(normal0.a, 0);\\n  #endif\\n\\n  // get color and opacity\\n  #if vtkNumberOfComponents == 1\\n    vec3 tColor = getColorFromTexture(tValue.r, 0, 0.5);\\n    float alpha = getOpacityFromTexture(tValue.r, 0, 0.5);\\n  #endif\\n  #if vtkNumberOfComponents == 2\\n    vec3 tColor = vec3(tValue.r * volume.colorTextureScale[0] +\\n                  volume.colorTextureShift[0]);\\n    float alpha = getOpacityFromTexture(tValue.a, 1, 0.5);\\n  #endif\\n  #if vtkNumberOfComponents == 3\\n      vec3 tColor = tValue.rgb * volume.colorTextureScale.rgb +\\n              volume.colorTextureShift.rgb;\\n      float alpha = getOpacityFromTexture(tValue.a, 0, 0.5);\\n  #endif\\n  #if vtkNumberOfComponents == 4\\n      vec3 tColor = tValue.rgb * volume.colorTextureScale.rgb +\\n              volume.colorTextureShift.rgb;\\n      float alpha = getOpacityFromTexture(tValue.a, 3, 0.5);\\n  #endif\\n\\n  // Apply gradient opacity\\n  #if defined(EnabledGradientOpacity)\\n    alpha *= gradientOpacity;\\n  #endif\\n\\n  #if vtkNumberOfComponents == 1\\n    if (alpha < EPSILON) {\\n      return vec4(0.0);\\n    }\\n  #endif\\n\\n  // lighting\\n  #if vtkNumberOfLights > 0\\n    vec4 normalLight;\\n    if (volume.computeNormalFromOpacity == 1) {\\n      if (normal0[3] != 0.0) {\\n        normalLight =\\n            computeDensityNormal(scalarInterp, 0.5, gradientOpacity, 0);\\n        if (normalLight[3] == 0.0) {\\n          normalLight = normal0;\\n        }\\n      }\\n    } else {\\n      normalLight = normal0;\\n    }\\n    tColor = applyAllLightning(tColor, alpha, posVC, normalLight);\\n  #endif\\n\\n  return vec4(tColor, alpha);\\n}\\n\\nvec4 getColorForValue(vec4 tValue, vec3 posVC, vec3 posIS) {\\n  #ifdef EnableColorForValueFunctionId0\\n    return getColorForDependentComponents(tValue, posVC, posIS);\\n  #endif\\n\\n  #ifdef EnableColorForValueFunctionId1\\n    return getColorForAdditivePreset(tValue, posVC, posIS);\\n  #endif\\n\\n  #ifdef EnableColorForValueFunctionId2\\n    return getColorForColorizePreset(tValue, posVC, posIS);\\n  #endif\\n\\n  #ifdef EnableColorForValueFunctionId3\\n    /*\\n      * Mix the color information from all the independent components to get a\\n      * single rgba output. See other shader functions like\\n      * `getColorForAdditivePreset` to learn how to create a custom color mix.\\n      * The custom color mix should return a value, but if it doesn't, it will\\n      * fallback on the default shading\\n      */\\n    //VTK::CustomColorMix\\n  #endif\\n\\n  #if defined(EnableColorForValueFunctionId4) || defined(EnableColorForValueFunctionId3)\\n    return getColorForDefaultIndependentPreset(tValue, posIS);\\n  #endif\\n\\n  #ifdef EnableColorForValueFunctionId5\\n    return getColorForLabelOutline();\\n  #endif\\n}\\n\\nbool valueWithinScalarRange(vec4 val) {\\n  #if vtkNumberOfComponents > 1 && !defined(EnabledIndependentComponents)\\n    return false;\\n  #endif\\n  vec4 rangeMin = volume.ipScalarRangeMin;\\n  vec4 rangeMax = volume.ipScalarRangeMax;\\n  for (int component = 0; component < vtkNumberOfComponents; ++component) {\\n    if (val[component] < rangeMin[component] ||\\n        rangeMax[component] < val[component]) {\\n      return false;\\n    }\\n  }\\n  return true;\\n}\\n\\n#if vtkBlendMode == LABELMAP_EDGE_PROJECTION_BLEND\\n  bool checkOnEdgeForNeighbor(int xFragmentOffset, int yFragmentOffset,\\n                              int segmentIndex, vec3 stepIS) {\\n    vec3 volumeDimensions = vec3(volume.dimensions);\\n    vec4 neighborPixelCoord = vec4(gl_FragCoord.x + float(xFragmentOffset),\\n                                  gl_FragCoord.y + float(yFragmentOffset),\\n                                  gl_FragCoord.z, gl_FragCoord.w);\\n    vec3 originalNeighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);\\n\\n    vec3 neighborPosIS = originalNeighborPosIS;\\n    for (int k = 0; k < vtkMaximumNumberOfSamples / 2; ++k) {\\n      ivec3 texCoord = ivec3(neighborPosIS * volumeDimensions);\\n      vec4 texValue = rawFetchTexture(texCoord);\\n      if (int(texValue.g) == segmentIndex) {\\n        // not on edge\\n        return false;\\n      }\\n      neighborPosIS += stepIS;\\n    }\\n\\n    neighborPosIS = originalNeighborPosIS;\\n    for (int k = 0; k < vtkMaximumNumberOfSamples / 2; ++k) {\\n      ivec3 texCoord = ivec3(neighborPosIS * volumeDimensions);\\n      vec4 texValue = rawFetchTexture(texCoord);\\n      if (int(texValue.g) == segmentIndex) {\\n        // not on edge\\n        return false;\\n      }\\n      neighborPosIS -= stepIS;\\n    }\\n\\n    // onedge\\n    float sampleHeight = volume.transferFunctionsSampleHeight[1];\\n    vec3 tColorSegment =\\n        getColorFromTexture(float(segmentIndex), 1, sampleHeight);\\n    float pwfValueSegment =\\n        getOpacityFromTexture(float(segmentIndex), 1, sampleHeight);\\n    gl_FragData[0] = vec4(tColorSegment, pwfValueSegment);\\n    return true;\\n  }\\n#endif\\n\\nvec4 getColorAtPos(vec3 posVC) {\\n  vec3 posIS = posVCtoIS(posVC);\\n  vec4 texValue = getTextureValue(posIS);\\n  return getColorForValue(texValue, posVC, posIS);\\n}\\n\\n//=======================================================================\\n// Apply the specified blend mode operation along the ray's path.\\n//\\nvoid applyBlend(vec3 rayOriginVC, vec3 rayDirVC, float minDistance,\\n                float maxDistance) {\\n  // start slightly inside and apply some jitter\\n  vec3 stepVC = rayDirVC * sampleDistance;\\n  float raySteps = (maxDistance - minDistance) / sampleDistance;\\n\\n  // Avoid 0.0 jitter\\n  float jitter = 0.01 + 0.99 * fragmentSeed;\\n\\n  #if vtkBlendMode == COMPOSITE_BLEND\\n    // now map through opacity and color\\n    vec3 firstPosVC = rayOriginVC + minDistance * rayDirVC;\\n    vec4 firstColor = getColorAtPos(firstPosVC);\\n\\n    // handle very thin volumes\\n    if (raySteps <= 1.0) {\\n      firstColor.a = 1.0 - pow(1.0 - firstColor.a, raySteps);\\n      gl_FragData[0] = firstColor;\\n      return;\\n    }\\n\\n    // first color only counts for `jitter` factor of the step\\n    firstColor.a = 1.0 - pow(1.0 - firstColor.a, jitter);\\n    vec4 color = vec4(firstColor.rgb * firstColor.a, firstColor.a);\\n    vec3 posVC = firstPosVC + jitter * stepVC;\\n    float stepsTraveled = jitter;\\n\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      // If we have reached the last step, break\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n      vec4 tColor = getColorAtPos(posVC);\\n\\n      color = color + vec4(tColor.rgb * tColor.a, tColor.a) * (1.0 - color.a);\\n      stepsTraveled++;\\n      posVC += stepVC;\\n      if (color.a > 0.99) {\\n        color.a = 1.0;\\n        break;\\n      }\\n    }\\n\\n    if (color.a < 0.99 && (raySteps - stepsTraveled) > 0.0) {\\n      vec3 endPosVC = rayOriginVC + maxDistance * rayDirVC;\\n      vec4 tColor = getColorAtPos(endPosVC);\\n      tColor.a = 1.0 - pow(1.0 - tColor.a, raySteps - stepsTraveled);\\n\\n      float mix = (1.0 - color.a);\\n      color = color + vec4(tColor.rgb * tColor.a, tColor.a) * mix;\\n    }\\n\\n    gl_FragData[0] = vec4(color.rgb / color.a, color.a);\\n  #endif\\n\\n  #if vtkBlendMode == MAXIMUM_INTENSITY_BLEND ||                                 \\\\\\n      vtkBlendMode == MINIMUM_INTENSITY_BLEND\\n    // Find maximum/minimum intensity along the ray.\\n\\n    // Define the operation we will use (min or max)\\n    #if vtkBlendMode == MAXIMUM_INTENSITY_BLEND\\n      #define OP max\\n    #else\\n      #define OP min\\n    #endif\\n\\n    vec3 posVC = rayOriginVC + minDistance * rayDirVC;\\n    float stepsTraveled = 0.0;\\n\\n    // Find a value to initialize the selected variables\\n    vec4 selectedValue;\\n    vec3 selectedPosVC;\\n    vec3 selectedPosIS;\\n    {\\n      vec3 posIS = posVCtoIS(posVC);\\n      selectedValue = getTextureValue(posIS);\\n      selectedPosVC = posVC;\\n      selectedPosIS = posIS;\\n    }\\n\\n    // If the clipping range is shorter than the sample distance\\n    // we can skip the sampling loop along the ray.\\n    if (raySteps <= 1.0) {\\n      gl_FragData[0] = getColorForValue(selectedValue, selectedPosVC, selectedPosIS);\\n      return;\\n    }\\n\\n    posVC += jitter * stepVC;\\n    stepsTraveled += jitter;\\n\\n    // Sample along the ray until vtkMaximumNumberOfSamples,\\n    // ending slightly inside the total distance\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      // If we have reached the last step, break\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n\\n      // Get selected values\\n      vec3 posIS = posVCtoIS(posVC);\\n      vec4 previousSelectedValue = selectedValue;\\n      vec4 currentValue = getTextureValue(posIS);\\n      selectedValue = OP(selectedValue, currentValue);\\n      if (previousSelectedValue != selectedValue) {\\n        selectedPosVC = posVC;\\n        selectedPosIS = posIS;\\n      }\\n\\n      // Otherwise, continue along the ray\\n      stepsTraveled++;\\n      posVC += stepVC;\\n    }\\n\\n    // Perform the last step along the ray using the\\n    // residual distance\\n    posVC = rayOriginVC + maxDistance * rayDirVC;\\n    {\\n      vec3 posIS = posVCtoIS(posVC);\\n      vec4 previousSelectedValue = selectedValue;\\n      vec4 currentValue = getTextureValue(posIS);\\n      selectedValue = OP(selectedValue, currentValue);\\n      if (previousSelectedValue != selectedValue) {\\n        selectedPosVC = posVC;\\n        selectedPosIS = posIS;\\n      }\\n    }\\n\\n    gl_FragData[0] = getColorForValue(selectedValue, selectedPosVC, selectedPosIS);\\n  #endif\\n\\n  #if vtkBlendMode == ADDITIVE_INTENSITY_BLEND ||                                \\\\\\n      vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n    vec4 sum = vec4(0.);\\n    #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n      float totalWeight = 0.0;\\n    #endif\\n    vec3 posVC = rayOriginVC + minDistance * rayDirVC;\\n    float stepsTraveled = 0.0;\\n\\n    vec3 posIS = posVCtoIS(posVC);\\n    vec4 value = getTextureValue(posIS);\\n\\n    if (raySteps <= 1.0) {\\n      gl_FragData[0] = getColorForValue(value * raySteps, posVC, posIS);\\n      return;\\n    }\\n\\n    if (valueWithinScalarRange(value)) {\\n      sum += value * jitter;\\n      #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n        totalWeight += jitter;\\n      #endif\\n    }\\n    posVC += jitter * stepVC;\\n    stepsTraveled += jitter;\\n\\n    // Sample along the ray until vtkMaximumNumberOfSamples,\\n    // ending slightly inside the total distance\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      // If we have reached the last step, break\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n\\n      posIS = posVCtoIS(posVC);\\n      value = getTextureValue(posIS);\\n      // One can control the scalar range by setting the AverageIPScalarRange to\\n      // disregard scalar values, not in the range of interest, from the average\\n      // computation. Notes:\\n      // - We are comparing all values in the texture to see if any of them\\n      //   are outside of the scalar range. In the future we might want to allow\\n      //   scalar ranges for each component.\\n      if (valueWithinScalarRange(value)) {\\n        sum += value;\\n        #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n          totalWeight++;\\n        #endif\\n      }\\n\\n      stepsTraveled++;\\n      posVC += stepVC;\\n    }\\n\\n    // Perform the last step along the ray using the\\n    // residual distance\\n    posVC = rayOriginVC + maxDistance * rayDirVC;\\n    posIS = posVCtoIS(posVC);\\n    value = getTextureValue(posIS);\\n    if (valueWithinScalarRange(value)) {\\n      sum += value;\\n      #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n        totalWeight += raySteps - stepsTraveled;\\n      #endif\\n    }\\n\\n    #if vtkBlendMode == AVERAGE_INTENSITY_BLEND\\n      sum /= vec4(totalWeight, totalWeight, totalWeight, 1.0);\\n    #endif\\n\\n    gl_FragData[0] = getColorForValue(sum, posVC, posIS);\\n  #endif\\n\\n  #if vtkBlendMode == RADON_TRANSFORM_BLEND\\n    float normalizedRayIntensity = 1.0;\\n    vec3 posVC = rayOriginVC + minDistance * rayDirVC;\\n    float stepsTraveled = 0.0;\\n\\n    // handle very thin volumes\\n    if (raySteps <= 1.0) {\\n      vec3 posIS = posVCtoIS(posVC);\\n      vec4 tValue = getTextureValue(posIS);\\n      normalizedRayIntensity -= raySteps * sampleDistance *\\n                                getOpacityFromTexture(tValue.r, 0, 0.5);\\n      gl_FragData[0] =\\n          vec4(getColorFromTexture(normalizedRayIntensity, 0, 0.5), 1.0);\\n      return;\\n    }\\n\\n    posVC += jitter * stepVC;\\n    stepsTraveled += jitter;\\n\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n\\n      vec3 posIS = posVCtoIS(posVC);\\n      vec4 value = getTextureValue(posIS);\\n      // Convert scalar value to normalizedRayIntensity coefficient and\\n      // accumulate normalizedRayIntensity\\n      normalizedRayIntensity -=\\n          sampleDistance * getOpacityFromTexture(value.r, 0, 0.5);\\n\\n      posVC += stepVC;\\n      stepsTraveled++;\\n    }\\n\\n    // map normalizedRayIntensity to color\\n    gl_FragData[0] =\\n        vec4(getColorFromTexture(normalizedRayIntensity, 0, 0.5), 1.0);\\n  #endif\\n\\n  #if vtkBlendMode == LABELMAP_EDGE_PROJECTION_BLEND\\n    // Only works with a single volume\\n    vec3 posVC = rayOriginVC + minDistance * rayDirVC;\\n    float stepsTraveled = 0.0;\\n    vec3 posIS = posVCtoIS(posVC);\\n    vec4 tValue = getTextureValue(posIS);\\n    if (raySteps <= 1.0) {\\n      gl_FragData[0] = getColorForValue(tValue, posVC, posIS);\\n      return;\\n    }\\n\\n    vec3 stepIS = vecVCToIS(stepVC);\\n    vec4 value = tValue;\\n    posIS += jitter * stepIS;\\n    stepsTraveled += jitter;\\n    vec3 maxPosIS = posIS; // Store the position of the max value\\n    int segmentIndex = int(value.g);\\n    bool originalPosHasSeenNonZero = false;\\n\\n    if (segmentIndex != 0) {\\n      // Tried using the segment index in an boolean array but reading\\n      // from the array by dynamic indexing was horrondously slow\\n      // so use bit masking instead and assign 1 to the bit corresponding to the\\n      // segment index and later check if the bit is set via bit operations\\n      setLabelOutlineBit(segmentIndex);\\n    }\\n\\n    // Sample along the ray until vtkMaximumNumberOfSamples,\\n    // ending slightly inside the total distance\\n    for (int i = 0; i < vtkMaximumNumberOfSamples; ++i) {\\n      // If we have reached the last step, break\\n      if (stepsTraveled + 1.0 >= raySteps) {\\n        break;\\n      }\\n\\n      // compute the scalar\\n      tValue = getTextureValue(posIS);\\n      segmentIndex = int(tValue.g);\\n\\n      if (segmentIndex != 0) {\\n        originalPosHasSeenNonZero = true;\\n        setLabelOutlineBit(segmentIndex);\\n      }\\n\\n      if (tValue.r > value.r) {\\n        value = tValue;   // Update the max value\\n        maxPosIS = posIS; // Update the position where max occurred\\n      }\\n\\n      // Otherwise, continue along the ray\\n      stepsTraveled++;\\n      posIS += stepIS;\\n    }\\n\\n    // Perform the last step along the ray using the\\n    // residual distance\\n    posIS = posVCtoIS(rayOriginVC + maxDistance * rayDirVC);\\n    tValue = getTextureValue(posIS);\\n\\n    if (tValue.r > value.r) {\\n      value = tValue;   // Update the max value\\n      maxPosIS = posIS; // Update the position where max occurred\\n    }\\n\\n    // If we have not seen any non-zero segments, we can return early\\n    // and grab color from the actual center value first component (image)\\n    if (!originalPosHasSeenNonZero) {\\n      vec3 maxPosVC = posIStoVC(maxPosIS);\\n      gl_FragData[0] = getColorForValue(value, maxPosVC, maxPosIS);\\n      return;\\n    }\\n\\n    vec3 neighborRayStepsIS = stepIS;\\n    float neighborRaySteps = raySteps;\\n    bool shouldLookInAllNeighbors = false;\\n\\n    vec3 volumeSpacings = volume.spacing;\\n    float minVoxelSpacing =\\n        min(volumeSpacings[0], min(volumeSpacings[1], volumeSpacings[2]));\\n    vec4 base =\\n        vec4(gl_FragCoord.x, gl_FragCoord.y, gl_FragCoord.z, gl_FragCoord.w);\\n\\n    vec4 baseXPlus = vec4(gl_FragCoord.x + 1.0, gl_FragCoord.y, gl_FragCoord.z,\\n                          gl_FragCoord.w);\\n    vec4 baseYPlus = vec4(gl_FragCoord.x, gl_FragCoord.y + 1.0, gl_FragCoord.z,\\n                          gl_FragCoord.w);\\n\\n    vec3 baseWorld = fragCoordToWorld(base);\\n    vec3 baseXPlusWorld = fragCoordToWorld(baseXPlus);\\n    vec3 baseYPlusWorld = fragCoordToWorld(baseYPlus);\\n\\n    float XPlusDiff = length(baseXPlusWorld - baseWorld);\\n    float YPlusDiff = length(baseYPlusWorld - baseWorld);\\n\\n    float minFragSpacingWorld = min(XPlusDiff, YPlusDiff);\\n\\n    for (int s = 1; s < MAX_SEGMENT_INDEX; s++) {\\n      // bail out quickly if the segment index has not\\n      // been seen by the center segment\\n      if (!isLabelOutlineBitSet(s)) {\\n        continue;\\n      }\\n\\n      // Use texture sampling for outlineThickness so that we can have\\n      // per segment thickness\\n      float textureCoordinate = float(s - 1) / 1024.0;\\n      float textureValue =\\n          texture2D(labelOutlineThicknessTexture, vec2(textureCoordinate, 0.5)).r;\\n\\n      int actualThickness = int(textureValue * 255.0);\\n\\n      // check the extreme points in the neighborhood since there is a better\\n      // chance of finding the edge there, so that we can bail out\\n      // faster if we find the edge\\n      bool onEdge = checkOnEdgeForNeighbor(-actualThickness, -actualThickness, s,\\n                                          stepIS) ||\\n                    checkOnEdgeForNeighbor(actualThickness, actualThickness, s,\\n                                          stepIS) ||\\n                    checkOnEdgeForNeighbor(actualThickness, -actualThickness, s,\\n                                          stepIS) ||\\n                    checkOnEdgeForNeighbor(-actualThickness, +actualThickness, s,\\n                                          stepIS);\\n\\n      if (onEdge) {\\n        return;\\n      }\\n\\n      // since the next step is computationally expensive, we need to perform\\n      // some optimizations to avoid it if possible. One of the optimizations\\n      // is to check the whether the minimum of the voxel spacing is greater than\\n      // the 2 * the thickness of the outline segment. If that is the case\\n      // then we can safely skip the next step since we can be sure that the\\n      // the previous 4 checks on the extreme points would caught the entirety\\n      // of the all the fragments inside. i.e., this happens when we zoom out,\\n      if (minVoxelSpacing >\\n          (2.0 * float(actualThickness) - 1.0) * minFragSpacingWorld) {\\n        continue;\\n      }\\n\\n      // Loop through the rest, skipping the processed extremes and the center\\n      for (int i = -actualThickness; i <= actualThickness; i++) {\\n        for (int j = -actualThickness; j <= actualThickness; j++) {\\n          if (i == 0 && j == 0)\\n            continue; // Skip the center\\n          if (abs(i) == actualThickness && abs(j) == actualThickness)\\n            continue; // Skip corners\\n          if (checkOnEdgeForNeighbor(i, j, s, stepIS)) {\\n            return;\\n          }\\n        }\\n      }\\n    }\\n\\n    float sampleHeight = volume.transferFunctionsSampleHeight[0];\\n    vec3 tColor0 = getColorFromTexture(value.r, 0, sampleHeight);\\n    float pwfValue0 = getOpacityFromTexture(value.r, 0, sampleHeight);\\n    gl_FragData[0] = vec4(tColor0, pwfValue0);\\n  #endif\\n}\\n\\n//=======================================================================\\n// given a\\n// - ray direction (rayDir)\\n// - starting point (vertexVCVSOutput)\\n// - bounding planes of the volume\\n// - optionally depth buffer values\\n// - far clipping plane\\n// compute the start/end distances of the ray we need to cast\\nvec2 computeRayDistances(vec3 rayOriginVC, vec3 rayDirVC) {\\n  vec2 dists = rayIntersectVolumeDistances(rayOriginVC, rayDirVC);\\n\\n  //VTK::ClipPlane::Impl\\n\\n  // do not go behind front clipping plane\\n  dists.x = max(0.0, dists.x);\\n\\n  // do not go PAST far clipping plane\\n  float farDist = -camThick / rayDirVC.z;\\n  dists.y = min(farDist, dists.y);\\n\\n  // Do not go past the zbuffer value if set\\n  // This is used for intermixing opaque geometry\\n  //VTK::ZBuffer::Impl\\n\\n  return dists;\\n}\\n\\nfloat getFragmentSeed() {\\n  // This first noise has a diagonal pattern\\n  float firstNoise =\\n      fract(sin(dot(gl_FragCoord.xy, vec2(12.9898, 78.233))) * 43758.5453);\\n  // This second noise is made out of blocks of CPU generated noise\\n  float secondNoise = texture2D(jtexture, gl_FragCoord.xy / 32.0).r;\\n  // Combine the two sources of noise in a way that the distribution is uniform\\n  // in [0,1[\\n  float noiseSum = firstNoise + secondNoise;\\n  return noiseSum < 1.0 ? noiseSum : noiseSum - 1.0;\\n}\\n\\nvoid main() {\\n  fragmentSeed = getFragmentSeed();\\n\\n  if (cameraParallel == 1) {\\n    // Camera is parallel, so the rayDir is just the direction of the camera.\\n    rayDirVC = vec3(0.0, 0.0, -1.0);\\n  } else {\\n    // camera is at 0,0,0 so rayDir for perspective is just the vc coord\\n    rayDirVC = normalize(vertexVCVSOutput);\\n  }\\n\\n  vec3 rayOriginVC = vertexVCVSOutput;\\n  vec2 rayStartEndDistancesVC = computeRayDistances(rayOriginVC, rayDirVC);\\n  if (rayStartEndDistancesVC[1] <= rayStartEndDistancesVC[0] ||\\n      rayStartEndDistancesVC[1] <= 0.0) {\\n    // Volume not hit or behind the ray\\n    discard;\\n  }\\n\\n  // Perform the blending operation along the ray\\n  applyBlend(rayOriginVC, rayDirVC, rayStartEndDistancesVC[0], rayStartEndDistancesVC[1]);\\n}\\n&quot;,e.Geometry=&quot;&quot;},e.replaceShaderValues=(e,n,r)=>{let o=e.Fragment;o=td.substitute(o,&quot;//VTK::EnabledColorFunctions&quot;,`#define EnableColorForValueFunctionId${t.previousState.colorForValueFunctionId}`).result;const a=[];t.previousState.surfaceLightingEnabled&&a.push(&quot;Surface&quot;),t.previousState.volumeLightingEnabled&&a.push(&quot;Volume&quot;),o=td.substitute(o,&quot;//VTK::EnabledLightings&quot;,a.map((e=>`#define Enable${e}Lighting`))).result,t.previousState.multiTexturePerVolumeEnabled&&(o=td.substitute(o,&quot;//VTK::EnabledMultiTexturePerVolume&quot;,&quot;#define EnabledMultiTexturePerVolume&quot;).result),t.previousState.useIndependentComponents&&(o=td.substitute(o,&quot;//VTK::EnabledIndependentComponents&quot;,&quot;#define EnabledIndependentComponents&quot;).result),t.previousState.gradientOpacityEnabled&&(o=td.substitute(o,&quot;//VTK::EnabledGradientOpacity&quot;,&quot;#define EnabledGradientOpacity&quot;).result),o=td.substitute(o,&quot;//VTK::vtkProportionalComponents&quot;,t.previousState.proportionalComponents.map((e=>`#define vtkComponent${e}Proportional`)).join(&quot;\\n&quot;)).result,o=td.substitute(o,&quot;//VTK::vtkForceNearestComponents&quot;,t.previousState.forceNearestComponents.map((e=>`#define vtkComponent${e}ForceNearest`)).join(&quot;\\n&quot;)).result,t.previousState.hasZBufferTexture&&(o=td.substitute(o,&quot;//VTK::ZBuffer::Dec&quot;,[&quot;uniform sampler2D zBufferTexture;&quot;,&quot;uniform float vpZWidth;&quot;,&quot;uniform float vpZHeight;&quot;]).result,o=td.substitute(o,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;vec4 depthVec = texture2D(zBufferTexture, vec2(gl_FragCoord.x / vpZWidth, gl_FragCoord.y/vpZHeight));&quot;,&quot;float zdepth = (depthVec.r*256.0 + depthVec.g)/257.0;&quot;,&quot;zdepth = zdepth * 2.0 - 1.0;&quot;,&quot;if (cameraParallel == 0) {&quot;,&quot;zdepth = -2.0 * camFar * camNear / (zdepth*(camFar-camNear)-(camFar+camNear)) - camNear;}&quot;,&quot;else {&quot;,&quot;zdepth = (zdepth + 1.0) * 0.5 * (camFar - camNear);}\\n&quot;,&quot;zdepth = -zdepth/rayDirVC.z;&quot;,&quot;dists.y = min(zdepth,dists.y);&quot;]).result),o=td.substitute(o,&quot;//VTK::BlendMode&quot;,`${t.previousState.blendMode}`).result,o=td.substitute(o,&quot;//VTK::NumberOfLights&quot;,`${t.previousState.numberOfLights}`).result,o=td.substitute(o,&quot;//VTK::MaxLaoKernelSize&quot;,`${t.previousState.maxLaoKernelSize}`).result,o=td.substitute(o,&quot;//VTK::NumberOfComponents&quot;,`${t.previousState.numberOfComponents}`).result,o=td.substitute(o,&quot;//VTK::MaximumNumberOfSamples&quot;,`${t.previousState.maximumNumberOfSamples}`).result,e.Fragment=o;const i=t.previousState.numberOfClippingPlanes;i>0&&(o=td.substitute(o,&quot;//VTK::ClipPlane::Dec&quot;,[&quot;uniform vec3 vClipPlaneNormals[6];&quot;,&quot;uniform float vClipPlaneDistances[6];&quot;,&quot;uniform vec3 vClipPlaneOrigins[6];&quot;,&quot;uniform int clip_numPlanes;&quot;,&quot;//VTK::ClipPlane::Dec&quot;,&quot;#define vtkClippingPlanesOn&quot;],!1).result,o=td.substitute(o,&quot;//VTK::ClipPlane::Impl&quot;,[`for(int i = 0; i < ${i}; i++) {`,&quot;  float rayDirRatio = dot(rayDirVC, vClipPlaneNormals[i]);&quot;,&quot;  float equationResult = dot(vertexVCVSOutput, vClipPlaneNormals[i]) + vClipPlaneDistances[i];&quot;,&quot;  if (rayDirRatio == 0.0)&quot;,&quot;  {&quot;,&quot;    if (equationResult < 0.0) dists.x = dists.y;&quot;,&quot;    continue;&quot;,&quot;  }&quot;,&quot;  float result = -1.0 * equationResult / rayDirRatio;&quot;,&quot;  if (rayDirRatio < 0.0) dists.y = min(dists.y, result);&quot;,&quot;  else dists.x = max(dists.x, result);&quot;,&quot;}&quot;,&quot;//VTK::ClipPlane::Impl&quot;],!1).result),e.Fragment=o},e.getNeedToRebuildShaders=(r,o,a)=>{const i=!!t.zBufferTexture,s=t.currentValidInputs.length,l=t.numberOfLights,c=t.numberOfComponents,u=t.useIndependentComponents,d=a.getProperties(),p=t.currentValidInputs[0],f=d[p.inputIndex],g=s>1,m=p.imageData.getBounds(),h=Gi.getDiagonalLength(m),v=Math.ceil(h/e.getCurrentSampleDistance(o));v>t.renderable.getMaximumSamplesPerRay()&&ng(`The number of steps required ${v} is larger than the specified maximum number of steps ${t.renderable.getMaximumSamplesPerRay()}.\\nPlease either change the volumeMapper sampleDistance or its maximum number of samples.`);const T=u?c:1;let y=!1;for(let e=0;e<T;++e)if(f.getUseGradientOpacity(e)){y=!0;break}let b=0;const x=f.getLAOKernelSize();x>b&&f.getLocalAmbientOcclusion()&&f.getAmbient()>0&&(b=x);const C=t.renderable.getClippingPlanes().length,S=t.renderable.getViewSpecificProperties().OpenGL?.ShaderReplacements,A=t.currentRenderPass?.getShaderReplacement(),I=t.renderable.getBlendMode(),w=(()=>{if(I!==eg.LABELMAP_EDGE_PROJECTION_BLEND&&n(f))return 5;if(u)switch(f.getColorMixPreset()){case Qf.ADDITIVE:return 1;case Qf.COLORIZE:return 2;case Qf.CUSTOM:return 3;default:return 4}return 0})(),O=f.getVolumetricScatteringBlending()<1,P=f.getVolumetricScatteringBlending()>0;let R=!1;for(let e=0;e<c;++e)if(f.getForceNearestInterpolation(e)){R=!0;break}const M=[],E=[];for(let e=0;e<c;e++)f.getOpacityMode(e)===Zf.PROPORTIONAL&&M.push(e),f.getForceNearestInterpolation(e)&&E.push(e);const V={numberOfComponents:c,useIndependentComponents:u,proportionalComponents:M,forceNearestComponents:E,blendMode:I,numberOfLights:l,numberOfValidInputs:s,maximumNumberOfSamples:v,hasZBufferTexture:i,maxLaoKernelSize:b,numberOfClippingPlanes:C,mapperShaderReplacements:S,renderPassShaderReplacements:A,colorForValueFunctionId:w,surfaceLightingEnabled:O,volumeLightingEnabled:P,forceNearestInterpolationEnabled:R,multiTexturePerVolumeEnabled:g,gradientOpacityEnabled:y};return!(0!==r.getProgram()?.getHandle()&&t.previousState&&ke(t.previousState,V)||(t.previousState=V,0))},e.updateShaders=(n,r,o)=>{if(e.getNeedToRebuildShaders(n,r,o)){const a={Vertex:null,Fragment:null,Geometry:null};e.buildShaders(a,r,o);const i=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(a.Vertex,a.Fragment,a.Geometry);i!==n.getProgram()&&(n.setProgram(i),n.getVAO().releaseGraphicsResources()),n.getShaderSourceTime().modified()}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(n.getProgram());n.getVAO().bind(),e.setMapperShaderParameters(n,r,o),e.setCameraShaderParameters(n,r,o),e.setPropertyShaderParameters(n,r,o),e.getClippingPlaneShaderParameters(n,r,o)},e.setMapperShaderParameters=(n,r,o)=>{const a=n.getProgram();n.getCABO().getElementCount()&&(t.VBOBuildTime.getMTime()>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())&&(a.isAttributeUsed(&quot;vertexDC&quot;)&&(n.getVAO().addAttributeArray(a,n.getCABO(),&quot;vertexDC&quot;,n.getCABO().getVertexOffset(),n.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||rg(&quot;Error setting vertexDC in shader VAO.&quot;)),n.getAttributeUpdateTime().modified());const i=e.getCurrentSampleDistance(r);a.setUniformf(&quot;sampleDistance&quot;,i);const s=i*t.renderable.getVolumeShadowSamplingDistFactor();a.setUniformf(&quot;volumeShadowSampleDistance&quot;,s),t.scalarTextures.forEach(((e,t)=>{a.setUniformi(`volumeTexture[${t}]`,e.getTextureUnit())}));const l=o.getProperties()[t.currentValidInputs[0].inputIndex].getIpScalarRange(),c=new Float32Array(4),u=new Float32Array(4),d=(e,t,n)=>{t?.dataComputedScale?.length&&(c[e]=l[0]*t.dataComputedScale[n]+t.dataComputedOffset[n],u[e]=l[1]*t.dataComputedScale[n]+t.dataComputedOffset[n],c[e]=(c[e]-t.offset[n])/t.scale[n],u[e]=(u[e]-t.offset[n])/t.scale[n])};if(t.previousState.multiTexturePerVolumeEnabled)t.scalarTextures.forEach(((e,t)=>{const n=e.getVolumeInfo();d(t,n,0)}));else{const e=t.scalarTextures[0].getVolumeInfo();for(let t=0;t<4;++t)d(t,e,t)}const p=&quot;volume&quot;;if(a.setUniform4f(`${p}.ipScalarRangeMin`,c[0],c[1],c[2],c[3]),a.setUniform4f(`${p}.ipScalarRangeMax`,u[0],u[1],u[2],u[3]),null!==t.zBufferTexture){a.setUniformi(&quot;zBufferTexture&quot;,t.zBufferTexture.getTextureUnit());const e=t._useSmallViewport?[t._smallViewportWidth,t._smallViewportHeight]:t._openGLRenderWindow.getFramebufferSize();a.setUniformf(&quot;vpZWidth&quot;,e[0]),a.setUniformf(&quot;vpZHeight&quot;,e[1])}},e.setCameraShaderParameters=(r,o,a)=>{const{idxToView:i,vecISToVCMatrix:s,modelToView:l,projectionToView:c,projectionToWorld:u}=og,d=t.openGLCamera.getKeyMatrices(o),p=t.openGLVolume.getKeyMatrices();b(l,d.wcvc,p.mcwc);const f=r.getProgram(),g=t.openGLCamera.getRenderable(),m=g.getParallelProjection(),h=g.getClippingRange();f.setUniformf(&quot;camThick&quot;,h[1]-h[0]),f.setUniformf(&quot;camNear&quot;,h[0]),f.setUniformf(&quot;camFar&quot;,h[1]),f.setUniformi(&quot;cameraParallel&quot;,m);const T=t.currentValidInputs[0],y=T.imageData.getBounds(),x=Gi.getCorners(y,[]).map((e=>(In(e,e,l),m||bn(e,e,-h[0]/(e[2]*gn(e))),In(e,e,d.vcpc),e))),C=Gi.addPoints([...Gi.INIT_BOUNDS],x);f.setUniformf(&quot;dcxmin&quot;,C[0]),f.setUniformf(&quot;dcxmax&quot;,C[1]),f.setUniformf(&quot;dcymin&quot;,C[2]),f.setUniformf(&quot;dcymax&quot;,C[3]);const S=e.getRenderTargetSize();f.setUniformf(&quot;vpWidth&quot;,S[0]),f.setUniformf(&quot;vpHeight&quot;,S[1]);const A=e.getRenderTargetOffset();f.setUniformf(&quot;vpOffsetX&quot;,A[0]/S[0]),f.setUniformf(&quot;vpOffsetY&quot;,A[1]/S[1]),v(c,d.vcpc),f.setUniformMatrix(&quot;PCVCMatrix&quot;,c),f.setUniformi(&quot;twoSidedLighting&quot;,o.getTwoSidedLighting());const I=new Array(2*t.previousState.maxLaoKernelSize);for(let e=0;e<t.previousState.maxLaoKernelSize;e++)I[2*e]=Math.random(),I[2*e+1]=Math.random();if(f.setUniform2fv(&quot;kernelSample&quot;,I),t.numberOfLights>0){let e=0;o.getLights().forEach((t=>{if(t.getSwitch()>0){const n=`lights[${e}]`,r=bn([],t.getColor(),t.getIntensity());f.setUniform3fv(`${n}.color`,r);const o=t.getTransformedPosition();In(o,o,l),f.setUniform3fv(`${n}.positionVC`,o);const a=[...t.getDirection()];wn(a,a,d.normalMatrix),Cn(a,a),f.setUniform3fv(`${n}.directionVC`,a);const i=[-.5*a[0],-.5*a[1],-.5*(a[2]-1)];f.setUniform3fv(`${n}.halfAngleVC`,i);const s=t.getAttenuationValues();f.setUniform3fv(`${n}.attenuation`,s);const c=t.getExponent();f.setUniformf(`${n}.exponent`,c);const u=t.getConeAngle();f.setUniformf(`${n}.coneAngle`,u);const p=t.getPositional();f.setUniformi(`${n}.isPositional`,p),e++}}))}const w=&quot;volume&quot;,O=a.getProperties()[T.inputIndex],P=T.imageData,R=P.getSpatialExtent(),M=P.getSpacing(),E=P.getDimensions(),V=P.getIndexToWorld(),D=P.getWorldToIndex(),L=P.getDirectionByReference();b(i,l,V),f.setUniform3fv(`${w}.spacing`,M);const B=xn([],M);f.setUniform3fv(`${w}.inverseSpacing`,B),f.setUniform3iv(`${w}.dimensions`,E),f.setUniform3fv(`${w}.inverseDimensions`,xn([],E)),f.setUniformMatrix(`${w}.worldToIndex`,D),s.fill(0);const N=yn(new Float64Array(3),E,M);s[0]=N[0],s[4]=N[1],s[8]=N[2],Te(s,L,s),Te(s,p.normalMatrix,s),Te(s,d.normalMatrix,s),f.setUniformMatrix3x3(`${w}.vecISToVCMatrix`,s),f.setUniformMatrix3x3(`${w}.vecVCToISMatrix`,me(new Float32Array(9),s));const F=mn(R[0],R[2],R[4]),_=In(new Float64Array(3),F,i);f.setUniform3fv(`${w}.originVC`,_);const k=gn(N);if(f.setUniformf(`${w}.diagonalLength`,k),n(O)){const e=g.getDistance();g.setClippingRange(e,e+.1),v(u,t.openGLCamera.getKeyMatrices(o).wcpc),g.setClippingRange(h[0],h[1]),t.openGLCamera.getKeyMatrices(o),f.setUniformMatrix(`${w}.PCWCMatrix`,u)}if(O.getVolumetricScatteringBlending()>0&&(f.setUniformf(`${w}.globalIlluminationReach`,O.getGlobalIlluminationReach()),f.setUniformf(`${w}.volumetricScatteringBlending`,O.getVolumetricScatteringBlending()),f.setUniformf(`${w}.anisotropy`,O.getAnisotropy()),f.setUniformf(`${w}.anisotropySquared`,O.getAnisotropy()**2)),O.getLocalAmbientOcclusion()&&O.getAmbient()>0){const e=O.getLAOKernelSize();f.setUniformi(`${w}.kernelSize`,e);const t=O.getLAOKernelRadius();f.setUniformi(`${w}.kernelRadius`,t)}else f.setUniformi(`${w}.kernelSize`,0)},e.setPropertyShaderParameters=(e,n,r)=>{const o=e.getProgram();o.setUniformi(&quot;jtexture&quot;,t.jitterTexture.getTextureUnit());const a=r.getProperties();o.setUniformi(&quot;labelOutlineThicknessTexture&quot;,t.labelOutlineThicknessTexture.getTextureUnit()),o.setUniformi(&quot;opacityTexture&quot;,t.opacityTexture.getTextureUnit()),o.setUniformi(&quot;colorTexture&quot;,t.colorTexture.getTextureUnit());const i=&quot;volume&quot;,s=a[t.currentValidInputs[0].inputIndex],l=t.previousState.numberOfComponents,c=t.previousState.useIndependentComponents;if(c){const e=new Float32Array(4);for(let t=0;t<l;t++)e[t]=s.getComponentWeight(t);o.setUniform4fv(`${i}.independentComponentMix`,e);const t=new Float32Array(4),n=1/l;for(let e=0;e<l;++e)t[e]=(e+.5)*n;o.setUniform4fv(`${i}.transferFunctionsSampleHeight`,t)}const u=t.colorForValueFunctionId;o.setUniformi(`${i}.colorForValueFunctionId`,u);const d=s.getComputeNormalFromOpacity();o.setUniformi(`${i}.computeNormalFromOpacity`,d);const p=new Float32Array(4),f=new Float32Array(4),g=new Float32Array(4),m=new Float32Array(4);for(let e=0;e<l;e++){const n=t.previousState.multiTexturePerVolumeEnabled,r=n?e:0,o=n?0:e,a=t.scalarTextures[r].getVolumeInfo(),i=c?e:0,l=a.scale[o],u=s.getRGBTransferFunction(i).getRange();p[e]=l/(u[1]-u[0]),f[e]=(a.offset[o]-u[0])/(u[1]-u[0]);const d=s.getScalarOpacity(i).getRange();g[e]=l/(d[1]-d[0]),m[e]=(a.offset[o]-d[0])/(d[1]-d[0])}if(o.setUniform4fv(`${i}.colorTextureScale`,p),o.setUniform4fv(`${i}.colorTextureShift`,f),o.setUniform4fv(`${i}.opacityTextureScale`,g),o.setUniform4fv(`${i}.opacityTextureShift`,m),t.previousState.gradientOpacityEnabled){const e=new Array(4),n=new Array(4),r=new Array(4),a=new Array(4);if(c)for(let o=0;o<l;++o){const i=t.previousState.multiTexturePerVolumeEnabled,l=i?o:0,c=i?0:o,u=t.scalarTextures[l].getVolumeInfo().scale[c];if(s.getUseGradientOpacity(o)){const t=[s.getGradientOpacityMinimumOpacity(o),s.getGradientOpacityMaximumOpacity(o)],i=[s.getGradientOpacityMinimumValue(o),s.getGradientOpacityMaximumValue(o)];r[o]=t[0],a[o]=t[1],e[o]=u*(t[1]-t[0])/(i[1]-i[0]),n[o]=-i[0]*(t[1]-t[0])/(i[1]-i[0])+t[0]}else r[o]=1,a[o]=1,e[o]=0,n[o]=1}else{const o=l-1,i=t.previousState.multiTexturePerVolumeEnabled,c=i?o:0,u=i?0:o,d=t.scalarTextures[c].getVolumeInfo().scale[u],p=[s.getGradientOpacityMinimumOpacity(0),s.getGradientOpacityMaximumOpacity(0)],f=[s.getGradientOpacityMinimumValue(0),s.getGradientOpacityMaximumValue(0)];r[0]=p[0],a[0]=p[1],e[0]=d*(p[1]-p[0])/(f[1]-f[0]),n[0]=-f[0]*(p[1]-p[0])/(f[1]-f[0])+p[0]}o.setUniform4f(`${i}.gradientOpacityScale`,e),o.setUniform4f(`${i}.gradientOpacityShift`,n),o.setUniform4f(`${i}.gradientOpacityMin`,r),o.setUniform4f(`${i}.gradientOpacityMax`,a)}const h=s.getLabelOutlineOpacity();if(o.setUniformf(`${i}.outlineOpacity`,h),t.numberOfLights>0){o.setUniformf(`${i}.ambient`,s.getAmbient()),o.setUniformf(`${i}.diffuse`,s.getDiffuse()),o.setUniformf(`${i}.specular`,s.getSpecular());const e=s.getSpecularPower();o.setUniformf(`${i}.specularPower`,0===e?1:e)}},e.getClippingPlaneShaderParameters=(e,n,r)=>{if(t.renderable.getClippingPlanes().length>0){const r=t.openGLCamera.getKeyMatrices(n),o=[],a=[],i=[],s=t.renderable.getClippingPlanes(),l=s.length;for(let e=0;e<l;++e){const t=s[e].getNormal(),n=s[e].getOrigin();wn(t,t,r.normalMatrix),In(n,n,r.wcvc);const l=-1*Sn(n,t);o.push(t[0]),o.push(t[1]),o.push(t[2]),a.push(l),i.push(n[0]),i.push(n[1]),i.push(n[2])}const c=e.getProgram();c.setUniform3fv(&quot;vClipPlaneNormals&quot;,o),c.setUniformfv(&quot;vClipPlaneDistances&quot;,a),c.setUniform3fv(&quot;vClipPlaneOrigins&quot;,i),c.setUniformi(&quot;clip_numPlanes&quot;,l)}},e.delete=Et((()=>{t._animationRateSubscription&&(t._animationRateSubscription.unsubscribe(),t._animationRateSubscription=null)}),(()=>{t._openGLRenderWindow&&a(t._openGLRenderWindow)}),e.delete),e.getRenderTargetSize=()=>{if(t._useSmallViewport)return[t._smallViewportWidth,t._smallViewportHeight];const{usize:e,vsize:n}=t._openGLRenderer.getTiledSizeAndOrigin();return[e,n]},e.getRenderTargetOffset=()=>{const{lowerLeftU:e,lowerLeftV:n}=t._openGLRenderer.getTiledSizeAndOrigin();return[e,n]},e.getCurrentSampleDistance=e=>{const n=e.getVTKWindow().getInteractor(),r=t.renderable.getSampleDistance();return n.isAnimating()?r*t.renderable.getInteractionSampleDistanceFactor():r},e.renderPieceStart=(n,r)=>{const o=n.getVTKWindow().getInteractor();if(t._lastScale||(t._lastScale=t.renderable.getInitialInteractionScale()),t._useSmallViewport=!1,o.isAnimating()&&t._lastScale>1.5&&(t._useSmallViewport=!0),t._animationRateSubscription||(t._animationRateSubscription=o.onAnimationFrameRateUpdate((()=>{if(t.renderable.getAutoAdjustSampleDistances()){const e=o.getRecentAnimationFrameRate(),n=o.getDesiredUpdateRate()/e;(n>1.15||n<.85)&&(t._lastScale*=n),t._lastScale>400&&(t._lastScale=400),t._lastScale<1.5&&(t._lastScale=1.5)}else t._lastScale=t.renderable.getImageSampleDistance()*t.renderable.getImageSampleDistance()}))),t._useSmallViewport){const e=t._openGLRenderWindow.getFramebufferSize(),n=1/Math.sqrt(t._lastScale);if(t._smallViewportWidth=Math.ceil(n*e[0]),t._smallViewportHeight=Math.ceil(n*e[1]),t._smallViewportHeight>e[1]&&(t._smallViewportHeight=e[1]),t._smallViewportWidth>e[0]&&(t._smallViewportWidth=e[0]),t.framebuffer.saveCurrentBindingsAndBuffers(),null===t.framebuffer.getGLFramebuffer())t.framebuffer.create(e[0],e[1]),t.framebuffer.populateFramebuffer();else{const n=t.framebuffer.getSize();n&&n[0]===e[0]&&n[1]===e[1]||(t.framebuffer.create(e[0],e[1]),t.framebuffer.populateFramebuffer())}t.framebuffer.bind();const r=t.context;r.clearColor(0,0,0,0),r.colorMask(!0,!0,!0,!0),r.clear(r.COLOR_BUFFER_BIT),r.viewport(0,0,t._smallViewportWidth,t._smallViewportHeight),t.fvp=[t._smallViewportWidth/e[0],t._smallViewportHeight/e[1]]}t.context.disable(t.context.DEPTH_TEST),e.updateBufferObjects(n,r);const a=r.getProperties();t.currentValidInputs.forEach((e=>{let{inputIndex:n}=e;const r=a[n].getInterpolationType(),o=t.scalarTextures[n];r===Yf.NEAREST?(o.setMinificationFilter(ud.NEAREST),o.setMagnificationFilter(ud.NEAREST)):(o.setMinificationFilter(ud.LINEAR),o.setMagnificationFilter(ud.LINEAR))})),null!==t.zBufferTexture&&t.zBufferTexture.activate()},e.renderPieceDraw=(n,r)=>{const o=t.context,a=[...t.scalarTextures,t.colorTexture,t.opacityTexture,t.labelOutlineThicknessTexture,t.jitterTexture];a.forEach((e=>e.activate())),e.updateShaders(t.tris,n,r),o.drawArrays(o.TRIANGLES,0,t.tris.getCABO().getElementCount()),t.tris.getVAO().release(),a.forEach((e=>e.deactivate()))},e.renderPieceFinish=(e,n)=>{if(null!==t.zBufferTexture&&t.zBufferTexture.deactivate(),t._useSmallViewport){if(t.framebuffer.restorePreviousBindingsAndBuffers(),null===t.copyShader){t.copyShader=t._openGLRenderWindow.getShaderCache().readyShaderProgramArray([&quot;//VTK::System::Dec&quot;,&quot;attribute vec4 vertexDC;&quot;,&quot;uniform vec2 tfactor;&quot;,&quot;varying vec2 tcoord;&quot;,&quot;void main() { tcoord = vec2(vertexDC.x*0.5 + 0.5, vertexDC.y*0.5 + 0.5) * tfactor; gl_Position = vertexDC; }&quot;].join(&quot;\\n&quot;),[&quot;//VTK::System::Dec&quot;,&quot;//VTK::Output::Dec&quot;,&quot;uniform sampler2D texture1;&quot;,&quot;varying vec2 tcoord;&quot;,&quot;void main() { gl_FragData[0] = texture2D(texture1,tcoord); }&quot;].join(&quot;\\n&quot;),&quot;&quot;);const e=t.copyShader;t.copyVAO=od.newInstance(),t.copyVAO.setOpenGLRenderWindow(t._openGLRenderWindow),t.tris.getCABO().bind(),t.copyVAO.addAttributeArray(e,t.tris.getCABO(),&quot;vertexDC&quot;,t.tris.getCABO().getVertexOffset(),t.tris.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE)||rg(&quot;Error setting vertexDC in copy shader VAO.&quot;)}else t._openGLRenderWindow.getShaderCache().readyShaderProgram(t.copyShader);const e=t._openGLRenderWindow.getFramebufferSize();t.context.viewport(0,0,e[0],e[1]);const n=t.framebuffer.getColorTexture();n.activate(),t.copyShader.setUniformi(&quot;texture&quot;,n.getTextureUnit()),t.copyShader.setUniform2f(&quot;tfactor&quot;,t.fvp[0],t.fvp[1]);const r=t.context;r.blendFuncSeparate(r.ONE,r.ONE_MINUS_SRC_ALPHA,r.ONE,r.ONE_MINUS_SRC_ALPHA),t.context.drawArrays(t.context.TRIANGLES,0,t.tris.getCABO().getElementCount()),n.deactivate(),r.blendFuncSeparate(r.SRC_ALPHA,r.ONE_MINUS_SRC_ALPHA,r.ONE,r.ONE_MINUS_SRC_ALPHA)}},e.renderPiece=(n,r)=>{e.invokeEvent({type:&quot;StartEvent&quot;}),t.renderable.update();const o=t.renderable.getNumberOfInputPorts();t.currentValidInputs=[];for(let e=0;e<o;++e){const n=t.renderable.getInputData(e);n&&!n.isDeleted()&&t.currentValidInputs.push({imageData:n,inputIndex:e})}let a=0;if(t.currentValidInputs.length>0){const e=r.getProperties(),o=t.currentValidInputs[0],i=o.imageData.getPointData().getScalars(),s=e[o.inputIndex];s.getShade()&&t.renderable.getBlendMode()===eg.COMPOSITE_BLEND&&n.getLights().forEach((e=>{e.getSwitch()>0&&a++}));const l=t.currentValidInputs.length,c=l>1;t.numberOfComponents=c?l:i.getNumberOfComponents(),t.useIndependentComponents=function(e,t){const n=e.getIndependentComponents(),r=e.getColorMixPreset();return n&&t>=2||!!r}(s,t.numberOfComponents)}a!==t.numberOfLights&&(t.numberOfLights=a,e.modified()),e.invokeEvent({type:&quot;EndEvent&quot;}),0!==t.currentValidInputs.length&&(e.renderPieceStart(n,r),e.renderPieceDraw(n,r),e.renderPieceFinish(n,r))},e.updateBufferObjects=(t,n)=>{e.getNeedToRebuildBufferObjects(t,n)&&e.buildBufferObjects(t,n)},e.getNeedToRebuildBufferObjects=(n,r)=>t.VBOBuildTime.getMTime()<e.getMTime()||t.VBOBuildTime.getMTime()<r.getMTime()||t.VBOBuildTime.getMTime()<r.getProperty(t.currentValidInputs[0].inputIndex)?.getMTime()||t.VBOBuildTime.getMTime()<t.renderable.getMTime()||t.currentValidInputs.some((e=>{let{imageData:n}=e;return t.VBOBuildTime.getMTime()<n.getMTime()}))||t.scalarTextures.length!==t.currentValidInputs.length||!t.scalarTextures.every((e=>!!e?.getHandle()))||!t.colorTexture?.getHandle()||!t.opacityTexture?.getHandle()||!t.labelOutlineThicknessTexture?.getHandle()||!t.jitterTexture?.getHandle(),e.buildBufferObjects=(n,r)=>{if(!t.jitterTexture.getHandle()){const e=new Float32Array(1024);for(let t=0;t<1024;++t)e[t]=Math.random();t.jitterTexture.setMinificationFilter(ud.NEAREST),t.jitterTexture.setMagnificationFilter(ud.NEAREST),t.jitterTexture.create2DFromRaw({width:32,height:32,numComps:1,dataType:cs.FLOAT,data:e})}const a=r.getProperties(),i=t.currentValidInputs[0],s=a[i.inputIndex],l=t.numberOfComponents,c=t.useIndependentComponents,u=c?l:1,d=[];for(let e=0;e<u;++e)d.push(s.getScalarOpacity(e));const p=wf(d,c,u),f=s.getScalarOpacity(),g=t._openGLRenderWindow.getGraphicsResourceForObject(f);if(g?.oglObject?.getHandle()&&g.hash===p)t.opacityTexture=g.oglObject;else{const r=Pd.newInstance();r.setOpenGLRenderWindow(t._openGLRenderWindow);let o=t.renderable.getOpacityTextureWidth();o<=0&&(o=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const a=2*o*u,i=new Float32Array(a),l=new Float32Array(o);for(let t=0;t<u;++t){const r=s.getScalarOpacity(t),a=e.getCurrentSampleDistance(n)/s.getScalarOpacityUnitDistance(t),c=r.getRange();r.getTable(c[0],c[1],o,l,1);for(let e=0;e<o;++e)i[t*o*2+e]=1-(1-l[e])**a,i[t*o*2+e+o]=i[t*o*2+e]}if(r.resetFormatAndType(),r.setMinificationFilter(ud.LINEAR),r.setMagnificationFilter(ud.LINEAR),t._openGLRenderWindow.getWebgl2()||t.context.getExtension(&quot;OES_texture_float&quot;)&&t.context.getExtension(&quot;OES_texture_float_linear&quot;))r.create2DFromRaw({width:o,height:2*u,numComps:1,dataType:cs.FLOAT,data:i});else{const e=new Uint8ClampedArray(a);for(let t=0;t<a;++t)e[t]=255*i[t];r.create2DFromRaw({width:o,height:2*u,numComps:1,dataType:cs.UNSIGNED_CHAR,data:e})}f&&t._openGLRenderWindow.setGraphicsResourceForObject(f,r,p),t.opacityTexture=r}o(t._openGLRenderWindow,t._opacityTextureCore,f),t._opacityTextureCore=f;const m=[];for(let e=0;e<u;++e)m.push(s.getRGBTransferFunction(e));const h=wf(m,c,u),v=s.getRGBTransferFunction(),T=t._openGLRenderWindow.getGraphicsResourceForObject(v);if(T?.oglObject?.getHandle()&&T?.hash===h)t.colorTexture=T.oglObject;else{const e=Pd.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow);let n=t.renderable.getColorTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=new Uint8ClampedArray(2*n*u*3),o=new Float32Array(3*n);for(let e=0;e<u;++e){const t=s.getRGBTransferFunction(e),a=t.getRange();t.getTable(a[0],a[1],n,o,1);for(let t=0;t<3*n;++t)r[e*n*6+t]=255*o[t],r[e*n*6+t+3*n]=255*o[t]}e.resetFormatAndType(),e.setMinificationFilter(ud.LINEAR),e.setMagnificationFilter(ud.LINEAR),e.create2DFromRaw({width:n,height:2*u,numComps:3,dataType:cs.UNSIGNED_CHAR,data:r}),t._openGLRenderWindow.setGraphicsResourceForObject(v,e,h),t.colorTexture=e}o(t._openGLRenderWindow,t._colorTextureCore,v),t._colorTextureCore=v,t.currentValidInputs.forEach(((e,n)=>{let{imageData:r,inputIndex:i}=e;const s=a[i],l=r.getPointData().getScalars(),c=t._openGLRenderWindow.getGraphicsResourceForObject(l),u=Of(0,l),d=!c?.oglObject?.getHandle()||c?.hash!==u,p=s.getUpdatedExtents(),f=!!p.length;if(d&&!f){const e=Pd.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow);const o=r.getDimensions();e.setOglNorm16Ext(t.context.getExtension(&quot;EXT_texture_norm16&quot;)),e.resetFormatAndType(),e.create3DFilterableFromDataArray({width:o[0],height:o[1],depth:o[2],dataArray:l,preferSizeOverAccuracy:s.getPreferSizeOverAccuracy()}),t._openGLRenderWindow.setGraphicsResourceForObject(l,e,u),t.scalarTextures[n]=e}else t.scalarTextures[n]=c.oglObject;if(f){s.setUpdatedExtents([]);const e=r.getDimensions();t.scalarTextures[n].create3DFilterableFromDataArray({width:e[0],height:e[1],depth:e[2],dataArray:l,updatedExtents:p})}o(t._openGLRenderWindow,t._scalarTexturesCore[n],l),t._scalarTexturesCore[n]=l}));const y=s.getLabelOutlineThickness(),b=t._openGLRenderWindow.getGraphicsResourceForObject(y),x=y.join(&quot;-&quot;);if(b?.oglObject?.getHandle()&&b?.hash===x)t.labelOutlineThicknessTexture=b.oglObject;else{const e=Pd.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow);let n=t.renderable.getLabelOutlineTextureWidth();n<=0&&(n=t.context.getParameter(t.context.MAX_TEXTURE_SIZE));const r=1,o=new Uint8Array(n*r);for(let e=0;e<n;++e){const t=void 0!==y[e]?y[e]:y[0];o[e]=t}e.resetFormatAndType(),e.setMinificationFilter(ud.NEAREST),e.setMagnificationFilter(ud.NEAREST),e.create2DFromRaw({width:n,height:r,numComps:1,dataType:cs.UNSIGNED_CHAR,data:o}),y&&t._openGLRenderWindow.setGraphicsResourceForObject(y,e,x),t.labelOutlineThicknessTexture=e}if(o(t._openGLRenderWindow,t._labelOutlineThicknessTextureCore,y),t._labelOutlineThicknessTextureCore=y,!t.tris.getCABO().getElementCount()){const e=new Float32Array(12);for(let t=0;t<4;t++)e[3*t]=t%2*2-1,e[3*t+1]=t>1?1:-1,e[3*t+2]=-1;const n=new Uint16Array(8);n[0]=3,n[1]=0,n[2]=1,n[3]=3,n[4]=3,n[5]=0,n[6]=3,n[7]=2;const r=xs.newInstance({numberOfComponents:3,values:e});r.setName(&quot;points&quot;);const o=xs.newInstance({numberOfComponents:1,values:n});t.tris.getCABO().createVBO(o,&quot;polys&quot;,Zi.SURFACE,{points:r,cellOffset:0})}t.VBOBuildTime.modified()}}(e,t)}),&quot;vtkOpenGLVolumeMapper&quot;);Jt(&quot;vtkVolumeMapper&quot;,ig);const{vtkDebugMacro:sg}=Ht,lg={};const cg=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,lg,n),qt.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLPixelSpaceCallbackMapper&quot;),e.opaquePass=(n,r)=>{t._openGLRenderer=e.getFirstAncestorOfType(&quot;vtkOpenGLRenderer&quot;),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;);const o=t._openGLRenderer.getAspectRatio(),a=t._openGLRenderer?t._openGLRenderer.getRenderable().getActiveCamera():null,i=t._openGLRenderer.getTiledSizeAndOrigin();let s=null;if(t.renderable.getUseZValues()){const e=r.getZBufferTexture(),n=Math.floor(e.getWidth()),o=Math.floor(e.getHeight()),a=t._openGLRenderWindow.getContext();e.bind();const i=r.getFramebuffer();i?i.saveCurrentBindingsAndBuffers():sg(&quot;No framebuffer to save/restore&quot;);const l=a.createFramebuffer();a.bindFramebuffer(a.FRAMEBUFFER,l),a.framebufferTexture2D(a.FRAMEBUFFER,a.COLOR_ATTACHMENT0,a.TEXTURE_2D,e.getHandle(),0),a.checkFramebufferStatus(a.FRAMEBUFFER)===a.FRAMEBUFFER_COMPLETE&&(s=new Uint8Array(n*o*4),a.viewport(0,0,n,o),a.readPixels(0,0,n,o,a.RGBA,a.UNSIGNED_BYTE,s)),i&&i.restorePreviousBindingsAndBuffers(),a.deleteFramebuffer(l)}t.renderable.invokeCallback(t.renderable.getInputData(),a,o,i,s)},e.queryPass=(e,n)=>{e&&t.renderable.getUseZValues()&&n.requestDepth()}}(e,t)}),&quot;vtkOpenGLPixelSpaceCallbackMapper&quot;);Jt(&quot;vtkPixelSpaceCallbackMapper&quot;,cg);var ug=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtktextureObjectVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n\\nattribute vec4 vertexDC;\\nattribute vec2 tcoordDC;\\nvarying vec2 tcoordVC;\\n\\nvoid main()\\n{\\n  tcoordVC = tcoordDC;\\n  gl_Position = vertexDC;\\n}\\n&quot;;const{Representation:dg}=os;function pg(e,t,n,r){let[o,a]=t;const i=e.getContext(),s=Pd.newInstance({autoParameters:!1,wrapS:r,wrapT:r,minificationFilter:n,magnificationFilter:n,generateMipmap:!1,openGLDataType:i.FLOAT,baseLevel:0,maxLevel:0});return s.setOpenGLRenderWindow(e),s.setInternalFormat(i.RGBA32F),s.create2DFromRaw({width:o,height:a,numComps:4,dataType:&quot;Float32Array&quot;,data:null}),s.activate(),s.sendParameters(),s.deactivate(),s}function fg(e,t){return pg(e,t,Pd.Filter.NEAREST,Pd.Wrap.CLAMP_TO_EDGE)}const gg={vectorTexture:null,maskVectorTexture:null,noiseTexture:null,doEEPass:!1,doVTPass:!1,readIndex:0,quad:null,lastProgramHash:null,framebuffer:null,size:null,pingTextures:[],pongTextures:[],textures:[]};function mg(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,gg,n),Wt.obj(e,t),Wt.get(e,t,[&quot;readIndex&quot;]),Wt.setGet(e,t,[&quot;doEEPass&quot;,&quot;doVTPass&quot;,&quot;_openGLRenderWindow&quot;,&quot;vectorTexture&quot;,&quot;maskVectorTexture&quot;,&quot;noiseTexture&quot;,&quot;framebuffer&quot;,&quot;size&quot;]),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkLICPingPongBufferManager&quot;),t._openGLRenderWindow?(t.quad=function(e){const t=ld.newInstance();t.setOpenGLRenderWindow(e);const n=new Float32Array(12);for(let e=0;e<4;e++)n[3*e]=e%2*2-1,n[3*e+1]=e>1?1:-1,n[3*e+2]=0;const r=new Float32Array([0,0,1,0,0,1,1,1]),o=new Uint16Array(8);o[0]=3,o[1]=0,o[2]=1,o[3]=3,o[4]=3,o[5]=0,o[6]=3,o[7]=2;const a=xs.newInstance({numberOfComponents:3,values:n});a.setName(&quot;points&quot;);const i=xs.newInstance({numberOfComponents:1,values:o}),s=xs.newInstance({numberOfComponents:2,values:r});return t.getCABO().createVBO(i,&quot;polys&quot;,dg.SURFACE,{points:a,cellOffset:0,tcoords:s}),t}(t._openGLRenderWindow),t.context=t._openGLRenderWindow.getContext(),t.licTexture0=fg(t._openGLRenderWindow,t.size),t.seedTexture0=fg(t._openGLRenderWindow,t.size),t.licTexture1=fg(t._openGLRenderWindow,t.size),t.seedTexture1=fg(t._openGLRenderWindow,t.size),t.eeTexture=t.doEEPass?pg(t._openGLRenderWindow,t.size,Pd.Filter.NEAREST,Pd.Wrap.CLAMP_TO_EDGE):null,t.imageVectorTexture=t.doVTPass?(n=t._openGLRenderWindow,r=t.size,pg(n,r,Pd.Filter.LINEAR,Pd.Wrap.CLAMP_TO_EDGE)):null,t.pingTextures[0]=t.licTexture0,t.pingTextures[1]=t.seedTexture0,t.pongTextures[0]=t.licTexture1,t.pongTextures[1]=t.seedTexture1,t.textures[0]=t.pingTextures,t.textures[1]=t.pongTextures,e.swap=()=>{t.readIndex=1-t.readIndex},e.renderQuad=(e,n)=>{const r=t.quad,o=t.context;let a=t.quadVAO;a||(a=od.newInstance(),a.setOpenGLRenderWindow(t._openGLRenderWindow),t.quadVAO=a),t.previousProgramHash!==n.getMd5Hash()&&(a.shaderProgramChanged(),r.getCABO().bind(),a.addAttributeArray(n,r.getCABO(),&quot;vertexDC&quot;,r.getCABO().getVertexOffset(),r.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE),a.addAttributeArray(n,r.getCABO(),&quot;tcoordDC&quot;,r.getCABO().getTCoordOffset(),r.getCABO().getStride(),t.context.FLOAT,2,t.context.FALSE),t.previousProgramHash=n.getMd5Hash()),o.drawArrays(o.TRIANGLES,0,r.getCABO().getElementCount()),a.release()},e.getLastLICBuffer=()=>0===t.readIndex?t.licTexture0:t.licTexture1,e.getLastSeedBuffer=()=>0===t.readIndex?t.seedTexture0:t.seedTexture1,e.getLICBuffer=()=>1-t.readIndex==0?t.licTexture0:t.licTexture1,e.getSeedBuffer=()=>1-t.readIndex==0?t.seedTexture0:t.seedTexture1,e.getLICTextureUnit=()=>{const e=t.textures[t.readIndex][0];return e.activate(),e.getTextureUnit()},e.getSeedTextureUnit=()=>{const e=t.textures[t.readIndex][1];return e.activate(),e.getTextureUnit()},e.getNoiseTextureUnit=function(){return 0===(arguments.length>0&&void 0!==arguments[0]?arguments[0]:0)?(t.noiseTexture.activate(),t.noiseTexture.getTextureUnit()):(t.eeTexture.activate(),t.eeTexture.getTextureUnit())},e.getVectorTextureUnit=()=>(t.vectorTexture.activate(),t.vectorTexture.getTextureUnit()),e.getImageVectorTextureUnit=()=>t.imageVectorTexture?(t.imageVectorTexture.activate(),t.imageVectorTexture.getTextureUnit()):e.getVectorTextureUnit(),e.getMaskVectorTextureUnit=()=>t.maskVectorTexture?(t.maskVectorTexture.activate(),t.maskVectorTexture.getTextureUnit()):e.getImageVectorTextureUnit(),e.clearBuffers=function(){let e=arguments.length>0&&void 0!==arguments[0]&&arguments[0];const n=t.framebuffer,r=t.context;n.removeColorBuffer(0),n.removeColorBuffer(1),n.removeColorBuffer(2),n.removeColorBuffer(3),n.setColorBuffer(t.licTexture0,0),n.setColorBuffer(t.seedTexture0,1),n.setColorBuffer(t.licTexture1,2),n.setColorBuffer(t.seedTexture1,3);const o=[r.COLOR_ATTACHMENT0,r.COLOR_ATTACHMENT1,r.COLOR_ATTACHMENT2,r.COLOR_ATTACHMENT3];e&&(n.removeColorBuffer(4),n.setColorBuffer(t.eeTexture,4),o.push(r.COLOR_ATTACHMENT4)),r.drawBuffers(o),r.clearColor(0,1,0,0),r.disable(r.SCISSOR_TEST),r.disable(r.BLEND),r.clear(r.COLOR_BUFFER_BIT),n.removeColorBuffer(0),n.removeColorBuffer(1),n.removeColorBuffer(2),n.removeColorBuffer(3),e&&n.removeColorBuffer(4),r.drawBuffers([r.NONE])},e.clearBuffer=e=>{const n=t.framebuffer,r=t.context;n.removeColorBuffer(0),n.setColorBuffer(e,0),r.drawBuffers([r.COLOR_ATTACHMENT0]),r.clearColor(0,1,0,0),r.disable(r.SCISSOR_TEST),r.disable(r.BLEND),r.clear(r.COLOR_BUFFER_BIT),n.removeColorBuffer(e,0),r.drawBuffers([r.NONE])},e.activateVectorTextures=()=>{t.imageVectorTexture?t.imageVectorTexture.activate():t.vectorTexture.activate(),t.maskVectorTexture&&t.maskVectorTexture.activate()},e.deactivateVectorTextures=()=>{t.imageVectorTexture?t.imageVectorTexture.deactivate():t.vectorTexture.deactivate(),t.maskVectorTexture&&t.maskVectorTexture.deactivate()},e.activateNoiseTexture=function(){switch(arguments.length>0&&void 0!==arguments[0]?arguments[0]:0){case 0:t.noiseTexture.activate();break;case 1:t.eeTexture.activate();break;default:console.error(&quot;Wrong LIC pass number&quot;)}},e.deactivateNoiseTexture=function(){switch(arguments.length>0&&void 0!==arguments[0]?arguments[0]:0){case 0:t.noiseTexture.deactivate();break;case 1:t.eeTexture.deactivate();break;default:console.error(&quot;Wrong LIC pass number&quot;)}},e.attachLICBuffers=()=>{const e=t.textures[t.readIndex],n=t.textures[1-t.readIndex],r=t.framebuffer,o=t.context;e[0].activate(),e[1].activate(),r.removeColorBuffer(0),r.removeColorBuffer(1),r.setColorBuffer(n[0],0),r.setColorBuffer(n[1],1),o.drawBuffers([o.COLOR_ATTACHMENT0,o.COLOR_ATTACHMENT1])},e.detachLICBuffers=()=>{const e=t.textures[t.readIndex],n=t.context,r=t.framebuffer;e[0].deactivate(),e[1].deactivate(),r.removeColorBuffer(0),r.removeColorBuffer(1),n.drawBuffers([n.NONE])},e.attachImageVectorBuffer=()=>{const e=t.framebuffer,n=t.context;t.vectorTexture.activate(),e.removeColorBuffer(0),e.setColorBuffer(t.imageVectorTexture,0),n.drawBuffers([n.COLOR_ATTACHMENT0])},e.detachImageVectorBuffer=()=>{const e=t.context,n=t.framebuffer;t.vectorTexture.deactivate(),n.removeColorBuffer(0),e.drawBuffers([e.NONE])},e.attachEEBuffer=()=>{t.textures[t.readIndex][0].activate(),t.framebuffer.removeColorBuffer(0),t.framebuffer.setColorBuffer(t.eeTexture,0);const e=t.context;e.drawBuffers([e.COLOR_ATTACHMENT0])},e.detachEEBuffer=()=>{const e=t.context;t.framebuffer.removeColorBuffer(0),e.drawBuffers([e.NONE]),t.textures[t.readIndex][0].deactivate()},e.detachBuffers=()=>{const e=t.context,n=t.framebuffer;n.removeColorBuffer(0),n.removeColorBuffer(1),e.drawBuffers([e.NONE]);const r=t.textures[t.readIndex],o=t.textures[1-t.readIndex];r[0]&&r[0].deactivate(),r[1]&&r[1].deactivate(),o[0]&&o[0].deactivate(),o[1]&&o[1].deactivate(),t.eeTexture&&t.eeTexture.deactivate(),t.noiseTexture&&t.noiseTexture.deactivate()},e.getWriteIndex=()=>1-t.readIndex,e.detachBuffers()):console.error(&quot;Pass renderwindow to ping pong manager&quot;);var n,r}(e,t)}var hg={newInstance:Wt.newInstance(mg,&quot;vtkLICPingPongBufferManager&quot;),extend:mg};const vg=0,Tg=1,yg=2,bg=3,xg=1,Cg={shadersNeedBuild:!0,stepSize:1,numberOfSteps:10,enhancedLIC:!0,enhanceContrast:!1,lowContrastEnhancementFactor:0,highContrastEnhancementFactor:0,antiAlias:0,componentIds:[0,1],normalizeVectors:!0,maskThreshold:0,transformVectors:!0,bufs:null,isComposite:!0};function Sg(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Cg,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;context&quot;,&quot;_openGLRenderWindow&quot;,&quot;nuberOfSteps&quot;,&quot;stepSize&quot;,&quot;normalizeVectors&quot;,&quot;maskThreshold&quot;,&quot;enhancedLIC&quot;,&quot;enhanceContrast&quot;,&quot;lowLICContrastEnhancementFactor&quot;,&quot;highLICContrastEnhancementFactor&quot;,&quot;antiAlias&quot;,&quot;componentIds&quot;,&quot;isComposite&quot;]),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){function n(e,t){e.setUniformi(&quot;texLIC&quot;,t.getLICTextureUnit()),e.setUniformi(&quot;texSeedPts&quot;,t.getSeedTextureUnit())}function r(e,t,n){e.attachLICBuffers(),e.renderQuad(t,n),e.detachLICBuffers(),e.swap()}t.classHierarchy.push(&quot;vtkLineIntegralConvolution2D&quot;),e.buildAShader=e=>t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(ug,e,&quot;&quot;),e.dumpTextureValues=function(e,n){let[r,o]=n,a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:t.context,i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:t._openGLRenderWindow,s=arguments.length>4&&void 0!==arguments[4]?arguments[4]:4;const l=Sp.newInstance(),c=a;let u=null;return l.setOpenGLRenderWindow(i),l.saveCurrentBindingsAndBuffers(),l.create(r,o),l.populateFramebuffer(),l.setColorBuffer(e),u=new Float32Array(r*o*s),c.readPixels(0,0,r,o,4===s?c.RGBA:c.RGB,c.FLOAT,u),l.restorePreviousBindingsAndBuffers(),u},e.getTextureMinMax=function(n,r){let o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:t.context,a=arguments.length>3&&void 0!==arguments[3]?arguments[3]:t._openGLRenderWindow;const i=e.dumpTextureValues(n,r,o,a,4);let s=Number.MAX_VALUE,l=Number.MIN_VALUE;for(let e=0;e<i.length;e+=4)if(0===i[e+1]){const t=i[e];t<s&&(s=t),t>l&&(l=t)}return{min:s,max:l}},e.getComponentSelectionProgram=e=>{const t=&quot;xyzw&quot;;return`.${t[e[0]]}${t[e[1]]}`},e.buildShaders=()=>{t.LIC0ShaderProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_LIC0.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n/**\\nThis shader initializes the convolution for the LIC computation.\\n*/\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\nuniform sampler2D texMaskVectors;\\nuniform sampler2D texNoise;\\nuniform sampler2D texLIC;\\n\\nuniform int   uStepNo;         // in step 0 initialize lic and seeds, else just seeds\\nuniform int   uPassNo;         // in pass 1 hpf of pass 0 is convolved.\\nuniform float uMaskThreshold;  // if |V| < uMaskThreshold render transparent\\nuniform vec2  uNoiseBoundsPt1; // tc of upper right pt of noise texture\\n\\nin vec2 tcoordVC;\\n\\n// convert from vector coordinate space to noise coordinate space.\\n// the noise texture is tiled across the *whole* domain\\nvec2 VectorTCToNoiseTC(vec2 vectc)\\n{\\n  return vectc/uNoiseBoundsPt1;\\n}\\n\\n// get the texture coordidnate to lookup noise value. this\\n// depends on the pass number.\\nvec2 getNoiseTC(vec2 vectc)\\n{\\n  // in pass 1 : convert from vector tc to noise tc\\n  // in pass 2 : use vector tc\\n  if (uPassNo == 0)\\n    {\\n    return VectorTCToNoiseTC(vectc);\\n    }\\n  else\\n    {\\n    return vectc;\\n    }\\n}\\n\\n// look up noise value at the given location. The location\\n// is supplied in vector texture coordinates, hence the\\n// need to convert to noise texture coordinates.\\nfloat getNoise(vec2 vectc)\\n{\\n  return texture2D(texNoise, getNoiseTC(vectc)).r;\\n}\\n\\nvoid main(void)\\n{\\n  vec2 vectc = tcoordVC.st;\\n\\n  // lic => (convolution, mask, 0, step count)\\n  if (uStepNo == 0)\\n    {\\n    float maskCriteria = length(texture2D(texMaskVectors, vectc).xyz);\\n    float maskFlag;\\n    if (maskCriteria <= uMaskThreshold)\\n      {\\n      maskFlag = 1.0;\\n      }\\n    else\\n      {\\n      maskFlag = 0.0;\\n      }\\n    float noise = getNoise(vectc);\\n    LICOutput = vec4(noise, maskFlag, 0.0, 1.0);\\n    }\\n  else\\n    {\\n    LICOutput = texture2D(texLIC, vectc);\\n    }\\n\\n  // initial seed\\n  SeedOutput = vec4(vectc, 0.0, 1.0);\\n}\\n&quot;);const n=td.substitute(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_VT.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// move vector field to normalized image space\\n// pre-processing for vtkLineIntegralConvolution2D\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\n// Fragment shader used by the gaussian blur filter render pass.\\n\\nuniform sampler2D texVectors; // input texture\\nuniform vec2      uTexSize;   // size of texture\\n\\nin vec2 tcoordVC;\\n\\nvoid main(void)\\n{\\n  //VTK::LICComponentSelection::Impl\\n  V = V/uTexSize;\\n  gl_FragData[0] = vec4(V, 0.0, 1.0);\\n}\\n&quot;,&quot;//VTK::LICComponentSelection::Impl&quot;,`vec2 V = texture2D(texVectors, tcoordVC.st)${e.getComponentSelectionProgram(t.componentIds)};`).result;t.VTProgram=e.buildAShader(n);const r=td.substitute(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_fs1.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\nuniform sampler2D  texVectors;\\nuniform sampler2D  texNoise;\\nuniform sampler2D  texLIC;\\nuniform sampler2D  texSeedPts;\\n\\nuniform int   uPassNo;          // in pass 1 hpf of pass 0 is convolved.\\nuniform float uStepSize;        // step size in parametric space\\n\\nuniform vec2  uNoiseBoundsPt1;  // tc of upper right pt of noise texture\\n\\nin vec2 tcoordVC;\\n\\n//VTK::LICVectorLookup::Impl\\n\\n// We need to do this manually since CLAMP_TO_BORDER and and borderColor\\n// are very poorly supported in webgl\\nvec2 clampToBorder(vec2 uv){\\n  if(uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0)\\n  {\\n    return vec2(0.0, 0.0);\\n  }\\n  return getVector(uv);\\n}\\n\\n// convert from vector coordinate space to noise coordinate space.\\n// the noise texture is tiled across the whole domain\\nvec2 VectorTCToNoiseTC(vec2 vectc)\\n{\\n  return vectc/uNoiseBoundsPt1;\\n}\\n\\n// get the texture coordidnate to lookup noise value.\\n// in pass 1 repeatedly tile the noise texture across\\n// the computational domain.\\nvec2 getNoiseTC(vec2 tc)\\n{\\n  if (uPassNo == 0)\\n    {\\n    return VectorTCToNoiseTC(tc);\\n    }\\n  else\\n    {\\n    return tc;\\n    }\\n}\\n\\n// look up noise value at the given location. The location\\n// is supplied in vector texture coordinates, hence the need\\n// to convert to either noise or lic texture coordinates in\\n// pass 1 and 2 respectively.\\nfloat getNoise(vec2 vectc)\\n{\\n  return texture2D(texNoise, getNoiseTC(vectc)).r;\\n}\\n\\n// fourth-order Runge-Kutta streamline integration\\n// no bounds checks are made, therefore it's essential\\n// to have the entire texture initialized to 0\\n// and set clamp to border and have border color 0\\n// an integer is set if the step was taken, keeping\\n// an accurate step count is necessary to prevent\\n// boundary artifacts. Don't count the step if\\n// all vector lookups are identically 0. This is\\n// a proxy for \\&quot;stepped outside valid domain\\&quot;\\nvec2 rk4(vec2 pt0, float dt, out bool count)\\n{\\n  count=true;\\n  float dtHalf = dt * 0.5;\\n  vec2 pt1;\\n\\n  vec2 v0 = clampToBorder(pt0);\\n  pt1 = pt0 + v0 * dtHalf;\\n\\n  vec2 v1 = clampToBorder(pt1);\\n  pt1 = pt0 + v1 * dtHalf;\\n\\n  vec2 v2 = clampToBorder(pt1);\\n  pt1 = pt0 + v2 * dt;\\n\\n  vec2 v3 = clampToBorder(pt1);\\n  vec2 vSum = v0 + v1 + v1 + v2 + v2 + v3;\\n\\n  if (vSum == vec2(0.0, 0.0))\\n    {\\n      count = false;\\n    }\\n\\n  pt1 = pt0 + (vSum) * (dt * (1.0/6.0));\\n\\n return pt1;\\n}\\n\\nvoid main(void)\\n{\\n  vec2 lictc = tcoordVC.st;\\n  vec4 lic = texture2D(texLIC, lictc);\\n  vec2 pt0 = texture2D(texSeedPts, lictc).st;\\n\\n  bool count;\\n  vec2 pt1 = rk4(pt0, uStepSize, count);\\n\\n  if (count)\\n    {\\n    // accumulate lic step\\n    // (lic, mask, 0, step count)\\n    float noise = getNoise(pt1);\\n    LICOutput = vec4(lic.r + noise, lic.g, 0.0, lic.a + 1.0);\\n    SeedOutput = vec4(pt1, 0.0, 1.0);\\n    }\\n  else\\n    {\\n    // keep existing values\\n    LICOutput = lic;\\n    SeedOutput = vec4(pt0, 0.0, 1.0);\\n    }\\n}\\n&quot;,&quot;//VTK::LICVectorLookup::Impl&quot;,function(){return arguments.length>0&&void 0!==arguments[0]&&!arguments[0]?&quot;\\n    vec2 getVector( vec2 vectc )\\n\\n      {\\n\\n      return texture2D( texVectors, vectc ).xy;\\n\\n      }\\n\\n    &quot;:&quot;\\n    vec2 getVector( vec2 vectc )\\n\\n      {\\n\\n      vec2 V = texture2D( texVectors, vectc ).xy;\\n\\n      // normalize if |V| not 0\\n\\n      float lenV = length( V );\\n\\n      if ( lenV > 1.0e-8 )\\n\\n        {\\n\\n        return V/lenV;\\n\\n        }\\n\\n      else\\n\\n        {\\n\\n        return vec2( 0.0, 0.0 );\\n\\n        }\\n\\n      }\\n\\n    &quot;}(t.normalizeVectors),!0).result;t.LICIShaderProgram=e.buildAShader(r),t.LICNShaderProgram=e.buildAShader(&quot; //VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_LICN.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\n/**\\nThis shader finalizes the convolution for the LIC computation\\napplying the normalization. eg. if box kernel is used the this\\nis the number of steps taken.\\n*/\\n\\nuniform sampler2D texLIC;\\n\\nin vec2 tcoordVC;\\n\\nvoid main(void)\\n{\\n  vec4 conv = texture2D(texLIC, tcoordVC.st);\\n  conv.r = conv.r/conv.a;\\n  // lic => (convolution, mask, 0, 1)\\n  LICOutput = vec4(conv.rg , 0.0, 1.0);\\n  SeedOutput = vec4(0.0, 0.0, 0.0, 0.0);\\n}\\n&quot;),t.CEProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_CE.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// gray scale contrast enhance stage implemented via histogram stretching\\n// if the min and max are tweaked it can generate out-of-range values\\n// these will be clamped in 0 to 1\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\n\\nuniform sampler2D texLIC;  // most recent lic pass\\nuniform float uMin;        // min gray scale color value\\nuniform float uMaxMinDiff; // max-min\\n\\nin vec2 tcoordVC;\\n\\nvoid main( void )\\n{\\n  vec4 lic = texture2D(texLIC, tcoordVC.st);\\n  if (lic.g!=0.0)\\n    {\\n    LICOutput = lic;\\n    }\\n  else\\n    {\\n    float CElic = clamp((lic.r - uMin)/uMaxMinDiff, 0.0, 1.0);\\n    LICOutput = vec4(CElic, lic.gb, 1.0);\\n    }\\n    SeedOutput = vec4(0.0, 0.0, 0.0, 0.0);\\n}\\n&quot;),t.EEProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_fs2.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// high-pass filter stage employed by vtkLineIntegralConvolution2D\\n// between LIC pass 1 and LIC pass 2. filtered LIC pass 1, becomes\\n// noise for pass2.\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 EEOutput;\\n\\nuniform sampler2D texLIC; // most recent lic pass\\nuniform float     uDx;    // fragment size\\nuniform float     uDy;    // fragment size\\n\\nin vec2 tcoordVC;\\n\\n// kernel for simple laplace edge enhancement.\\n// p=Laplace(p)+p\\nfloat K[9] = float[9](\\n  -1.0, -1.0, -1.0,\\n  -1.0,  9.0, -1.0,\\n  -1.0, -1.0, -1.0\\n  );\\n\\n// determine if the fragment was masked\\nbool Masked(float val) { return val != 0.0; }\\n\\nvoid main(void)\\n{\\n  // tex coord neighbor offsets\\n  vec2 fragDx[9] = vec2[9](\\n    vec2(-uDx, uDy), vec2(0.0, uDy), vec2(uDx, uDy),\\n    vec2(-uDx, 0.0), vec2(0.0, 0.0), vec2(uDx, 0.0),\\n    vec2(-uDx,-uDy), vec2(0.0,-uDy), vec2(uDx,-uDy)\\n    );\\n\\n  vec2 lictc = tcoordVC.st;\\n\\n  // compute the convolution but don't use convovled values if\\n  // any masked fragments on the stencil. Fragments outside\\n  // the valid domain are masked during initialization, and\\n  // texture wrap parameters are clamp to border with border\\n  // color that contains masked flag\\n  float conv = 0.0;\\n  bool dontUse = false;\\n  for (int i=0; i<9; ++i)\\n    {\\n    vec2 tc = lictc + fragDx[i];\\n    vec4 lic = texture2D(texLIC, tc);\\n    dontUse = dontUse || Masked(lic.g);\\n    conv = conv + K[i] * lic.r;\\n    }\\n\\n  if (dontUse)\\n    {\\n    EEOutput = vec4(texture2D(texLIC, lictc).rg, 0.0, 1.0);\\n    }\\n  else\\n    {\\n    conv = clamp(conv, 0.0, 1.0);\\n    EEOutput = vec4(conv,texture2D(texLIC, lictc).g, 0.0, 1.0);\\n    }\\n\\n}\\n&quot;),t.AAHProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_AAH.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// Anti-alias stage in vtkLineIntegralConvolution2D\\n// horizontal pass of a Gaussian convolution\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\nuniform sampler2D texLIC; // input texture\\nuniform float     uDx;    // fragment size\\n\\nin vec2 tcoordVC;\\n\\n// factored 3x3 Gaussian kernel\\n// K^T*K = G\\nfloat K[3] = float[3](0.141421356, 0.707106781, 0.141421356);\\n\\n// determine if the fragment was masked\\nbool Masked(float val){ return val != 0.0; }\\n\\nvoid main(void)\\n{\\n// neighbor offsets\\nvec2 fragDx[3] = vec2[3](vec2(-uDx,0.0), vec2(0.0,0.0), vec2(uDx,0.0));\\n\\n  vec2 lictc = tcoordVC.st;\\n  vec4 lic[3];\\n  bool dontUse = false;\\n  float conv = 0.0;\\n  for (int i=0; i<3; ++i)\\n    {\\n    vec2 tc = lictc + fragDx[i];\\n    lic[i] = texture2D(texLIC, tc);\\n    dontUse = dontUse || Masked(lic[i].g);\\n    conv = conv + K[i] * lic[i].r;\\n    }\\n  // output is (conv, mask, skip, 1)\\n  if (dontUse)\\n    {\\n    LICOutput = vec4(lic[1].rg, 1.0, 1.0);\\n    }\\n  else\\n    {\\n    LICOutput = vec4(conv, lic[1].gb, 1.0);\\n    }\\n  SeedOutput = vec4(0.0, 0.0, 0.0, 0.0);\\n}\\n&quot;),t.AAVProgram=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkLineIntegralConvolution2D_AAV.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// Anti-alias stage in vtkLineIntegralConvolution2D\\n// vertical pass of a Gaussian convolution\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 LICOutput;\\nlayout(location = 1) out vec4 SeedOutput;\\n\\nuniform sampler2D texLIC; // input texture\\nuniform float     uDy;    // fragment size\\n\\nin vec2 tcoordVC;\\n\\n\\n// factored 3x3 Gaussian kernel\\n// K^T*K = G\\nfloat K[3] = float[3](0.141421356, 0.707106781, 0.141421356);\\n\\n// determine if the fragment was masked\\nbool Masked(float val){ return val != 0.0; }\\n\\nvoid main(void)\\n{\\n// neighbor offsets\\nvec2 fragDy[3] = vec2[3](vec2(0.0,-uDy), vec2(0.0,0.0), vec2(0.0,uDy));\\n\\n\\n  vec2 lictc = tcoordVC.st;\\n  vec4 lic[3];\\n  bool dontUse = false;\\n  float conv = 0.0;\\n  for (int i=0; i<3; ++i)\\n    {\\n    vec2 tc = lictc + fragDy[i];\\n    lic[i] = texture2D(texLIC, tc);\\n    dontUse = dontUse || Masked(lic[i].g);\\n    conv = conv + K[i] * lic[i].r;\\n    }\\n  // output is (conv, mask, skip, 1)\\n  if (dontUse)\\n    {\\n    LICOutput = vec4(lic[1].rg, 1.0, 1.0);\\n    }\\n  else\\n    {\\n    LICOutput = vec4(conv, lic[1].gb, 1.0);\\n    }\\n  SeedOutput = vec4(0.0, 0.0, 0.0, 0.0);\\n}\\n&quot;)},e.executeLIC=(o,a,i,s,l,c)=>{if(t._openGLRenderWindow=l,t.context=l.getContext(),Object.assign(t,c),o[0]<=0||o[1]<=0)return null;const u=[1/o[0],1/o[1]];let d=t.stepSize*Math.sqrt(u[0]*u[0]+u[1]*u[1]);d<=0&&(d=1e-10);const p=t.context;let f=t.framebuffer;const g=f?.getSize();f&&g&&o[0]===g&&o[1]===g||(f=Sp.newInstance(),f.setOpenGLRenderWindow(t._openGLRenderWindow),f.saveCurrentBindingsAndBuffers(),f.create(...o),f.populateFramebuffer(),f.restorePreviousBindingsAndBuffers(),t.framebuffer=f),f.saveCurrentBindingsAndBuffers(),f.bind(),p.viewport(0,0,...o),p.scissor(0,0,...o),t.shadersNeedBuild&&(e.buildShaders(),t.shadersNeedBuild=!1),t.bufs?(t.bufs.setVectorTexture(a),t.bufs.setMaskVectorTexture(i),t.bufs.setNoiseTexture(s)):t.bufs=hg.newInstance({openGLRenderWindow:l,doEEPass:t.enhancedLIC,doVTPass:t.transformVectors,vectorTexture:a,maskVectorTexture:i,noiseTexture:s,framebuffer:f,size:o});const m=[(s.getWidth()+1)/o[0],(s.getHeight()+1)/o[1]],h=1/o[0],v=1/o[1],T=t._openGLRenderWindow.getShaderCache();if(t.transformVectors){const e=t.VTProgram;T.readyShaderProgram(e),t.bufs.attachImageVectorBuffer(),e.setUniform2f(&quot;uTexSize&quot;,...o),e.setUniformi(&quot;texVectors&quot;,t.bufs.getVectorTextureUnit()),p.clearColor(0,0,0,0),p.clear(p.COLOR_BUFFER_BIT),t.bufs.renderQuad(o,e),t.bufs.detachImageVectorBuffer()}t.bufs.clearBuffers(t.enhancedLIC),t.bufs.activateVectorTextures(),t.bufs.activateNoiseTexture(0);const{LIC0ShaderProgram:y}=t;T.readyShaderProgram(y),y.setUniformi(&quot;uStepNo&quot;,0),y.setUniformi(&quot;uPassNo&quot;,0),y.setUniformf(&quot;uMaskThreshold&quot;,t.maskThreshold),y.setUniform2f(&quot;uNoiseBoundsPt1&quot;,...m),y.setUniformi(&quot;texMaskVectors&quot;,t.bufs.getMaskVectorTextureUnit()),y.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),y.setUniformi(&quot;texNoise&quot;,t.bufs.getNoiseTextureUnit(0)),r(t.bufs,o,y);const{LICIShaderProgram:b}=t;T.readyShaderProgram(b),b.setUniformi(&quot;uPassNo&quot;,0),b.setUniformf(&quot;uStepSize&quot;,-d),b.setUniform2f(&quot;uNoiseBoundsPt1&quot;,...m),b.setUniformi(&quot;texVectors&quot;,t.bufs.getImageVectorTextureUnit()),b.setUniformi(&quot;texNoise&quot;,t.bufs.getNoiseTextureUnit(0));for(let e=0;e<t.numberOfSteps;++e)n(b,t.bufs),r(t.bufs,o,b);T.readyShaderProgram(y),y.setUniformi(&quot;uStepNo&quot;,1),n(y,t.bufs),r(t.bufs,o,y),T.readyShaderProgram(b),b.setUniformf(&quot;uStepSize&quot;,d);for(let e=0;e<t.numberOfSteps;++e)n(b,t.bufs),r(t.bufs,o,b);t.bufs.deactivateNoiseTexture(0),t.bufs.deactivateVectorTextures();const{LICNShaderProgram:x}=t;if(T.readyShaderProgram(x),x.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),r(t.bufs,o,x),t.enhancedLIC){t.enhanceContrast!==Tg&&t.enhanceContrast!==bg||e.contrastEnhance(!1,o),t.bufs.attachEEBuffer();const{EEProgram:a}=t;T.readyShaderProgram(a),a.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),a.setUniformf(&quot;uDx&quot;,h),a.setUniformf(&quot;uDy&quot;,v),t.bufs.renderQuad(o,a),t.bufs.detachEEBuffer(),t.bufs.detachBuffers(),t.bufs.clearBuffers(!1),t.bufs.activateVectorTextures(),t.bufs.activateNoiseTexture(1),T.readyShaderProgram(y),y.setUniformi(&quot;uStepNo&quot;,0),y.setUniformi(&quot;uPassNo&quot;,1),n(y,t.bufs),y.setUniformi(&quot;texNoise&quot;,t.bufs.getNoiseTextureUnit(1)),r(t.bufs,o,y),T.readyShaderProgram(b),b.setUniformi(&quot;uPassNo&quot;,1),b.setUniformf(&quot;uStepSize&quot;,-d),b.setUniformi(&quot;texNoise&quot;,t.bufs.getNoiseTextureUnit(1));const i=t.numberOfSteps/2;for(let e=0;e<i;++e)n(b,t.bufs),r(t.bufs,o,b);T.readyShaderProgram(y),y.setUniformi(&quot;uStepNo&quot;,1),n(y,t.bufs),r(t.bufs,o,y),T.readyShaderProgram(b),b.setUniformf(&quot;uStepSize&quot;,d);for(let e=0;e<i;++e)n(b,t.bufs),r(t.bufs,o,b);t.bufs.deactivateNoiseTexture(1),t.bufs.deactivateVectorTextures(),T.readyShaderProgram(x),x.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),x.setUniformi(&quot;texSeedPts&quot;,t.bufs.getSeedTextureUnit()),r(t.bufs,o,x)}if(t.antiAlias){const e=t.AAHProgram;T.readyShaderProgram(e),e.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),e.setUniformf(&quot;uDx&quot;,h);const a=t.AAVProgram;T.readyShaderProgram(a),a.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),a.setUniformf(&quot;uDy&quot;,v);for(let i=0;i<t.antiAlias;++i)T.readyShaderProgram(e),n(e,t.bufs),r(t.bufs,o,e),T.readyShaderProgram(a),n(a,t.bufs),r(t.bufs,o,a)}return t.enhanceContrast!==Tg&&t.enhanceContrast!==bg||e.contrastEnhance(!0,o),t.bufs.detachBuffers(),f.restorePreviousBindingsAndBuffers(),t.bufs.getLastLICBuffer()},e.contrastEnhance=(n,o)=>{const a=t._openGLRenderWindow.getShaderCache();let{min:i,max:s}=e.getTextureMinMax(t.bufs.getLastLICBuffer(),o,t.context,t._openGLRenderWindow);(s<=i||s>1||i<0)&&(console.error(&quot;Invalid color range: &quot;,i,s),i=0,s=1);let l=s-i;n&&(i+=l*t.lowLICContrastEnhancementFactor,s-=l*t.highLICContrastEnhancementFactor,l=s-i);const{CEProgram:c}=t;a.readyShaderProgram(c),c.setUniformi(&quot;texLIC&quot;,t.bufs.getLICTextureUnit()),c.setUniformf(&quot;uMin&quot;,i),c.setUniformf(&quot;uMaxMinDiff&quot;,l),r(t.bufs,o,c)}}(e,t)}var Ag={newInstance:Wt.newInstance(Sg,&quot;vtkLineIntegralConvolution2D&quot;),extend:Sg};const Ig={enableLIC:!1,nuberOfSteps:40,stepSize:.25,transformVectors:!0,normalizeVectors:!0,maskOnSurface:!1,maskThreshold:0,maskColor:[0,0,0],maskIntensity:0,enhancedLIC:!0,enhanceContrast:vg,lowLICContrastEnhancementFactor:0,highLICContrastEnhancementFactor:0,lowColorContrastEnhancementFactor:0,highColorContrastEnhancementFactor:0,antiAlias:0,colorMode:0,LICIntensity:1,mapModeBias:0,noiseTextureSize:200,noiseTextureType:xg,noiseGrainSize:8,noiseImpulseProbability:.1,noiseImpulseBackgroundValue:0,noiseGeneratorSeed:0,minNoiseValue:0,maxNoiseValue:1,numberOfNoiseLevels:2,shadersNeedBuilding:!0,reallocateTextures:!0,rebuildNoiseTexture:!1,viewPortScale:1};function wg(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ig,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;enableLIC&quot;,&quot;numberOfSteps&quot;,&quot;stepSize&quot;,&quot;normalizeVectors&quot;,&quot;transformVectors&quot;,&quot;maskOnSurface&quot;,&quot;maskThreshold&quot;,&quot;maskColor&quot;,&quot;maskIntensity&quot;,&quot;enhancedLIC&quot;,&quot;enhanceContrast&quot;,&quot;lowLICContrastEnhancementFactor&quot;,&quot;highLICContrastEnhancementFactor&quot;,&quot;lowColorContrastEnhancementFactor&quot;,&quot;highColorContrastEnhancementFactor&quot;,&quot;antiAlias&quot;,&quot;colorMode&quot;,&quot;LICIntensity&quot;,&quot;mapModeBias&quot;,&quot;noiseTextureSize&quot;,&quot;noiseTextureType&quot;,&quot;noiseGrainSize&quot;,&quot;minNoiseValue&quot;,&quot;maxNoiseValue&quot;,&quot;numberOfNoiseLevels&quot;,&quot;noiseImpulseProbability&quot;,&quot;noiseImpulseBackgroundValue&quot;,&quot;noiseGeneratorSeed&quot;,&quot;viewPortScale&quot;,&quot;rebuildNoiseTexture&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkSurfaceLICInterface&quot;)}(0,t)}var Og={newInstance:Wt.newInstance(wg,&quot;vtkSurfaceLICInterface&quot;),extend:wg};const{Representation:Pg}=os;const Rg={context:null,shadersNeedBuilding:!0,reallocateTextures:!0,size:null,licInterface:null};function Mg(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Rg,n),Og.extend(e,t,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;context&quot;,&quot;_openGLRenderWindow&quot;,&quot;reallocateTextures&quot;,&quot;licInterface&quot;,&quot;size&quot;]),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLSurfaceLICInterface&quot;),e.renderQuad=(e,n)=>{const r=t.licQuad,o=t.context;let a=t.licQuadVAO;a||(a=od.newInstance(),a.setOpenGLRenderWindow(t._openGLRenderWindow),t.licQuadVAO=a),t.previousProgramHash!==n.getMd5Hash()&&(a.shaderProgramChanged(),r.getCABO().bind(),a.addAttributeArray(n,r.getCABO(),&quot;vertexDC&quot;,r.getCABO().getVertexOffset(),r.getCABO().getStride(),t.context.FLOAT,3,t.context.FALSE),a.addAttributeArray(n,r.getCABO(),&quot;tcoordDC&quot;,r.getCABO().getTCoordOffset(),r.getCABO().getStride(),t.context.FLOAT,2,t.context.FALSE),t.previousProgramHash=n.getMd5Hash()),o.drawArrays(o.TRIANGLES,0,r.getCABO().getElementCount()),a.release()},e.generateNoiseTexture=e=>{if(!t.noiseTexture||t.licInterface.getRebuildNoiseTexture()){t.licInterface.setRebuildNoiseTexture(!1),t.noiseTexture&&t.noiseTexture.releaseGraphicsResources(),oo(t.noiseGeneratorSeed,{global:!0});let n=[];const{noiseTextureType:r,noiseGrainSize:o,numberOfNoiseLevels:a,noiseImpulseProbability:i,noiseImpulseBackgroundValue:s,minNoiseValue:l,maxNoiseValue:c}=t.licInterface.get(&quot;noiseTextureType&quot;,&quot;noiseGrainSize&quot;,&quot;numberOfNoiseLevels&quot;,&quot;noiseImpulseProbability&quot;,&quot;noiseImpulseBackgroundValue&quot;,&quot;minNoiseValue&quot;,&quot;maxNoiseValue&quot;);n=r===xg?function(e,t,n,r,o,a){const i=Math.max(0,Math.min(1,n)),s=Float32Array.from({length:e*e},(()=>{let e=0;if(1===i||Math.random()>1-i)for(let t=0;t<2048;++t)e+=Math.random();return e}));let l=0,c=2049;s.forEach((e=>{c=1===i?e<c?e:c:e<c&&e>0?e:c,l=e>l?e:l}));let u=l-c;0===u&&(c=0,u=0===l?1:l);const d=t-1,p=0!==d?1/d:0,f=a-o;return s.map((e=>{const n=e<c?e:(e-c)/u,i=Math.floor(n*t);return e>=c?1===t?a:o+(i>d?d:i)*p*f:r}))}(Math.floor(e/o),a,i,s,l,c):function(e,t,n,r){let[o,a]=e;const i=r-n;return Float32Array.from({length:o*a},(()=>{let e=Math.random();return e=Math.floor(e*t)/t,e=e*i+n,e>1?1:e<0?0:e}))}([Math.ceil(e/o),Math.ceil(e/o)],a,l,c);const u=1/o,d=Float32Array.from({length:e*e*4},((t,r)=>{const a=r/4;if(r%4==0){const t=Math.floor(a%e*u),r=Math.floor(a/e*u);return n[r*(e/o)+t]}return r%4==1||r%4==3?1:0})),p=Pd.newInstance({wrapS:Pd.Wrap.REPEAT,wrapT:Pd.Wrap.REPEAT,minificationFilter:Pd.Filter.NEAREST,magnificationFilter:Pd.Filter.NEAREST,generateMipMap:!1,openGLDataType:t.context.FLOAT,baseLevel:0,maxLevel:0,autoParameters:!1});p.setOpenGLRenderWindow(t._openGLRenderWindow),p.create2DFromRaw({width:e,height:e,numComps:4,dataType:&quot;Float32Array&quot;,data:d}),p.activate(),p.sendParameters(),p.deactivate(),t.noiseTexture=p}},e.buildAShader=e=>t._openGLRenderWindow.getShaderCache().readyShaderProgramArray(ug,e,&quot;&quot;),e.allocateTextures=()=>{const n=Pd.Filter.NEAREST,r=Pd.Filter.LINEAR,o=t._openGLRenderWindow;t.geometryImage||(t.geometryImage=e.allocateTexture(o,n)),t.vectorImage||(t.vectorImage=e.allocateTexture(o,r)),t.maskVectorImage||(t.maskVectorImage=e.allocateTexture(o,r)),t.LICImage||(t.LICImage=e.allocateTexture(o,n)),t.RGBColorImage||(t.RGBColorImage=e.allocateTexture(o,n)),t.HSLColorImage||(t.HSLColorImage=e.allocateTexture(o,n)),t.depthTexture||(t.depthTexture=e.allocateDepthTexture(o))},e.allocateTexture=(e,n)=>{const r=t.context,o=Pd.newInstance({wrapS:Pd.Wrap.CLAMP_TO_EDGE,wrapT:Pd.Wrap.CLAMP_TO_EDGE,minificationFilter:n,magnificationFilter:n,generateMipmap:!1,openGLDataType:r.FLOAT,baseLevel:0,maxLevel:0,autoParameters:!1});return o.setOpenGLRenderWindow(e),o.setInternalFormat(r.RGBA32F),o.create2DFromRaw({width:t.size[0],height:t.size[1],numComps:4,dataType:&quot;Float32Array&quot;,data:null}),o.activate(),o.sendParameters(),o.deactivate(),o},e.allocateDepthTexture=e=>{const n=t.context,r=Pd.newInstance({generateMipmap:!1,openGLDataType:n.FLOAT,autoParameters:!1});return r.setOpenGLRenderWindow(e),r.createDepthFromRaw({width:t.size[0],height:t.size[1],dataType:&quot;Float32Array&quot;,data:null}),r.activate(),r.sendParameters(),r.deactivate(),r},e.createFBO=()=>{if(!t.framebuffer){t.licHelper=null;const e=Sp.newInstance();e.setOpenGLRenderWindow(t._openGLRenderWindow),e.saveCurrentBindingsAndBuffers(),e.create(...t.size),e.populateFramebuffer(),t.framebuffer=e,e.restorePreviousBindingsAndBuffers()}},e.completedGeometry=()=>{const e=t.context,n=t.framebuffer;n.removeColorBuffer(0),n.removeColorBuffer(1),n.removeColorBuffer(2),n.removeDepthBuffer(),e.drawBuffers([e.NONE]),n.restorePreviousBindingsAndBuffers()},e.buildAllShaders=()=>{t.shadersNeedBuilding&&(t.licColorPass=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkSurfaceLICMapper_fs2.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// This shader combines surface geometry, LIC, and  scalar colors.\\n\\n// the output of this shader\\nlayout(location = 0) out vec4 RGBOutput;\\nlayout(location = 1) out vec4 HSLOutput;\\n\\nuniform sampler2D texVectors;       // vectors, depth\\nuniform sampler2D texGeomColors;    // scalar colors + lighting\\nuniform sampler2D texLIC;           // image lic\\nuniform int       uScalarColorMode; // select between blend, and map shader\\nuniform float     uLICIntensity;    // blend shader: blending factor for lic'd colors\\nuniform float     uMapBias;         // map shader: adjust the brightness of the result\\nuniform float     uMaskIntensity;   // blending factor for mask color\\nuniform vec3      uMaskColor;       // color for the masked out fragments\\n\\nin vec2 tcoordVC;\\n\\n/**\\nConvert from RGB color space into HSL colorspace.\\n*/\\nvec3 RGBToHSL(vec3 RGB)\\n{\\n  vec3 HSL = vec3(0.0, 0.0, 0.0);\\n\\n  float RGBMin = min(min(RGB.r, RGB.g), RGB.b);\\n  float RGBMax = max(max(RGB.r, RGB.g), RGB.b);\\n  float RGBMaxMinDiff = RGBMax - RGBMin;\\n\\n  HSL.z = (RGBMax + RGBMin) / 2.0;\\n\\n  if (RGBMaxMinDiff == 0.0)\\n    {\\n    // Gray scale\\n    HSL.x = 0.0;\\n    HSL.y = 0.0;\\n    }\\n  else\\n    {\\n    // Color\\n    if (HSL.z < 0.5)\\n      HSL.y = RGBMaxMinDiff / (RGBMax + RGBMin);\\n    else\\n      HSL.y = RGBMaxMinDiff / (2.0 - RGBMax - RGBMin);\\n\\n    float dR\\n      = (((RGBMax - RGB.r) / 6.0) + (RGBMaxMinDiff / 2.0)) / RGBMaxMinDiff;\\n    float dG\\n      = (((RGBMax - RGB.g) / 6.0) + (RGBMaxMinDiff / 2.0)) / RGBMaxMinDiff;\\n    float dB\\n      = (((RGBMax - RGB.b) / 6.0) + (RGBMaxMinDiff / 2.0)) / RGBMaxMinDiff;\\n\\n    if (RGB.r == RGBMax)\\n      HSL.x = dB - dG;\\n    else\\n    if (RGB.g == RGBMax)\\n      HSL.x = (1.0 / 3.0) + dR - dB;\\n    else\\n    if (RGB.b == RGBMax)\\n      HSL.x = (2.0 / 3.0) + dG - dR;\\n\\n    if (HSL.x < 0.0)\\n      HSL.x += 1.0;\\n\\n    if (HSL.x > 1.0)\\n      HSL.x -= 1.0;\\n    }\\n\\n  return HSL;\\n}\\n\\n/**\\nHelper for HSL to RGB conversion.\\n*/\\nfloat Util(float v1, float v2, float vH)\\n{\\n  if (vH < 0.0)\\n    vH += 1.0;\\n\\n  if (vH > 1.0)\\n     vH -= 1.0;\\n\\n  if ((6.0 * vH) < 1.0)\\n    return (v1 + (v2 - v1) * 6.0 * vH);\\n\\n  if ((2.0 * vH) < 1.0)\\n    return (v2);\\n\\n  if ((3.0 * vH) < 2.0)\\n    return (v1 + (v2 - v1) * ((2.0 / 3.0) - vH) * 6.0);\\n\\n  return v1;\\n}\\n\\n/**\\nConvert from HSL space into RGB space.\\n*/\\nvec3 HSLToRGB(vec3 HSL)\\n{\\n  vec3 RGB;\\n  if (HSL.y == 0.0)\\n    {\\n    // Gray\\n    RGB.r = HSL.z;\\n    RGB.g = HSL.z;\\n    RGB.b = HSL.z;\\n    }\\n  else\\n    {\\n    // Chromatic\\n    float v2;\\n    if (HSL.z < 0.5)\\n      v2 = HSL.z * (1.0 + HSL.y);\\n    else\\n      v2 = (HSL.z + HSL.y) - (HSL.y * HSL.z);\\n\\n    float v1 = 2.0 * HSL.z - v2;\\n\\n    RGB.r = Util(v1, v2, HSL.x + (1.0 / 3.0));\\n    RGB.g = Util(v1, v2, HSL.x);\\n    RGB.b = Util(v1, v2, HSL.x - (1.0 / 3.0));\\n    }\\n\\n  return RGB.rgb;\\n}\\n\\nvoid main()\\n{\\n  vec4 lic = texture2D(texLIC, tcoordVC.st);\\n  vec4 geomColor = texture2D(texGeomColors, tcoordVC.st);\\n\\n  // depth is used to determine which fragment belong to us\\n  // and we can change\\n  float depth = texture2D(texVectors, tcoordVC.st).a;\\n\\n  vec3 fragColorRGB;\\n  float valid;\\n  if (depth > 1.0e-3)\\n    {\\n    // we own it\\n    // shade LIC'ed geometry, or apply mask\\n    if (lic.g!=0.0)\\n      {\\n      // it's masked\\n      // apply fragment mask\\n      fragColorRGB = uMaskIntensity * uMaskColor + (1.0 - uMaskIntensity) * geomColor.rgb;\\n      valid = 0.0;\\n      }\\n    else\\n      {\\n      if (uScalarColorMode==0)\\n        {\\n        // blend with scalars\\n        fragColorRGB = lic.rrr * uLICIntensity + geomColor.rgb * (1.0 - uLICIntensity);\\n        }\\n      else\\n        {\\n        // multiply with scalars\\n        fragColorRGB = geomColor.rgb * clamp((uMapBias + lic.r), 0.0, 1.0);\\n        }\\n      if (lic.b != 0.0)\\n        {\\n        // didn't have the required guard pixels\\n        // don't consider it in min max estimation\\n        // for histpgram stretching\\n        valid = 0.0;\\n        }\\n      else\\n        {\\n        // ok to use in min/max estimates for histogram\\n        // stretching\\n        valid = 1.0;\\n        }\\n      }\\n    }\\n  else\\n    {\\n    // we don't own it\\n    // pass through scalars\\n    fragColorRGB = geomColor.rgb;\\n    valid = 0.0;\\n    }\\n\\n  // if no further stages this texture is\\n  // copied to the screen\\n  RGBOutput = vec4(fragColorRGB, geomColor.a);\\n\\n  // if further stages, move to hsl space for contrast\\n  // enhancement. encoding validity saves moving a texture to the cpu\\n  vec3 fragColorHSL = RGBToHSL(fragColorRGB);\\n  HSLOutput = vec4(fragColorHSL, valid);\\n}\\n&quot;),t.licCopyPass=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkSurfaceLICMapper_DCpy.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// This shader copies fragments and depths to the output buffer\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nuniform sampler2D texDepth;     // z values from vertex shader\\nuniform sampler2D texRGBColors; // final rgb LIC colors\\n\\nin vec2 tcoordVC;\\n\\nvoid main()\\n{\\n  gl_FragDepth = texture2D(texDepth, tcoordVC).x;\\n  gl_FragData[0] = texture2D(texRGBColors, tcoordVC);\\n\\n  // since we render a screen aligned quad\\n  // we're going to be writing fragments\\n  // not touched by the original geometry\\n  // it's critical not to modify those\\n  // fragments.\\n  if (gl_FragDepth == 1.0)\\n    {\\n    discard;\\n    }\\n}\\n&quot;),t.enhanceContrastPass=e.buildAShader(&quot;//VTK::System::Dec\\n\\n//=========================================================================\\n//\\n//  Program:   Visualization Toolkit\\n//  Module:    vtkSurfaceLICMapper_CE.glsl\\n//\\n//  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n//  All rights reserved.\\n//  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n//\\n//     This software is distributed WITHOUT ANY WARRANTY; without even\\n//     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n//     PURPOSE.  See the above copyright notice for more information.\\n//\\n//=========================================================================\\n\\n// color contrast enhance stage implemented via histogram stretching\\n// on lightness channel. if the min and max are tweaked it can generate\\n// out-of-range values these will be clamped in 0 to 1\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nuniform sampler2D texGeomColors; // scalars + lighting\\nuniform sampler2D texLIC;        // image lic, mask\\nuniform sampler2D texHSLColors;  // hsla colors\\n\\nuniform float     uLMin;         // min lightness over all fragments\\nuniform float     uLMaxMinDiff;  // max - min lightness over all fragments\\n\\nin vec2 tcoordVC;\\n\\nvec3 HSLToRGB(vec3 HSL)\\n{\\n  vec3 RGB;\\n  float v;\\n  float h = HSL.x;\\n  float sl = HSL.y;\\n  float l = HSL.z;\\n\\n  v = (l <= 0.5) ? (l * (1.0 + sl)) : (l + sl - l * sl);\\n  if (v <= 0.0) {\\n    RGB = vec3(0.0,0.0,0.0);\\n  } else {\\n    float m;\\n    int sextant;\\n    float fract, vsf, mid1, mid2;\\n\\n    m = l + l - v;\\n    h *= 6.0;\\n    sextant = int(h);\\n    fract = h - float(sextant);\\n\\n    vsf = (v - m) * fract;\\n    mid1 = m + vsf;\\n    mid2 = v - vsf;\\n    switch (sextant) {\\n      case 0: RGB.r = v; RGB.g = mid1; RGB.b = m; break;\\n      case 1: RGB.r = mid2; RGB.g = v; RGB.b = m; break;\\n      case 2: RGB.r = m; RGB.g = v; RGB.b = mid1; break;\\n      case 3: RGB.r = m; RGB.g = mid2; RGB.b = v; break;\\n      case 4: RGB.r = mid1; RGB.g = m; RGB.b = v; break;\\n      case 5: RGB.r = v; RGB.g = m; RGB.b = mid2; break;\\n    }\\n  }\\n  return RGB;\\n}\\n\\nvoid main()\\n{\\n  // lookup hsl color , mask\\n  vec4 fragColor = texture2D(texHSLColors, tcoordVC.st);\\n\\n  // don't modify masked fragments (masked => lic.g==1)\\n  vec4 lic = texture2D(texLIC, tcoordVC.st);\\n  if (lic.g==0.0)\\n    {\\n    // normalize lightness channel\\n    fragColor.z = clamp((fragColor.z - uLMin)/uLMaxMinDiff, 0.0, 1.0);\\n    }\\n\\n  // back into rgb space\\n  fragColor.rgb = HSLToRGB(fragColor.xyz);\\n\\n  // add alpha\\n  vec4 geomColor = texture2D(texGeomColors, tcoordVC.st);\\n  fragColor.a = geomColor.a;\\n\\n  gl_FragData[0] = fragColor;\\n}\\n&quot;),t.shadersNeedBuilding=!1)},e.initializeResources=()=>{e.createFBO(),e.generateNoiseTexture(t.licInterface.getNoiseTextureSize()),e.allocateTextures(),e.buildAllShaders(),t.licQuad||(t.licQuad=function(e){const t=ld.newInstance();t.setOpenGLRenderWindow(e);const n=new Float32Array(12);for(let e=0;e<4;e++)n[3*e]=e%2*2-1,n[3*e+1]=e>1?1:-1,n[3*e+2]=0;const r=new Float32Array([0,0,1,0,0,1,1,1]),o=new Uint16Array(8);o[0]=3,o[1]=0,o[2]=1,o[3]=3,o[4]=3,o[5]=0,o[6]=3,o[7]=2;const a=xs.newInstance({numberOfComponents:3,values:n});a.setName(&quot;points&quot;);const i=xs.newInstance({numberOfComponents:1,values:o}),s=xs.newInstance({numberOfComponents:2,values:r});return t.getCABO().createVBO(i,&quot;polys&quot;,Pg.SURFACE,{points:a,cellOffset:0,tcoords:s}),t}(t._openGLRenderWindow)),t.licHelper||(t.licHelper=Ag.newInstance())},e.prepareForGeometry=()=>{const e=t.framebuffer;e.saveCurrentBindingsAndBuffers(),e.bind(),t.geometryImage.activate(),t.vectorImage.activate(),t.maskVectorImage.activate(),e.removeColorBuffer(0),e.removeColorBuffer(2),e.removeColorBuffer(3),e.setColorBuffer(t.geometryImage,0),e.setColorBuffer(t.vectorImage,2),e.setColorBuffer(t.maskVectorImage,3),e.setDepthBuffer(t.depthTexture);const n=t.context;n.drawBuffers([n.COLOR_ATTACHMENT0,n.NONE,n.COLOR_ATTACHMENT2,n.COLOR_ATTACHMENT3]),n.viewport(0,0,...t.size),n.scissor(0,0,...t.size),n.disable(n.BLEND),n.disable(n.DEPTH_TEST),n.disable(n.SCISSOR_TEST),n.clearColor(0,0,0,0),n.clear(n.DEPTH_BUFFER_BIT|n.COLOR_BUFFER_BIT)},e.copyToScreen=n=>{t.RGBColorImage.activate(),t.depthTexture.activate(),t.licCopyPass||e.initializeResources();const r=t.licCopyPass;t._openGLRenderWindow.getShaderCache().readyShaderProgram(r);const o=t.context;o.viewport(0,0,...n),o.scissor(0,0,...n),o.disable(o.BLEND),o.enable(o.DEPTH_TEST),o.disable(o.SCISSOR_TEST),r.setUniformi(&quot;texDepth&quot;,t.depthTexture.getTextureUnit()),r.setUniformi(&quot;texRGBColors&quot;,t.RGBColorImage.getTextureUnit()),e.renderQuad(n,r),t.RGBColorImage.deactivate(),t.depthTexture.deactivate()},e.combineColorsAndLIC=()=>{const n=t.context,r=t.framebuffer;r.saveCurrentBindingsAndBuffers(),r.bind(),r.create(...t.size),r.removeColorBuffer(0),r.removeColorBuffer(1),r.setColorBuffer(t.RGBColorImage,0),r.setColorBuffer(t.HSLColorImage,1),n.drawBuffers([n.COLOR_ATTACHMENT0,n.COLOR_ATTACHMENT1]),n.disable(n.DEPTH_TEST),n.clearColor(0,0,0,0),n.clear(n.COLOR_BUFFER_BIT),t.vectorImage.activate(),t.geometryImage.activate(),t.LICImage.activate(),t.licColorPass||e.initializeResources();const o=t.licColorPass;t._openGLRenderWindow.getShaderCache().readyShaderProgram(o),o.setUniformi(&quot;texVectors&quot;,t.vectorImage.getTextureUnit()),o.setUniformi(&quot;texGeomColors&quot;,t.geometryImage.getTextureUnit());const{colorMode:a,LICIntensity:i,mapModeBias:s,maskIntensity:l,maskColor:c,enhanceContrast:u,lowColorContrastEnhancementFactor:d,highColorContrastEnhancementFactor:p}=t.licInterface.get(&quot;colorMode&quot;,&quot;LICIntensity&quot;,&quot;mapModeBias&quot;,&quot;maskIntensity&quot;,&quot;maskColor&quot;,&quot;enhanceContrast&quot;,&quot;lowColorContrastEnhancementFactor&quot;,&quot;highColorContrastEnhancementFactor&quot;);if(o.setUniformi(&quot;texLIC&quot;,t.LICImage.getTextureUnit()),o.setUniformi(&quot;uScalarColorMode&quot;,a),o.setUniformf(&quot;uLICIntensity&quot;,i),o.setUniformf(&quot;uMapBias&quot;,s),o.setUniformf(&quot;uMaskIntensity&quot;,l),o.setUniform3f(&quot;uMaskColor&quot;,...c),e.renderQuad(t.size,o),t.vectorImage.deactivate(),t.geometryImage.deactivate(),t.LICImage.deactivate(),r.removeColorBuffer(0),r.removeColorBuffer(1),n.drawBuffers([n.NONE]),u===yg||u===bg){let o=0,a=1,i=a-o;o+=i*d,a-=i*p,i=a-o,r.setColorBuffer(t.RGBColorImage),n.drawBuffers([n.COLOR_ATTACHMENT0]),t.geometryImage.activate(),t.HSLColorImage.activate(),t.LICImage.activate(),t.enhanceContrastPass||e.initializeResources();const{enhanceContrastPass:s}=t;t._openGLRenderWindow.getShaderCache().readyShaderProgram(s),s.setUniformi(&quot;texGeomColors&quot;,t.geometryImage.getTextureUnit()),s.setUniformi(&quot;texHSLColors&quot;,t.HSLColorImage.getTextureUnit()),s.setUniformi(&quot;texLIC&quot;,t.LICImage.getTextureUnit()),s.setUniformf(&quot;uLMin&quot;,o),s.setUniformf(&quot;uLMaxMinDiff&quot;,i),e.renderQuad(t.size,s),t.geometryImage.deactivate(),t.HSLColorImage.deactivate(),t.LICImage.deactivate(),r.removeColorBuffer(0),n.drawBuffers([n.NONE])}r.restorePreviousBindingsAndBuffers()},e.applyLIC=()=>{const e=t.licInterface.get(&quot;stepSize&quot;,&quot;numberOfSteps&quot;,&quot;enhancedLIC&quot;,&quot;enhanceContrast&quot;,&quot;lowLICContrastEnhancementFactor&quot;,&quot;highLICContrastEnhancementFactor&quot;,&quot;antiAlias&quot;,&quot;normalizeVectors&quot;,&quot;maskThreshold&quot;,&quot;transformVectors&quot;),n=t.licHelper.executeLIC(t.size,t.vectorImage,t.maskVectorImage,t.noiseTexture,t._openGLRenderWindow,e);if(!n)return console.error(&quot;Failed to compute image LIC&quot;),void(t.LICImage=null);t.LICImage=n},e.setSize=n=>{Array.isArray(n)&&2===n.length&&(t.size&&t.size[0]===n[0]&&t.size[1]===n[1]||(t.size=n,e.releaseGraphicsResources()))},e.releaseGraphicsResources=()=>{t.geometryImage&&(t.geometryImage.releaseGraphicsResources(),t.geometryImage=null),t.vectorImage&&(t.vectorImage.releaseGraphicsResources(),t.vectorImage=null),t.maskVectorImage&&(t.maskVectorImage.releaseGraphicsResources(),t.maskVectorImage=null),t.LICImage&&(t.LICImage.releaseGraphicsResources(),t.LICImage=null),t.RGBColorImage&&(t.RGBColorImage.releaseGraphicsResources(),t.RGBColorImage=null),t.HSLColorImage&&(t.HSLColorImage.releaseGraphicsResources(),t.HSLColorImage=null),t.depthTexture&&(t.depthTexture.releaseGraphicsResources(),t.depthTexture=null),t.framebuffer&&(t.framebuffer.releaseGraphicsResources(),t.framebuffer=null)}}(e,t)}var Eg={newInstance:Wt.newInstance(Mg,&quot;vtkSurfaceLICInterface&quot;),extend:Mg};const{vtkErrorMacro:Vg}=Ht,Dg={canDrawLIC:!1,rebuildLICShaders:!1,rebuildLICBuffers:!1,openGLLicInterface:null};const Lg=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Dg,n),$d.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLSurfaceLICMapper&quot;);const n={...e};e.getNeedToRebuildShaders=(e,r,o)=>t.rebuildLICShaders||n.getNeedToRebuildShaders(e,r,o),e.replaceShaderValues=(e,r,o)=>{const a=t.lastBoundBO.getReferenceByName(&quot;lastLightComplexity&quot;);let i=e.Vertex,s=e.Fragment;const l=t.renderable.getInputArrayToProcess(0);if(l&&t.canDrawLIC){s=td.substitute(s,&quot;//VTK::Output::Dec&quot;,[&quot;//VTK::Output::Dec&quot;,&quot;layout(location = 2) out vec4 vectorTexture;&quot;,&quot;layout(location = 3) out vec4 maskVectorTexture;&quot;]).result;const n=`${l.getName()}MC`;0===a&&t.lastBoundBO.set({lastLightComplexity:1},!0),i=td.substitute(i,&quot;//VTK::TCoord::Dec&quot;,[`attribute vec3 ${n};`,&quot;out vec3 licOutput;&quot;,&quot;//VTK::TCoord::Dec&quot;]).result,i=td.substitute(i,&quot;//VTK::TCoord::Impl&quot;,[`licOutput = ${n};`,&quot;//VTK::TCoord::Impl&quot;]).result,s=td.substitute(s,&quot;//VTK::TCoord::Dec&quot;,[&quot;uniform int uMaskOnSurface;&quot;,&quot;uniform mat3 normalMatrix;&quot;,&quot;in vec3 licOutput;&quot;,&quot;//VTK::TCoord::Dec&quot;]).result,s=td.substitute(s,&quot;//VTK::TCoord::Impl&quot;,[&quot;// projected vectors&quot;,&quot;  vec3 tcoordLIC = normalMatrix * licOutput;&quot;,&quot;  vec3 normN = normalize(normalVCVSOutput);&quot;,&quot;  float k = dot(tcoordLIC, normN);&quot;,&quot;  vec3 projected = (tcoordLIC - k*normN);&quot;,&quot;  vectorTexture = vec4(projected.x, projected.y, 0.0 , 1.0);&quot;,&quot;// vectors for fragment masking&quot;,&quot;  if (uMaskOnSurface == 0)&quot;,&quot;    {&quot;,&quot;    maskVectorTexture = vec4(licOutput, 1.0);&quot;,&quot;    }&quot;,&quot;  else&quot;,&quot;    {&quot;,&quot;    maskVectorTexture = vec4(projected.x, projected.y, 0.0 , 1.0);&quot;,&quot;    }&quot;,&quot;//VTK::TCoord::Impl&quot;],!1).result,e.Vertex=i}t.rebuildLICShaders=!1,e.Fragment=s,n.replaceShaderValues(e,r,o),a>0&&t.lastBoundBO.set({lastLightComplexity:a},!0)},e.setMapperShaderParameters=(e,r,o)=>{n.setMapperShaderParameters(e,r,o),t.canDrawLIC&&e.getProgram().setUniformi(&quot;uMaskOnSurface&quot;,t.maskOnSurface)},e.getNeedToRebuildBufferObjects=(e,r)=>t.rebuildLICBuffers||n.getNeedToRebuildBufferObjects(e,r),e.buildBufferObjects=(e,r)=>{if(t.canDrawLIC){const e=t.renderable.getInputArrayToProcess(0);e&&e.getNumberOfComponents()>1&&t.renderable.setCustomShaderAttributes([e.getName()])}t.rebuildLICBuffers=!1,n.buildBufferObjects(e,r)},e.pushState=e=>{t.stateCache={[e.BLEND]:e.isEnabled(e.BLEND),[e.DEPTH_TEST]:e.isEnabled(e.DEPTH_TEST),[e.SCISSOR_TEST]:e.isEnabled(e.SCISSOR_TEST),[e.CULL_FACE]:e.isEnabled(e.CULL_FACE)}},e.popState=e=>{const n=n=>t.stateCache[n]?e.enable(n):e.disable(n);n(e.BLEND),n(e.DEPTH_TEST),n(e.SCISSOR_TEST),n(e.CULL_FACE)},e.renderPiece=(r,o)=>{let a=!0;t._openGLRenderWindow.getWebgl2()||(Vg(&quot;SurfaceLICMapper Requires WebGL 2&quot;),a=!1),t.context.getExtension(&quot;EXT_color_buffer_float&quot;)&&t.context.getExtension(&quot;OES_texture_float_linear&quot;)||(Vg(&quot;SurfaceLICMapper requires the EXT_color_buffer_float and OES_texture_float_linear WebGL2 extensions.&quot;),a=!1),t.currentInput=t.renderable.getInputData(),t.currentInput||(Vg(&quot;No input&quot;),a=!1);let i=t.renderable.getLicInterface();i||(i=Og.newInstance(),t.renderable.setLicInterface(i)),t.openGLLicInterface||(t.openGLLicInterface=Eg.newInstance()),i!==t.openGLLicInterface.getLicInterface()&&t.openGLLicInterface.setLicInterface(i);const s=t.renderable.getInputArrayToProcess(0);if(i.getEnableLIC()&&(!s||s.getNumberOfComponents()<2)&&(Vg(&quot;No vector input array&quot;),a=!1),i.getEnableLIC()||(a=!1),t.canDrawLIC!==a&&(t.rebuildLICShaders=!0,t.rebuildLICBuffers=!0),t.canDrawLIC=a,!a||!i.getEnableLIC())return void n.renderPiece(r,o);const l=t.context,c=o.getProperty().getBackfaceCulling(),u=o.getProperty().getFrontfaceCulling();c||u?u?(t._openGLRenderWindow.enableCullFace(),l.cullFace(l.FRONT)):(t._openGLRenderWindow.enableCullFace(),l.cullFace(l.BACK)):t._openGLRenderWindow.disableCullFace();const d=t._openGLRenderWindow.getSize(),p=d.map((e=>Math.round(e*i.getViewPortScale())));t.openGLLicInterface.setSize(p),t.openGLLicInterface.setOpenGLRenderWindow(t._openGLRenderWindow),t.openGLLicInterface.setContext(t.context),e.pushState(t.context),t.openGLLicInterface.initializeResources(),t.openGLLicInterface.prepareForGeometry(),e.popState(t.context),n.renderPieceStart(r,o),n.renderPieceDraw(r,o),n.renderPieceFinish(r,o),e.pushState(t.context),t.VBOBuildTime.modified(),t.openGLLicInterface.completedGeometry(),t.context.disable(t.context.CULL_FACE),t.openGLLicInterface.applyLIC(),t.openGLLicInterface.combineColorsAndLIC(),t.openGLLicInterface.copyToScreen(d),e.popState(t.context)}}(e,t),Ct(e,t,[&quot;openGLLicInterface&quot;])}),&quot;vtkOpenGLSurfaceLICMapper&quot;);Jt(&quot;vtkSurfaceLICMapper&quot;,Lg);const{vtkErrorMacro:Bg}=Ht,Ng={};const Fg=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ng,n),$d.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLSphereMapper&quot;);const n={...e};e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkSphereMapperVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// this shader implements imposters in OpenGL for Spheres\\n\\nattribute vec4 vertexMC;\\nattribute vec2 offsetMC;\\n\\n// optional normal declaration\\n//VTK::Normal::Dec\\n\\n//VTK::Picking::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\nuniform mat3 normalMatrix; // transform model coordinate directions to view coordinates\\n\\n// material property values\\n//VTK::Color::Dec\\n\\n// clipping plane vars\\n//VTK::Clip::Dec\\n\\n// camera and actor matrix values\\n//VTK::Camera::Dec\\n\\nvarying vec4 vertexVCVSOutput;\\nvarying float radiusVCVSOutput;\\nvarying vec3 centerVCVSOutput;\\n\\nuniform int cameraParallel;\\nuniform float scaleFactor;\\n\\nvoid main()\\n{\\n  //VTK::Picking::Impl\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Clip::Impl\\n\\n  // compute the projected vertex position\\n  vec2 scaledOffsetMC = scaleFactor * offsetMC;\\n  vertexVCVSOutput = MCVCMatrix * vertexMC;\\n  centerVCVSOutput = vertexVCVSOutput.xyz;\\n  radiusVCVSOutput = length(scaledOffsetMC)*0.5;\\n\\n  // make the triangle face the camera\\n  if (cameraParallel == 0)\\n    {\\n    vec3 dir = normalize(-vertexVCVSOutput.xyz);\\n    vec3 base2 = normalize(cross(dir,vec3(1.0,0.0,0.0)));\\n    vec3 base1 = cross(base2,dir);\\n    vertexVCVSOutput.xyz = vertexVCVSOutput.xyz + scaledOffsetMC.x*base1 + scaledOffsetMC.y*base2;\\n    }\\n  else\\n    {\\n    // add in the offset\\n    vertexVCVSOutput.xy = vertexVCVSOutput.xy + scaledOffsetMC;\\n    }\\n\\n  gl_Position = VCPCMatrix * vertexVCVSOutput;\\n}\\n&quot;,e.Fragment=Md,e.Geometry=&quot;&quot;},e.replaceShaderValues=(e,r,o)=>{let a=e.Vertex,i=e.Fragment;a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 VCPCMatrix;\\n&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Dec&quot;,[&quot;varying vec4 vertexVCVSOutput;&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Impl&quot;,[&quot;vec4 vertexVC = vertexVCVSOutput;\\n&quot;]).result,i=td.substitute(i,&quot;//VTK::Normal::Dec&quot;,[&quot;uniform float invertedDepth;\\n&quot;,&quot;uniform int cameraParallel;\\n&quot;,&quot;varying float radiusVCVSOutput;\\n&quot;,&quot;varying vec3 centerVCVSOutput;\\n&quot;,&quot;uniform mat4 VCPCMatrix;\\n&quot;]).result;let s=&quot;&quot;;t.context.getExtension(&quot;EXT_frag_depth&quot;)&&(s=&quot;gl_FragDepthEXT = (pos.z / pos.w + 1.0) / 2.0;\\n&quot;),t._openGLRenderWindow.getWebgl2()&&(s=&quot;gl_FragDepth = (pos.z / pos.w + 1.0) / 2.0;\\n&quot;),i=td.substitute(i,&quot;//VTK::Depth::Impl&quot;,[&quot;  vec3 EyePos;\\n&quot;,&quot;  vec3 EyeDir;\\n&quot;,&quot;  if (cameraParallel != 0) {\\n&quot;,&quot;    EyePos = vec3(vertexVC.x, vertexVC.y, vertexVC.z + 3.0*radiusVCVSOutput);\\n&quot;,&quot;    EyeDir = vec3(0.0,0.0,-1.0); }\\n&quot;,&quot;  else {\\n&quot;,&quot;    EyeDir = vertexVC.xyz;\\n&quot;,&quot;    EyePos = vec3(0.0,0.0,0.0);\\n&quot;,&quot;    float lengthED = length(EyeDir);\\n&quot;,&quot;    EyeDir = normalize(EyeDir);\\n&quot;,&quot;    if (lengthED > radiusVCVSOutput*3.0) {\\n&quot;,&quot;      EyePos = vertexVC.xyz - EyeDir*3.0*radiusVCVSOutput; }\\n&quot;,&quot;    }\\n&quot;,&quot;  EyePos = EyePos - centerVCVSOutput;\\n&quot;,&quot;  EyePos = EyePos/radiusVCVSOutput;\\n&quot;,&quot;  float b = 2.0*dot(EyePos,EyeDir);\\n&quot;,&quot;  float c = dot(EyePos,EyePos) - 1.0;\\n&quot;,&quot;  float d = b*b - 4.0*c;\\n&quot;,&quot;  vec3 normalVCVSOutput = vec3(0.0,0.0,1.0);\\n&quot;,&quot;  if (d < 0.0) { discard; }\\n&quot;,&quot;  else {\\n&quot;,&quot;    float t = (-b - invertedDepth*sqrt(d))*0.5;\\n&quot;,&quot;    normalVCVSOutput = invertedDepth*normalize(EyePos + t*EyeDir);\\n&quot;,&quot;    vertexVC.xyz = normalVCVSOutput*radiusVCVSOutput + centerVCVSOutput;\\n&quot;,&quot;    }\\n&quot;,&quot;  vec4 pos = VCPCMatrix * vertexVC;\\n&quot;,s]).result,i=td.substitute(i,&quot;//VTK::Normal::Impl&quot;,&quot;&quot;).result,t.haveSeenDepthRequest&&(i=td.substitute(i,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float computedZ = (pos.z / pos.w + 1.0) / 2.0;&quot;,&quot;float iz = floor(computedZ * 65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result),e.Vertex=a,e.Fragment=i,n.replaceShaderValues(e,r,o)},e.setMapperShaderParameters=(e,r,o)=>{if(e.getCABO().getElementCount()&&(t.VBOBuildTime>e.getAttributeUpdateTime().getMTime()||e.getShaderSourceTime().getMTime()>e.getAttributeUpdateTime().getMTime())&&e.getProgram().isAttributeUsed(&quot;offsetMC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;offsetMC&quot;,12,e.getCABO().getStride(),t.context.FLOAT,2,!1)||Bg(&quot;Error setting 'offsetMC' in shader VAO.&quot;)),e.getProgram().isUniformUsed(&quot;invertedDepth&quot;)&&e.getProgram().setUniformf(&quot;invertedDepth&quot;,t.invert?-1:1),e.getProgram().isUniformUsed(&quot;scaleFactor&quot;)){const n=t.currentInput.getPointData();null!=t.renderable.getScaleArray()&&n.hasArray(t.renderable.getScaleArray())?e.getProgram().setUniformf(&quot;scaleFactor&quot;,t.renderable.getScaleFactor()):e.getProgram().setUniformf(&quot;scaleFactor&quot;,1)}n.setMapperShaderParameters(e,r,o)},e.setCameraShaderParameters=(e,n,r)=>{const o=e.getProgram(),a=n.getActiveCamera(),i=t.openGLCamera.getKeyMatrices(n);o.isUniformUsed(&quot;VCPCMatrix&quot;)&&o.setUniformMatrix(&quot;VCPCMatrix&quot;,i.vcpc);const s=new Float64Array(16);if(o.isUniformUsed(&quot;MCVCMatrix&quot;))if(r.getIsIdentity())p(s,i.wcvc),e.getCABO().getCoordShiftAndScaleEnabled()&&b(s,s,e.getCABO().getInverseShiftAndScaleMatrix()),o.setUniformMatrix(&quot;MCVCMatrix&quot;,s);else{const n=t.openGLActor.getKeyMatrices();b(s,i.wcvc,n.mcwc),e.getCABO().getCoordShiftAndScaleEnabled()&&b(s,s,e.getCABO().getInverseShiftAndScaleMatrix()),o.setUniformMatrix(&quot;MCVCMatrix&quot;,s)}o.isUniformUsed(&quot;cameraParallel&quot;)&&e.getProgram().setUniformi(&quot;cameraParallel&quot;,a.getParallelProjection())},e.getOpenGLMode=(e,n)=>t.context.TRIANGLES,e.buildBufferObjects=(e,n)=>{const r=t.currentInput;if(null===r)return;t.renderable.mapScalars(r,1);const o=t.renderable.getColorMapColors(),a=t.primitives[t.primTypes.Tris].getCABO(),i=r.getPointData(),s=r.getPoints(),l=s.getNumberOfPoints(),c=s.getData();let u=null;null!=t.renderable.getScaleArray()&&i.hasArray(t.renderable.getScaleArray())&&(u=i.getArray(t.renderable.getScaleArray()).getData());let d=null,p=0,f=null;o?(p=o.getNumberOfComponents(),a.setColorOffset(0),a.setColorBOStride(4),d=o.getData(),f=new Uint8Array(3*l*4),a.getColorBO()||a.setColorBO(zu.newInstance()),a.getColorBO().setOpenGLRenderWindow(t._openGLRenderWindow)):a.getColorBO()&&a.setColorBO(null),a.setColorComponents(p);const g=new Float32Array(5*l*3);a.setStride(20);const m=Math.cos(vo(30));let h=0,v=0;const{useShiftAndScale:T,coordShift:y,coordScale:b}=Wu(s);T&&a.setCoordShiftAndScale(y,b);let x=0,C=0;for(let e=0;e<l;++e){let n=t.renderable.getRadius();u&&(n=u[e]),h=3*e;const r=(c[h++]-y[0])*b[0],o=(c[h++]-y[1])*b[1],a=(c[h++]-y[2])*b[2];g[x++]=r,g[x++]=o,g[x++]=a,g[x++]=-2*n*m,g[x++]=-n,d&&(v=e*p,f[C++]=d[v],f[C++]=d[v+1],f[C++]=d[v+2],f[C++]=d[v+3]),g[x++]=r,g[x++]=o,g[x++]=a,g[x++]=2*n*m,g[x++]=-n,d&&(f[C++]=d[v],f[C++]=d[v+1],f[C++]=d[v+2],f[C++]=d[v+3]),g[x++]=r,g[x++]=o,g[x++]=a,g[x++]=0,g[x++]=2*n,d&&(f[C++]=d[v],f[C++]=d[v+1],f[C++]=d[v+2],f[C++]=d[v+3])}a.setElementCount(x/5),a.upload(g,Fu.ARRAY_BUFFER),o&&a.getColorBO().upload(f,Fu.ARRAY_BUFFER),t.VBOBuildTime.modified()}}(e,t)}),&quot;vtkOpenGLSphereMapper&quot;);Jt(&quot;vtkSphereMapper&quot;,Fg);const{vtkErrorMacro:_g}=Ht,kg={};const Gg=Mt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,kg,n),$d.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLStickMapper&quot;);const n={...e};e.getShaderTemplate=(e,t,n)=>{e.Vertex=&quot;//VTK::System::Dec\\n\\n/*=========================================================================\\n\\n  Program:   Visualization Toolkit\\n  Module:    vtkStickMapperVS.glsl\\n\\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\\n  All rights reserved.\\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\\n\\n     This software is distributed WITHOUT ANY WARRANTY; without even\\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\\n     PURPOSE.  See the above copyright notice for more information.\\n\\n=========================================================================*/\\n// this shader implements imposters in OpenGL for Sticks\\n\\nattribute vec4 vertexMC;\\nattribute vec3 orientMC;\\nattribute vec4 offsetMC;\\nattribute float radiusMC;\\n\\n// optional normal declaration\\n//VTK::Normal::Dec\\n\\n//VTK::Picking::Dec\\n\\n// Texture coordinates\\n//VTK::TCoord::Dec\\n\\nuniform mat3 normalMatrix; // transform model coordinate directions to view coordinates\\n\\n// material property values\\n//VTK::Color::Dec\\n\\n// clipping plane vars\\n//VTK::Clip::Dec\\n\\n// camera and actor matrix values\\n//VTK::Camera::Dec\\n\\nvarying vec4 vertexVCVSOutput;\\nvarying float radiusVCVSOutput;\\nvarying float lengthVCVSOutput;\\nvarying vec3 centerVCVSOutput;\\nvarying vec3 orientVCVSOutput;\\n\\nuniform int cameraParallel;\\n\\nvoid main()\\n{\\n  //VTK::Picking::Impl\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Clip::Impl\\n\\n  vertexVCVSOutput = MCVCMatrix * vertexMC;\\n  centerVCVSOutput = vertexVCVSOutput.xyz;\\n  radiusVCVSOutput = radiusMC;\\n  lengthVCVSOutput = length(orientMC);\\n  orientVCVSOutput = normalMatrix * normalize(orientMC);\\n\\n  // make sure it is pointing out of the screen\\n  if (orientVCVSOutput.z < 0.0)\\n    {\\n    orientVCVSOutput = -orientVCVSOutput;\\n    }\\n\\n  // make the basis\\n  vec3 xbase;\\n  vec3 ybase;\\n  vec3 dir = vec3(0.0,0.0,1.0);\\n  if (cameraParallel == 0)\\n    {\\n    dir = normalize(-vertexVCVSOutput.xyz);\\n    }\\n  if (abs(dot(dir,orientVCVSOutput)) == 1.0)\\n    {\\n    xbase = normalize(cross(vec3(0.0,1.0,0.0),orientVCVSOutput));\\n    ybase = cross(xbase,orientVCVSOutput);\\n    }\\n  else\\n    {\\n    xbase = normalize(cross(orientVCVSOutput,dir));\\n    ybase = cross(orientVCVSOutput,xbase);\\n    }\\n\\n  vec3 offsets = offsetMC.xyz*2.0-1.0;\\n  vertexVCVSOutput.xyz = vertexVCVSOutput.xyz +\\n    radiusVCVSOutput*offsets.x*xbase +\\n    radiusVCVSOutput*offsets.y*ybase +\\n    0.5*lengthVCVSOutput*offsets.z*orientVCVSOutput;\\n\\n  gl_Position = VCPCMatrix * vertexVCVSOutput;\\n}\\n&quot;,e.Fragment=Md,e.Geometry=&quot;&quot;},e.replaceShaderValues=(e,r,o)=>{let a=e.Vertex,i=e.Fragment;a=td.substitute(a,&quot;//VTK::Camera::Dec&quot;,[&quot;uniform mat4 VCPCMatrix;\\n&quot;,&quot;uniform mat4 MCVCMatrix;&quot;]).result,i=td.substitute(i,&quot;//VTK::PositionVC::Dec&quot;,&quot;varying vec4 vertexVCVSOutput;&quot;).result,i=td.substitute(i,&quot;//VTK::PositionVC::Impl&quot;,&quot;  vec4 vertexVC = vertexVCVSOutput;\\n&quot;).result,i=td.substitute(i,&quot;//VTK::Normal::Dec&quot;,[&quot;uniform int cameraParallel;\\n&quot;,&quot;varying float radiusVCVSOutput;\\n&quot;,&quot;varying vec3 orientVCVSOutput;\\n&quot;,&quot;varying float lengthVCVSOutput;\\n&quot;,&quot;varying vec3 centerVCVSOutput;\\n&quot;,&quot;uniform mat4 VCPCMatrix;\\n&quot;]).result;let s=&quot;&quot;;t.context.getExtension(&quot;EXT_frag_depth&quot;)&&(s=&quot;  gl_FragDepthEXT = (pos.z / pos.w + 1.0) / 2.0;\\n&quot;),t._openGLRenderWindow.getWebgl2()&&(s=&quot;gl_FragDepth = (pos.z / pos.w + 1.0) / 2.0;\\n&quot;),i=td.substitute(i,&quot;//VTK::Depth::Impl&quot;,[&quot;  vec3 EyePos;\\n&quot;,&quot;  vec3 EyeDir;\\n&quot;,&quot;  if (cameraParallel != 0) {\\n&quot;,&quot;    EyePos = vec3(vertexVC.x, vertexVC.y, vertexVC.z + 3.0*radiusVCVSOutput);\\n&quot;,&quot;    EyeDir = vec3(0.0,0.0,-1.0); }\\n&quot;,&quot;  else {\\n&quot;,&quot;    EyeDir = vertexVC.xyz;\\n&quot;,&quot;    EyePos = vec3(0.0,0.0,0.0);\\n&quot;,&quot;    float lengthED = length(EyeDir);\\n&quot;,&quot;    EyeDir = normalize(EyeDir);\\n&quot;,&quot;    if (lengthED > radiusVCVSOutput*3.0) {\\n&quot;,&quot;      EyePos = vertexVC.xyz - EyeDir*3.0*radiusVCVSOutput; }\\n&quot;,&quot;    }\\n&quot;,&quot;  EyePos = EyePos - centerVCVSOutput;\\n&quot;,&quot;  vec3 base1;\\n&quot;,&quot;  if (abs(orientVCVSOutput.z) < 0.99) {\\n&quot;,&quot;    base1 = normalize(cross(orientVCVSOutput,vec3(0.0,0.0,1.0))); }\\n&quot;,&quot;  else {\\n&quot;,&quot;    base1 = normalize(cross(orientVCVSOutput,vec3(0.0,1.0,0.0))); }\\n&quot;,&quot;  vec3 base2 = cross(orientVCVSOutput,base1);\\n&quot;,&quot;  EyePos = vec3(dot(EyePos,base1),dot(EyePos,base2),dot(EyePos,orientVCVSOutput));\\n&quot;,&quot;  EyeDir = vec3(dot(EyeDir,base1),dot(EyeDir,base2),dot(EyeDir,orientVCVSOutput));\\n&quot;,&quot;  EyePos = EyePos/radiusVCVSOutput;\\n&quot;,&quot;  float a = EyeDir.x*EyeDir.x + EyeDir.y*EyeDir.y;\\n&quot;,&quot;  float b = 2.0*(EyePos.x*EyeDir.x + EyePos.y*EyeDir.y);\\n&quot;,&quot;  float c = EyePos.x*EyePos.x + EyePos.y*EyePos.y - 1.0;\\n&quot;,&quot;  float d = b*b - 4.0*a*c;\\n&quot;,&quot;  vec3 normalVCVSOutput = vec3(0.0,0.0,1.0);\\n&quot;,&quot;  if (d < 0.0) { discard; }\\n&quot;,&quot;  else {\\n&quot;,&quot;    float t =  (-b - sqrt(d))/(2.0*a);\\n&quot;,&quot;    float tz = EyePos.z + t*EyeDir.z;\\n&quot;,&quot;    vec3 iPoint = EyePos + t*EyeDir;\\n&quot;,&quot;    if (abs(iPoint.z)*radiusVCVSOutput > lengthVCVSOutput*0.5) {\\n&quot;,&quot;      float t2 = (-b + sqrt(d))/(2.0*a);\\n&quot;,&quot;      float tz2 = EyePos.z + t2*EyeDir.z;\\n&quot;,&quot;      if (tz2*radiusVCVSOutput > lengthVCVSOutput*0.5 || tz*radiusVCVSOutput < -0.5*lengthVCVSOutput) { discard; }\\n&quot;,&quot;      else {\\n&quot;,&quot;        normalVCVSOutput = orientVCVSOutput;\\n&quot;,&quot;        float t3 = (lengthVCVSOutput*0.5/radiusVCVSOutput - EyePos.z)/EyeDir.z;\\n&quot;,&quot;        iPoint = EyePos + t3*EyeDir;\\n&quot;,&quot;        vertexVC.xyz = radiusVCVSOutput*(iPoint.x*base1 + iPoint.y*base2 + iPoint.z*orientVCVSOutput) + centerVCVSOutput;\\n&quot;,&quot;        }\\n&quot;,&quot;      }\\n&quot;,&quot;    else {\\n&quot;,&quot;      normalVCVSOutput = iPoint.x*base1 + iPoint.y*base2;\\n&quot;,&quot;      vertexVC.xyz = radiusVCVSOutput*(normalVCVSOutput + iPoint.z*orientVCVSOutput) + centerVCVSOutput;\\n&quot;,&quot;      }\\n&quot;,&quot;    }\\n&quot;,&quot;  vec4 pos = VCPCMatrix * vertexVC;\\n&quot;,s]).result,i=td.substitute(i,&quot;//VTK::Normal::Impl&quot;,&quot;&quot;).result,t.haveSeenDepthRequest&&(i=td.substitute(i,&quot;//VTK::ZBuffer::Impl&quot;,[&quot;if (depthRequest == 1) {&quot;,&quot;float computedZ = (pos.z / pos.w + 1.0) / 2.0;&quot;,&quot;float iz = floor(computedZ * 65535.0 + 0.1);&quot;,&quot;float rf = floor(iz/256.0)/255.0;&quot;,&quot;float gf = mod(iz,256.0)/255.0;&quot;,&quot;gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }&quot;]).result),e.Vertex=a,e.Fragment=i,n.replaceShaderValues(e,r,o)},e.setMapperShaderParameters=(e,r,o)=>{e.getCABO().getElementCount()&&(t.VBOBuildTime>e.getAttributeUpdateTime().getMTime()||e.getShaderSourceTime().getMTime()>e.getAttributeUpdateTime().getMTime())&&(e.getProgram().isAttributeUsed(&quot;orientMC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;orientMC&quot;,12,e.getCABO().getStride(),t.context.FLOAT,3,!1)||_g(&quot;Error setting 'orientMC' in shader VAO.&quot;)),e.getProgram().isAttributeUsed(&quot;offsetMC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO().getColorBO(),&quot;offsetMC&quot;,0,e.getCABO().getColorBOStride(),t.context.UNSIGNED_BYTE,3,!0)||_g(&quot;Error setting 'offsetMC' in shader VAO.&quot;)),e.getProgram().isAttributeUsed(&quot;radiusMC&quot;)&&(e.getVAO().addAttributeArray(e.getProgram(),e.getCABO(),&quot;radiusMC&quot;,24,e.getCABO().getStride(),t.context.FLOAT,1,!1)||_g(&quot;Error setting 'radiusMC' in shader VAO.&quot;))),n.setMapperShaderParameters(e,r,o)},e.setCameraShaderParameters=(e,n,r)=>{const o=e.getProgram(),a=n.getActiveCamera(),i=t.openGLCamera.getKeyMatrices(n);if(o.isUniformUsed(&quot;VCPCMatrix&quot;)&&o.setUniformMatrix(&quot;VCPCMatrix&quot;,i.vcpc),r.getIsIdentity())o.isUniformUsed(&quot;MCVCMatrix&quot;)&&o.setUniformMatrix(&quot;MCVCMatrix&quot;,i.wcvc),o.isUniformUsed(&quot;normalMatrix&quot;)&&o.setUniformMatrix3x3(&quot;normalMatrix&quot;,i.normalMatrix);else{const e=t.openGLActor.getKeyMatrices();if(o.isUniformUsed(&quot;MCVCMatrix&quot;)){const t=new Float64Array(16);b(t,i.wcvc,e.mcwc),o.setUniformMatrix(&quot;MCVCMatrix&quot;,t)}if(o.isUniformUsed(&quot;normalMatrix&quot;)){const t=new Float64Array(9);Te(t,i.normalMatrix,e.normalMatrix),o.setUniformMatrix3x3(&quot;normalMatrix&quot;,t)}}o.isUniformUsed(&quot;cameraParallel&quot;)&&e.getProgram().setUniformi(&quot;cameraParallel&quot;,a.getParallelProjection())},e.getOpenGLMode=(e,n)=>t.context.TRIANGLES,e.buildBufferObjects=(e,n)=>{const r=t.currentInput;if(null===r)return;t.renderable.mapScalars(r,1);const o=t.renderable.getColorMapColors(),a=t.primitives[t.primTypes.Tris].getCABO(),i=r.getPointData(),s=r.getPoints(),l=s.getNumberOfPoints(),c=s.getData();let u=3;u+=4;let d=null,p=0;a.setColorBOStride(4),a.getColorBO()||a.setColorBO(zu.newInstance()),a.getColorBO().setOpenGLRenderWindow(t._openGLRenderWindow),o&&(p=o.getNumberOfComponents(),a.setColorOffset(4),d=o.getData(),a.setColorBOStride(8)),a.setColorComponents(p),a.setStride(28);const f=new Float32Array(7*l*12),g=new Uint8Array(12*l*(d?8:4));let m=null,h=null;null!=t.renderable.getScaleArray()&&i.hasArray(t.renderable.getScaleArray())&&(m=i.getArray(t.renderable.getScaleArray()).getData()),null!=t.renderable.getOrientationArray()&&i.hasArray(t.renderable.getOrientationArray())?h=i.getArray(t.renderable.getOrientationArray()).getData():_g([&quot;Error setting orientationArray.\\n&quot;,&quot;You have to specify the stick orientation&quot;]);const v=[0,1,3,0,3,2,2,3,5,2,5,4];let T=0,y=0,b=0,x=0;for(let e=0;e<l;++e){let n=t.renderable.getLength(),r=t.renderable.getRadius();m&&(n=m[2*e],r=m[2*e+1]);for(let t=0;t<v.length;++t)T=3*e,f[b++]=c[T++],f[b++]=c[T++],f[b++]=c[T++],T=3*e,f[b++]=h[T++]*n,f[b++]=h[T++]*n,f[b++]=h[T++]*n,f[b++]=r,g[x++]=v[t]%2*255,g[x++]=v[t]>=4?255:0,g[x++]=v[t]>=2?255:0,g[x++]=255,y=e*p,d&&(g[x++]=d[y],g[x++]=d[y+1],g[x++]=d[y+2],g[x++]=d[y+3])}a.setElementCount(b/7),a.upload(f,Fu.ARRAY_BUFFER),a.getColorBO().upload(g,Fu.ARRAY_BUFFER),t.VBOBuildTime.modified()}}(e,t)}),&quot;vtkOpenGLStickMapper&quot;);Jt(&quot;vtkStickMapper&quot;,Gg);const Ug=[];Ug[&quot;-&quot;.charCodeAt(0)]=62,Ug[&quot;_&quot;.charCodeAt(0)]=63;const zg=&quot;ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/&quot;;for(let e=0;e<64;e++)Ug[zg.charCodeAt(e)]=e;function Wg(e){return void 0!==Ug[e.charCodeAt(0)]}function Hg(e,t,n,r){const{start:o,count:a}=t,i=a%4,s=Math.floor(a/4);let l=o,c=null,u=n;for(let t=0;t<s;t++){for(;!Wg(e[l]);)l++;for(c=Ug[e.charCodeAt(l++)]<<18;!Wg(e[l]);)l++;for(c|=Ug[e.charCodeAt(l++)]<<12;!Wg(e[l]);)l++;for(c|=Ug[e.charCodeAt(l++)]<<6;!Wg(e[l]);)l++;c|=Ug[e.charCodeAt(l++)],r[u++]=c>>16&255,r[u++]=c>>8&255,r[u++]=255&c}switch(i){case 3:for(;!Wg(e[l]);)l++;for(c=Ug[e.charCodeAt(l++)]<<10;!Wg(e[l]);)l++;for(c|=Ug[e.charCodeAt(l++)]<<4;!Wg(e[l]);)l++;c|=Ug[e.charCodeAt(l++)]>>2,r[u++]=c>>8&255,r[u++]=255&c;break;case 2:for(;!Wg(e[l]);)l++;for(c=Ug[e.charCodeAt(l++)]<<2;!Wg(e[l]);)l++;c|=Ug[e.charCodeAt(l++)]>>4,r[u++]=255&c;break;case 1:throw new Error(&quot;BASE64: remain 1 should not happen&quot;)}return u}function jg(e,t,n){const r=(e<<16)+(t<<8)+n;return zg[r>>18]+zg[r>>12&63]+zg[r>>6&63]+zg[63&r]}function Kg(e){const t=new Uint8Array(e),n=e.byteLength%3,r=e.byteLength-n,o=Array(r/3);for(let e=0;e<o.length;e++){const n=3*e;o[e]=jg(t[n],t[n+1],t[n+2])}if(n>0){const e=jg(t[r],t[r+1]||0,t[r+2]||0);1===n?o.push(`${e.substr(0,2)}==`):2===n&&o.push(`${e.substr(0,3)}=`)}return o.join(&quot;&quot;)}var $g={toArrayBuffer:function(e){const t=function(e){const t=e.length,n=[];let r=null;for(let o=0;o<t;o++)Wg(e[o])?(r||(r={start:o,count:0}),r.count++,r.end=o):&quot;=&quot;===e[o]&&r&&(n.push(r),r=null);return r&&n.push(r),n}(e),n=t[t.length-1].end+1,r=(4-n%4)%4,o=new ArrayBuffer(3*(n+r)/4-r),a=new Uint8Array(o);let i=0;for(let n=0;n<t.length;n++)i+=Hg(e,t[n],i,a),i+=(4-t[n].count%4)%4;return o},fromArrayBuffer:Kg};const qg={};function Xg(e,t){qg[e]=t}var Yg={get:function(){let e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return qg[arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;http&quot;](e)},has:function(e){return!!qg[e]},registerType:Xg},Zg=Uint8Array,Qg=Uint16Array,Jg=Uint32Array,em=new Zg([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),tm=new Zg([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),nm=new Zg([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),rm=function(e,t){for(var n=new Qg(31),r=0;r<31;++r)n[r]=t+=1<<e[r-1];var o=new Jg(n[30]);for(r=1;r<30;++r)for(var a=n[r];a<n[r+1];++a)o[a]=a-n[r]<<5|r;return[n,o]},om=rm(em,2),am=om[0],im=om[1];am[28]=258,im[258]=28;for(var sm=rm(tm,0),lm=sm[0],cm=(sm[1],new Qg(32768)),um=0;um<32768;++um){var dm=(43690&um)>>>1|(21845&um)<<1;dm=(61680&(dm=(52428&dm)>>>2|(13107&dm)<<2))>>>4|(3855&dm)<<4,cm[um]=((65280&dm)>>>8|(255&dm)<<8)>>>1}var pm=function(e,t,n){for(var r=e.length,o=0,a=new Qg(t);o<r;++o)e[o]&&++a[e[o]-1];var i,s=new Qg(t);for(o=0;o<t;++o)s[o]=s[o-1]+a[o-1]<<1;if(n){i=new Qg(1<<t);var l=15-t;for(o=0;o<r;++o)if(e[o])for(var c=o<<4|e[o],u=t-e[o],d=s[e[o]-1]++<<u,p=d|(1<<u)-1;d<=p;++d)i[cm[d]>>>l]=c}else for(i=new Qg(r),o=0;o<r;++o)e[o]&&(i[o]=cm[s[e[o]-1]++]>>>15-e[o]);return i},fm=new Zg(288);for(um=0;um<144;++um)fm[um]=8;for(um=144;um<256;++um)fm[um]=9;for(um=256;um<280;++um)fm[um]=7;for(um=280;um<288;++um)fm[um]=8;var gm=new Zg(32);for(um=0;um<32;++um)gm[um]=5;var mm=pm(fm,9,1),hm=pm(gm,5,1),vm=function(e){for(var t=e[0],n=1;n<e.length;++n)e[n]>t&&(t=e[n]);return t},Tm=function(e,t,n){var r=t/8|0;return(e[r]|e[r+1]<<8)>>(7&t)&n},ym=function(e,t){var n=t/8|0;return(e[n]|e[n+1]<<8|e[n+2]<<16)>>(7&t)},bm=function(e,t,n){(null==t||t<0)&&(t=0),(null==n||n>e.length)&&(n=e.length);var r=new(2==e.BYTES_PER_ELEMENT?Qg:4==e.BYTES_PER_ELEMENT?Jg:Zg)(n-t);return r.set(e.subarray(t,n)),r},xm=[&quot;unexpected EOF&quot;,&quot;invalid block type&quot;,&quot;invalid length/literal&quot;,&quot;invalid distance&quot;,&quot;stream finished&quot;,&quot;no stream handler&quot;,,&quot;no callback&quot;,&quot;invalid UTF-8 data&quot;,&quot;extra field too long&quot;,&quot;date not in range 1980-2099&quot;,&quot;filename too long&quot;,&quot;stream finishing&quot;,&quot;invalid zip data&quot;],Cm=function(e,t,n){var r=new Error(t||xm[e]);if(r.code=e,Error.captureStackTrace&&Error.captureStackTrace(r,Cm),!n)throw r;return r},Sm=function(e,t,n){var r=e.length;if(!r||n&&n.f&&!n.l)return t||new Zg(0);var o=!t||n,a=!n||n.i;n||(n={}),t||(t=new Zg(3*r));var i,s=function(e){var n=t.length;if(e>n){var r=new Zg(Math.max(2*n,e));r.set(t),t=r}},l=n.f||0,c=n.p||0,u=n.b||0,d=n.l,p=n.d,f=n.m,g=n.n,m=8*r;do{if(!d){l=Tm(e,c,1);var h=Tm(e,c+1,3);if(c+=3,!h){var v=e[(i=c,(P=4+((i+7)/8|0))-4)]|e[P-3]<<8,T=P+v;if(T>r){a&&Cm(0);break}o&&s(u+v),t.set(e.subarray(P,T),u),n.b=u+=v,n.p=c=8*T,n.f=l;continue}if(1==h)d=mm,p=hm,f=9,g=5;else if(2==h){var y=Tm(e,c,31)+257,b=Tm(e,c+10,15)+4,x=y+Tm(e,c+5,31)+1;c+=14;for(var C=new Zg(x),S=new Zg(19),A=0;A<b;++A)S[nm[A]]=Tm(e,c+3*A,7);c+=3*b;var I=vm(S),w=(1<<I)-1,O=pm(S,I,1);for(A=0;A<x;){var P,R=O[Tm(e,c,w)];if(c+=15&R,(P=R>>>4)<16)C[A++]=P;else{var M=0,E=0;for(16==P?(E=3+Tm(e,c,3),c+=2,M=C[A-1]):17==P?(E=3+Tm(e,c,7),c+=3):18==P&&(E=11+Tm(e,c,127),c+=7);E--;)C[A++]=M}}var V=C.subarray(0,y),D=C.subarray(y);f=vm(V),g=vm(D),d=pm(V,f,1),p=pm(D,g,1)}else Cm(1);if(c>m){a&&Cm(0);break}}o&&s(u+131072);for(var L=(1<<f)-1,B=(1<<g)-1,N=c;;N=c){var F=(M=d[ym(e,c)&L])>>>4;if((c+=15&M)>m){a&&Cm(0);break}if(M||Cm(2),F<256)t[u++]=F;else{if(256==F){N=c,d=null;break}var _=F-254;if(F>264){var k=em[A=F-257];_=Tm(e,c,(1<<k)-1)+am[A],c+=k}var G=p[ym(e,c)&B],U=G>>>4;if(G||Cm(3),c+=15&G,D=lm[U],U>3&&(k=tm[U],D+=ym(e,c)&(1<<k)-1,c+=k),c>m){a&&Cm(0);break}o&&s(u+131072);for(var z=u+_;u<z;u+=4)t[u]=t[u-D],t[u+1]=t[u+1-D],t[u+2]=t[u+2-D],t[u+3]=t[u+3-D];u=z}}n.l=d,n.p=N,n.b=u,n.f=l,d&&(l=1,n.m=f,n.d=p,n.n=g)}while(!l);return u==t.length?t:bm(t,0,u)},Am=new Zg(0),Im=function(e,t){return e[t]|e[t+1]<<8},wm=function(e,t){return(e[t]|e[t+1]<<8|e[t+2]<<16|e[t+3]<<24)>>>0},Om=function(e,t){return wm(e,t)+4294967296*wm(e,t+4)};function Pm(e,t){return Sm(e,t)}function Rm(e,t){return Sm(e.subarray(function(e){31==e[0]&&139==e[1]&&8==e[2]||Cm(6,&quot;invalid gzip data&quot;);var t=e[3],n=10;4&t&&(n+=e[10]|2+(e[11]<<8));for(var r=(t>>3&1)+(t>>4&1);r>0;r-=!e[n++]);return n+(2&t)}(e),-8),t||new Zg((r=(n=e).length,(n[r-4]|n[r-3]<<8|n[r-2]<<16|n[r-1]<<24)>>>0)));var n,r}function Mm(e,t){return Sm(((8!=(15&(n=e)[0])||n[0]>>>4>7||(n[0]<<8|n[1])%31)&&Cm(6,&quot;invalid zlib data&quot;),32&n[1]&&Cm(6,&quot;invalid zlib data: preset dictionaries not supported&quot;),e.subarray(2,-4)),t);var n}function Em(e,t){return 31==e[0]&&139==e[1]&&8==e[2]?Rm(e,t):8!=(15&e[0])||e[0]>>4>7||(e[0]<<8|e[1])%31?Pm(e,t):Mm(e,t)}var Vm=&quot;undefined&quot;!=typeof TextEncoder&&new TextEncoder,Dm=&quot;undefined&quot;!=typeof TextDecoder&&new TextDecoder;try{Dm.decode(Am,{stream:!0})}catch(e){}function Lm(e,t){if(t){for(var n=&quot;&quot;,r=0;r<e.length;r+=16384)n+=String.fromCharCode.apply(null,e.subarray(r,r+16384));return n}if(Dm)return Dm.decode(e);var o=function(e){for(var t=&quot;&quot;,n=0;;){var r=e[n++],o=(r>127)+(r>223)+(r>239);if(n+o>e.length)return[t,bm(e,n-1)];o?3==o?(r=((15&r)<<18|(63&e[n++])<<12|(63&e[n++])<<6|63&e[n++])-65536,t+=String.fromCharCode(55296|r>>10,56320|1023&r)):t+=1&o?String.fromCharCode((31&r)<<6|63&e[n++]):String.fromCharCode((15&r)<<12|(63&e[n++])<<6|63&e[n++]):t+=String.fromCharCode(r)}}(e),a=o[0];return o[1].length&&Cm(8),a}var Bm=function(e,t){return t+30+Im(e,t+26)+Im(e,t+28)},Nm=function(e,t,n){var r=Im(e,t+28),o=Lm(e.subarray(t+46,t+46+r),!(2048&Im(e,t+8))),a=t+46+r,i=wm(e,t+20),s=n&&4294967295==i?Fm(e,a):[i,wm(e,t+24),wm(e,t+42)],l=s[0],c=s[1],u=s[2];return[Im(e,t+10),l,c,o,a+Im(e,t+30)+Im(e,t+32),u]},Fm=function(e,t){for(;1!=Im(e,t);t+=4+Im(e,t+2));return[Om(e,t+12),Om(e,t+4),Om(e,t+20)]};function _m(e,t){for(var n={},r=e.length-22;101010256!=wm(e,r);--r)(!r||e.length-r>65558)&&Cm(13);var o=Im(e,r+8);if(!o)return{};var a=wm(e,r+16),i=4294967295==a;i&&(r=wm(e,r-12),101075792!=wm(e,r)&&Cm(13),o=wm(e,r+32),a=wm(e,r+48));for(var s=t&&t.filter,l=0;l<o;++l){var c=Nm(e,a,i),u=c[0],d=c[1],p=c[2],f=c[3],g=c[4],m=c[5],h=Bm(e,m);a=g,s&&!s({name:f,size:d,originalSize:p,compression:u})||(u?8==u?n[f]=Pm(e.subarray(h,h+d),new Zg(p)):Cm(14,&quot;unknown compression type &quot;+u):n[f]=bm(e,h,h+d))}return n}function km(){const e=new ArrayBuffer(4),t=new Uint8Array(e),n=new Uint32Array(e);return t[0]=161,t[1]=178,t[2]=195,t[3]=212,3569595041===n[0]?&quot;LittleEndian&quot;:2712847316===n[0]?&quot;BigEndian&quot;:null}&quot;function&quot;==typeof queueMicrotask?queueMicrotask:&quot;function&quot;==typeof setTimeout&&setTimeout;var Gm=km(),Um=function(e,t){if(t<2)return;const n=new Int8Array(e),r=n.length,o=[];for(let e=0;e<r;e+=t){for(let r=0;r<t;r++)o.push(n[e+r]);for(let r=0;r<t;r++)n[e+r]=o.pop()}};const{vtkErrorMacro:zm,vtkDebugMacro:Wm}=Wt;let Hm=0;function jm(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};const r=new XMLHttpRequest;return r.open(e,t,!0),n.headers&&Object.entries(n.headers).forEach((e=>{let[t,n]=e;return r.setRequestHeader(t,n)})),n.progressCallback&&r.addEventListener(&quot;progress&quot;,n.progressCallback),r}const Km={fetchArray:function(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return n.ref&&!n.ref.pending?new Promise(((o,a)=>{let i=null;i=n.ref.url?n.ref.url:[t,n.ref.basepath,r.compression?`${n.ref.id}.gz`:n.ref.id].join(&quot;/&quot;);const s=jm(&quot;GET&quot;,i,r);s.onreadystatechange=t=>{1===s.readyState&&(n.ref.pending=!0,1==++Hm&&e?.invokeBusy&&e.invokeBusy(!0)),4===s.readyState&&(n.ref.pending=!1,200===s.status||0===s.status?(n.buffer=s.response,r.compression&&(&quot;string&quot;===n.dataType||&quot;JSON&quot;===n.dataType?n.buffer=Lm(Em(new Uint8Array(n.buffer))):n.buffer=Em(new Uint8Array(n.buffer)).buffer),&quot;JSON&quot;===n.ref.encode?n.values=JSON.parse(n.buffer):(Gm!==n.ref.encode&&Gm&&(Wm(`Swap bytes of ${n.name}`),Um(n.buffer,ls[n.dataType])),n.values=Wt.newTypedArray(n.dataType,n.buffer)),n.values.length!==n.size&&zm(`Error in FetchArray: ${n.name}, does not have the proper array size. Got ${n.values.length}, instead of ${n.size}`),delete n.ref,0==--Hm&&e?.invokeBusy&&e.invokeBusy(!1),e?.modified&&e.modified(),o(n)):a({xhr:s,e:t}))},s.responseType=r.compression||&quot;string&quot;!==n.dataType?&quot;arraybuffer&quot;:&quot;text&quot;,s.send()})):Promise.resolve(n)},fetchJSON:function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return new Promise(((r,o)=>{const a=jm(&quot;GET&quot;,t,n);a.onreadystatechange=t=>{1===a.readyState&&1==++Hm&&e?.invokeBusy&&e.invokeBusy(!0),4===a.readyState&&(0==--Hm&&e?.invokeBusy&&e.invokeBusy(!1),200===a.status||0===a.status?n.compression?r(JSON.parse(Lm(Em(new Uint8Array(a.response))))):r(JSON.parse(a.responseText)):o({xhr:a,e:t}))},a.responseType=n.compression?&quot;arraybuffer&quot;:&quot;text&quot;,a.send()}))},fetchText:function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return n&&n.compression&&&quot;gz&quot;!==n.compression&&(zm(&quot;Supported algorithms are: [gz]&quot;),zm(`Unkown compression algorithm: ${n.compression}`)),new Promise(((r,o)=>{const a=jm(&quot;GET&quot;,t,n);a.onreadystatechange=t=>{1===a.readyState&&1==++Hm&&e?.invokeBusy&&e.invokeBusy(!0),4===a.readyState&&(0==--Hm&&e?.invokeBusy&&e.invokeBusy(!1),200===a.status||0===a.status?n.compression?r(Lm(Em(new Uint8Array(a.response)))):r(a.responseText):o({xhr:a,e:t}))},a.responseType=n.compression?&quot;arraybuffer&quot;:&quot;text&quot;,a.send()}))},fetchBinary:function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return t&&t.compression&&&quot;gz&quot;!==t.compression&&(zm(&quot;Supported algorithms are: [gz]&quot;),zm(`Unkown compression algorithm: ${t.compression}`)),new Promise(((n,r)=>{const o=jm(&quot;GET&quot;,e,t);o.onreadystatechange=e=>{4===o.readyState&&(200===o.status||0===o.status?t.compression?n(Em(new Uint8Array(o.response)).buffer):n(o.response):r({xhr:o,e:e}))},o.responseType=&quot;arraybuffer&quot;,o.send()}))},fetchImage:function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return new Promise(((e,r)=>{const o=new Image;n.crossOrigin&&(o.crossOrigin=n.crossOrigin),o.onload=()=>e(o),o.onerror=r,o.src=t}))}};Xg(&quot;http&quot;,(e=>Km));const{vtkDebugMacro:$m}=Wt,qm={position:[0,0,1],focalPoint:[0,0,0],viewUp:[0,1,0],directionOfProjection:[0,0,-1],parallelProjection:!1,useHorizontalViewAngle:!1,viewAngle:30,parallelScale:1,clippingRange:[.01,1000.01],windowCenter:[0,0],viewPlaneNormal:[0,0,1],useOffAxisProjection:!1,screenBottomLeft:[-.5,-.5,-.5],screenBottomRight:[.5,-.5,-.5],screenTopRight:[.5,.5,-.5],freezeFocalPoint:!1,projectionMatrix:null,viewMatrix:null,modelTransformMatrix:null,cameraLightTransform:u(),physicalTranslation:[0,0,0],physicalScale:1,physicalViewUp:[0,1,0],physicalViewNorth:[0,0,-1]};function Xm(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,qm,n),Wt.obj(e,t),Wt.get(e,t,[&quot;distance&quot;]),Wt.setGet(e,t,[&quot;parallelProjection&quot;,&quot;useHorizontalViewAngle&quot;,&quot;viewAngle&quot;,&quot;parallelScale&quot;,&quot;useOffAxisProjection&quot;,&quot;freezeFocalPoint&quot;,&quot;physicalScale&quot;]),Wt.getArray(e,t,[&quot;directionOfProjection&quot;,&quot;viewPlaneNormal&quot;,&quot;position&quot;,&quot;focalPoint&quot;]),Wt.setGetArray(e,t,[&quot;clippingRange&quot;,&quot;windowCenter&quot;],2),Wt.setGetArray(e,t,[&quot;viewUp&quot;,&quot;screenBottomLeft&quot;,&quot;screenBottomRight&quot;,&quot;screenTopRight&quot;,&quot;physicalTranslation&quot;,&quot;physicalViewUp&quot;,&quot;physicalViewNorth&quot;],3),function(e,t){t.classHierarchy.push(&quot;vtkCamera&quot;);const n=new Float64Array(3),r=new Float64Array([0,0,-1]),o=new Float64Array([0,1,0]),a=m(new Float64Array(16)),i=m(new Float64Array(16)),s=new Float64Array(3),l=new Float64Array(3),c=new Float64Array(3),u=m(new Float64Array(16)),d=m(new Float64Array(16)),f=new Float64Array(3),g=new Float64Array(3);function T(){t.viewPlaneNormal[0]=-t.directionOfProjection[0],t.viewPlaneNormal[1]=-t.directionOfProjection[1],t.viewPlaneNormal[2]=-t.directionOfProjection[2]}e.orthogonalizeViewUp=()=>{const n=e.getViewMatrix();t.viewUp[0]=n[4],t.viewUp[1]=n[5],t.viewUp[2]=n[6],e.modified()},e.setPosition=(n,r,o)=>{n===t.position[0]&&r===t.position[1]&&o===t.position[2]||(t.position[0]=n,t.position[1]=r,t.position[2]=o,e.computeDistance(),e.modified())},e.setFocalPoint=(n,r,o)=>{n===t.focalPoint[0]&&r===t.focalPoint[1]&&o===t.focalPoint[2]||(t.focalPoint[0]=n,t.focalPoint[1]=r,t.focalPoint[2]=o,e.computeDistance(),e.modified())},e.setDistance=n=>{if(t.distance===n)return;t.distance=n,t.distance<1e-20&&(t.distance=1e-20,$m(&quot;Distance is set to minimum.&quot;));const r=t.directionOfProjection;t.focalPoint[0]=t.position[0]+r[0]*t.distance,t.focalPoint[1]=t.position[1]+r[1]*t.distance,t.focalPoint[2]=t.position[2]+r[2]*t.distance,e.modified()},e.computeDistance=()=>{const e=t.focalPoint[0]-t.position[0],n=t.focalPoint[1]-t.position[1],r=t.focalPoint[2]-t.position[2];if(t.distance=Math.sqrt(e*e+n*n+r*r),t.distance<1e-20){t.distance=1e-20,$m(&quot;Distance is set to minimum.&quot;);const e=t.directionOfProjection;t.focalPoint[0]=t.position[0]+e[0]*t.distance,t.focalPoint[1]=t.position[1]+e[1]*t.distance,t.focalPoint[2]=t.position[2]+e[2]*t.distance}t.directionOfProjection[0]=e/t.distance,t.directionOfProjection[1]=n/t.distance,t.directionOfProjection[2]=r/t.distance,T()},e.dolly=n=>{if(n<=0)return;const r=t.distance/n;e.setPosition(t.focalPoint[0]-r*t.directionOfProjection[0],t.focalPoint[1]-r*t.directionOfProjection[1],t.focalPoint[2]-r*t.directionOfProjection[2])},e.roll=n=>{const r=t.position,o=t.focalPoint,a=t.viewUp,i=new Float64Array([a[0],a[1],a[2],0]);m(u);const s=new Float64Array([o[0]-r[0],o[1]-r[1],o[2]-r[2]]);S(u,u,vo(n),s),La(i,i,u),t.viewUp[0]=i[0],t.viewUp[1]=i[1],t.viewUp[2]=i[2],e.modified()},e.azimuth=n=>{const r=t.focalPoint;m(d),x(d,d,r),S(d,d,vo(n),t.viewUp),x(d,d,[-r[0],-r[1],-r[2]]),In(f,t.position,d),e.setPosition(f[0],f[1],f[2])},e.yaw=n=>{const r=t.position;m(d),x(d,d,r),S(d,d,vo(n),t.viewUp),x(d,d,[-r[0],-r[1],-r[2]]),In(g,t.focalPoint,d),e.setFocalPoint(g[0],g[1],g[2])},e.elevation=n=>{const r=t.focalPoint,o=e.getViewMatrix(),a=[-o[0],-o[1],-o[2]];m(d),x(d,d,r),S(d,d,vo(n),a),x(d,d,[-r[0],-r[1],-r[2]]),In(f,t.position,d),e.setPosition(f[0],f[1],f[2])},e.pitch=n=>{const r=t.position,o=e.getViewMatrix(),a=[o[0],o[1],o[2]];m(d),x(d,d,r),S(d,d,vo(n),a),x(d,d,[-r[0],-r[1],-r[2]]),In(g,t.focalPoint,d),e.setFocalPoint(...g)},e.zoom=n=>{n<=0||(t.parallelProjection?t.parallelScale/=n:t.viewAngle/=n,e.modified())},e.translate=(n,r,o)=>{const a=[n,r,o];Ro(t.position,a,t.position),Ro(t.focalPoint,a,t.focalPoint),e.computeDistance(),e.modified()},e.applyTransform=n=>{const r=[...t.viewUp,1],o=[],a=[],i=[];r[0]+=t.position[0],r[1]+=t.position[1],r[2]+=t.position[2],La(o,[...t.position,1],n),La(a,[...t.focalPoint,1],n),La(i,r,n),i[0]-=o[0],i[1]-=o[1],i[2]-=o[2],e.setPosition(...o.slice(0,3)),e.setFocalPoint(...a.slice(0,3)),e.setViewUp(...i.slice(0,3))},e.getThickness=()=>t.clippingRange[1]-t.clippingRange[0],e.setThickness=n=>{let r=n;r<1e-20&&(r=1e-20,$m(&quot;Thickness is set to minimum.&quot;)),e.setClippingRange(t.clippingRange[0],t.clippingRange[0]+r)},e.setThicknessFromFocalPoint=n=>{let r=n;r<1e-20&&(r=1e-20,$m(&quot;Thickness is set to minimum.&quot;)),e.setClippingRange(t.distance-r/2,t.distance+r/2)},e.setRoll=e=>{},e.getRoll=()=>{},e.setObliqueAngles=(e,t)=>{},e.getOrientation=()=>{},e.getOrientationWXYZ=()=>{},e.getFrustumPlanes=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:1,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:new Float64Array(24);const r=[[1,0,0,1],[-1,0,0,1],[0,1,0,1],[0,-1,0,1],[0,0,1,1],[0,0,-1,1]],o=e.getCompositeProjectionMatrix(t,-1,1);for(let e=0;e<6;e++)La(r[e],r[e],o),_o(r[e]),n[4*e+0]=r[e][0],n[4*e+1]=r[e][1],n[4*e+2]=r[e][2],n[4*e+3]=r[e][3];return n},e.getCameraLightTransformMatrix=e=>(p(e,t.cameraLightTransform),e),e.computeCameraLightTransform=()=>{p(a,e.getViewMatrix()),v(a,a),P(i,[t.distance,t.distance,t.distance]),b(a,a,i),m(t.cameraLightTransform),x(t.cameraLightTransform,a,[0,0,-1])},e.deepCopy=e=>{},e.physicalOrientationToWorldDirection=e=>{const t=_a(e[0],e[1],e[2],e[3]),n=Ba(),r=_a(0,0,1,0);var o,a;return a=t,(o=n)[0]=-a[0],o[1]=-a[1],o[2]=-a[2],o[3]=a[3],Fa(r,t,r),Fa(r,r,n),[r[0],r[1],r[2]]},e.getPhysicalToWorldMatrix=t=>{e.getWorldToPhysicalMatrix(t),v(t,t)},e.getWorldToPhysicalMatrix=e=>{m(e);const n=[3];Bo(t.physicalViewNorth,t.physicalViewUp,n),e[0]=n[0],e[1]=n[1],e[2]=n[2],e[4]=t.physicalViewUp[0],e[5]=t.physicalViewUp[1],e[6]=t.physicalViewUp[2],e[8]=-t.physicalViewNorth[0],e[9]=-t.physicalViewNorth[1],e[10]=-t.physicalViewNorth[2],h(e,e),hn(s,1/t.physicalScale,1/t.physicalScale,1/t.physicalScale),C(e,e,s),x(e,e,t.physicalTranslation)},e.computeViewParametersFromViewMatrix=i=>{v(a,i),In(s,n,a),e.computeDistance();const u=t.distance;e.setPosition(s[0],s[1],s[2]),In(l,r,a),Tn(l,l,s),Cn(l,l),e.setDirectionOfProjection(l[0],l[1],l[2]),In(c,o,a),Tn(c,c,s),Cn(c,c),e.setViewUp(c[0],c[1],c[2]),e.setDistance(u)},e.computeViewParametersFromPhysicalMatrix=t=>{e.getWorldToPhysicalMatrix(a),b(a,t,a),e.computeViewParametersFromViewMatrix(a)},e.setModelTransformMatrix=e=>{t.modelTransformMatrix=e},e.getModelTransformMatrix=()=>t.modelTransformMatrix,e.setViewMatrix=n=>{t.viewMatrix=n,t.viewMatrix&&(p(a,t.viewMatrix),e.computeViewParametersFromViewMatrix(a),h(t.viewMatrix,t.viewMatrix))},e.getViewMatrix=()=>{if(t.viewMatrix)return t.modelTransformMatrix?(b(a,t.viewMatrix,t.modelTransformMatrix),a):t.viewMatrix;X(a,t.position,t.focalPoint,t.viewUp),h(a,a);const e=new Float64Array(16);return t.modelTransformMatrix?b(e,a,t.modelTransformMatrix):p(e,a),e},e.setProjectionMatrix=e=>{t.projectionMatrix=e},e.getProjectionMatrix=(e,n,r)=>{const o=new Float64Array(16);if(m(o),t.projectionMatrix){const e=1/t.physicalScale;return hn(s,e,e,e),p(o,t.projectionMatrix),C(o,o,s),h(o,o),o}m(a);const i=t.clippingRange[1]-t.clippingRange[0],l=[t.clippingRange[0]+(n+1)*i/2,t.clippingRange[0]+(r+1)*i/2];if(t.parallelProjection){const n=t.parallelScale*e,r=t.parallelScale,o=(t.windowCenter[0]-1)*n,i=(t.windowCenter[0]+1)*n,s=(t.windowCenter[1]-1)*r,c=(t.windowCenter[1]+1)*r;$(a,o,i,s,c,l[0],l[1]),h(a,a)}else{if(t.useOffAxisProjection)throw new Error(&quot;Off-Axis projection is not supported at this time&quot;);{const n=Math.tan(vo(t.viewAngle)/2);let r,o;!0===t.useHorizontalViewAngle?(r=t.clippingRange[0]*n,o=t.clippingRange[0]*n/e):(r=t.clippingRange[0]*n*e,o=t.clippingRange[0]*n);const i=(t.windowCenter[0]-1)*r,s=(t.windowCenter[0]+1)*r,c=(t.windowCenter[1]-1)*o,u=(t.windowCenter[1]+1)*o,d=l[0],p=l[1];a[0]=2*d/(s-i),a[5]=2*d/(u-c),a[2]=(i+s)/(s-i),a[6]=(c+u)/(u-c),a[10]=-(d+p)/(p-d),a[14]=-1,a[11]=-2*d*p/(p-d),a[15]=0}}return p(o,a),o},e.getCompositeProjectionMatrix=(t,n,r)=>{const o=e.getViewMatrix(),a=e.getProjectionMatrix(t,n,r);return b(a,o,a),a},e.setDirectionOfProjection=(e,n,r)=>{if(t.directionOfProjection[0]===e&&t.directionOfProjection[1]===n&&t.directionOfProjection[2]===r)return;t.directionOfProjection[0]=e,t.directionOfProjection[1]=n,t.directionOfProjection[2]=r;const o=t.directionOfProjection;t.focalPoint[0]=t.position[0]+o[0]*t.distance,t.focalPoint[1]=t.position[1]+o[1]*t.distance,t.focalPoint[2]=t.position[2]+o[2]*t.distance,T()},e.setDeviceAngles=(n,r,o,a)=>{const i=[3];Bo(t.physicalViewNorth,t.physicalViewUp,i);const s=m(new Float64Array(16));S(s,s,vo(n),t.physicalViewUp),S(s,s,vo(r),i),S(s,s,vo(o),t.physicalViewNorth),S(s,s,vo(-a),t.physicalViewUp);const l=new Float64Array([-t.physicalViewUp[0],-t.physicalViewUp[1],-t.physicalViewUp[2]]),c=new Float64Array(t.physicalViewNorth);In(l,l,s),In(c,c,s),e.setDirectionOfProjection(l[0],l[1],l[2]),e.setViewUp(c[0],c[1],c[2]),e.modified()},e.setOrientationWXYZ=(t,n,r,o)=>{const a=m(new Float64Array(16));if(0!==t&&(0!==n||0!==r||0!==o)){const e=vo(t),i=Ba();Na(i,[n,r,o],e),G(a,i)}const i=new Float64Array(3);In(i,[0,0,-1],a);const s=new Float64Array(3);In(s,[0,1,0],a),e.setDirectionOfProjection(...i),e.setViewUp(...s),e.modified()},e.computeClippingRange=e=>{let n=null,r=null;n=t.viewPlaneNormal,r=t.position;const o=-n[0],a=-n[1],i=-n[2],s=-(o*r[0]+a*r[1]+i*r[2]),l=[o*e[0]+a*e[2]+i*e[4]+s,1e-18];for(let t=0;t<2;t++)for(let n=0;n<2;n++)for(let r=0;r<2;r++){const c=o*e[r]+a*e[2+n]+i*e[4+t]+s;l[0]=c<l[0]?c:l[0],l[1]=c>l[1]?c:l[1]}return l}}(e,t)}var Ym={newInstance:Wt.newInstance(Xm,&quot;vtkCamera&quot;),extend:Xm};const Zm={switch:!0,intensity:1,color:[1,1,1],position:[0,0,1],focalPoint:[0,0,0],positional:!1,exponent:1,coneAngle:30,coneFalloff:5,attenuationValues:[1,0,0],transformMatrix:null,lightType:&quot;SceneLight&quot;,shadowAttenuation:1,direction:[0,0,0],directionMTime:0};function Qm(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Zm,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;intensity&quot;,&quot;switch&quot;,&quot;positional&quot;,&quot;exponent&quot;,&quot;coneAngle&quot;,&quot;coneFalloff&quot;,&quot;transformMatrix&quot;,&quot;lightType&quot;,&quot;shadowAttenuation&quot;,&quot;attenuationValues&quot;]),Wt.setGetArray(e,t,[&quot;color&quot;,&quot;position&quot;,&quot;focalPoint&quot;,&quot;attenuationValues&quot;],3),function(e,t){t.classHierarchy.push(&quot;vtkLight&quot;);const n=new Float64Array(3);e.getTransformedPosition=()=>(t.transformMatrix?In(n,t.position,t.transformMatrix):hn(n,t.position[0],t.position[1],t.position[2]),n),e.getTransformedFocalPoint=()=>(t.transformMatrix?In(n,t.focalPoint,t.transformMatrix):hn(n,t.focalPoint[0],t.focalPoint[1],t.focalPoint[2]),n),e.getDirection=()=>(t.directionMTime<t.mtime&&(Rn(t.direction,t.focalPoint,t.position),Fo(t.direction),t.directionMTime=t.mtime),t.direction),e.setDirection=e=>{const n=new Float64Array(3);Rn(n,t.position,e),t.focalPoint=n},e.setDirectionAngle=(t,n)=>{const r=vo(t),o=vo(n);e.setPosition(Math.cos(r)*Math.sin(o),Math.sin(r),Math.cos(r)*Math.cos(o)),e.setFocalPoint(0,0,0),e.setPositional(0)},e.setLightTypeToHeadLight=()=>{e.setLightType(&quot;HeadLight&quot;)},e.setLightTypeToCameraLight=()=>{e.setLightType(&quot;CameraLight&quot;)},e.setLightTypeToSceneLight=()=>{e.setTransformMatrix(null),e.setLightType(&quot;SceneLight&quot;)},e.lightTypeIsHeadLight=()=>&quot;HeadLight&quot;===t.lightType,e.lightTypeIsSceneLight=()=>&quot;SceneLight&quot;===t.lightType,e.lightTypeIsCameraLight=()=>&quot;CameraLight&quot;===t.lightType}(e,t)}var Jm={newInstance:Wt.newInstance(Qm,&quot;vtkLight&quot;),extend:Qm,LIGHT_TYPES:[&quot;HeadLight&quot;,&quot;CameraLight&quot;,&quot;SceneLight&quot;]};const{vtkErrorMacro:eh}=Wt;const th={background:[0,0,0],background2:[.2,.2,.2],gradientBackground:!1,viewport:[0,0,1,1],aspect:[1,1],pixelAspect:[1,1],props:[],actors2D:[]};function nh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,th,n),Wt.obj(e,t),Wt.event(e,t,&quot;event&quot;),Wt.setGetArray(e,t,[&quot;viewport&quot;],4),Wt.setGetArray(e,t,[&quot;background&quot;,&quot;background2&quot;],3),function(e,t){function n(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];t.push(e);const r=e.getNestedProps();if(r&&r.length)for(let e=0;e<r.length;e++)n(r[e],t);return t}t.classHierarchy.push(&quot;vtkViewport&quot;),e.getViewProps=()=>t.props,e.hasViewProp=e=>t.props.includes(e),e.addViewProp=n=>{n&&!e.hasViewProp(n)&&t.props.push(n)},e.removeViewProp=e=>{const n=t.props.filter((t=>t!==e));t.props.length!==n.length&&(t.props=n)},e.removeAllViewProps=()=>{t.props=[]},e.getViewPropsWithNestedProps=()=>{let r=[];const o=e.getActors2D();o.sort(((e,t)=>e.getLayerNumber()-t.getLayerNumber()));const a=t.props.filter((e=>!o.includes(e)));for(let e=0;e<a.length;e++)n(a[e],r);return r=r.concat(o),r},e.addActor2D=e.addViewProp,e.removeActor2D=t=>{e.removeViewProp(t)},e.getActors2D=()=>(t.actors2D=[],t.props.forEach((e=>{t.actors2D=t.actors2D.concat(e.getActors2D())})),t.actors2D),e.displayToView=()=>eh(&quot;call displayToView on your view instead&quot;),e.viewToDisplay=()=>eh(&quot;callviewtodisplay on your view instead&quot;),e.getSize=()=>eh(&quot;call getSize on your View instead&quot;),e.normalizedDisplayToProjection=(t,n,r)=>{const o=e.normalizedDisplayToNormalizedViewport(t,n,r);return e.normalizedViewportToProjection(o[0],o[1],o[2])},e.normalizedDisplayToNormalizedViewport=(e,n,r)=>{const o=[t.viewport[2]-t.viewport[0],t.viewport[3]-t.viewport[1]];return[(e-t.viewport[0])/o[0],(n-t.viewport[1])/o[1],r]},e.normalizedViewportToProjection=(e,t,n)=>[2*e-1,2*t-1,2*n-1],e.projectionToNormalizedDisplay=(t,n,r)=>{const o=e.projectionToNormalizedViewport(t,n,r);return e.normalizedViewportToNormalizedDisplay(o[0],o[1],o[2])},e.normalizedViewportToNormalizedDisplay=(e,n,r)=>{const o=[t.viewport[2]-t.viewport[0],t.viewport[3]-t.viewport[1]];return[e*o[0]+t.viewport[0],n*o[1]+t.viewport[1],r]},e.projectionToNormalizedViewport=(e,t,n)=>[.5*(e+1),.5*(t+1),.5*(n+1)],e.PickPropFrom=()=>eh(&quot;vtkViewport::PickPropFrom - NOT IMPLEMENTED&quot;)}(e,t)}var rh={newInstance:Wt.newInstance(nh,&quot;vtkViewport&quot;),extend:nh};const{vtkDebugMacro:oh,vtkErrorMacro:ah,vtkWarningMacro:ih}=Ht;function sh(e){return()=>ah(`vtkRenderer::${e} - NOT IMPLEMENTED`)}const lh={pickedProp:null,activeCamera:null,allBounds:[],ambient:[1,1,1],allocatedRenderTime:100,timeFactor:1,automaticLightCreation:!0,twoSidedLighting:!0,lastRenderTimeInSeconds:-1,renderWindow:null,lights:[],actors:[],volumes:[],lightFollowCamera:!0,numberOfPropsRendered:0,propArray:null,pathArray:null,layer:0,preserveColorBuffer:!1,preserveDepthBuffer:!1,computeVisiblePropBounds:Pa(),interactive:!0,nearClippingPlaneTolerance:0,clippingRangeExpansion:.05,erase:!0,draw:!0,useShadows:!1,useDepthPeeling:!1,occlusionRatio:0,maximumNumberOfPeels:4,selector:null,delegate:null,texturedBackground:!1,backgroundTexture:null,environmentTexture:null,environmentTextureDiffuseStrength:1,environmentTextureSpecularStrength:1,useEnvironmentTextureAsBackground:!1,pass:0};function ch(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};for(Object.assign(t,lh,n),rh.extend(e,t,n),t.background||(t.background=[0,0,0,1]);t.background.length<3;)t.background.push(0);3===t.background.length&&t.background.push(1),Tt(e,t,[&quot;_renderWindow&quot;,&quot;allocatedRenderTime&quot;,&quot;timeFactor&quot;,&quot;lastRenderTimeInSeconds&quot;,&quot;numberOfPropsRendered&quot;,&quot;lastRenderingUsedDepthPeeling&quot;,&quot;selector&quot;]),Ct(e,t,[&quot;twoSidedLighting&quot;,&quot;lightFollowCamera&quot;,&quot;automaticLightCreation&quot;,&quot;erase&quot;,&quot;draw&quot;,&quot;nearClippingPlaneTolerance&quot;,&quot;clippingRangeExpansion&quot;,&quot;backingStore&quot;,&quot;interactive&quot;,&quot;layer&quot;,&quot;preserveColorBuffer&quot;,&quot;preserveDepthBuffer&quot;,&quot;useDepthPeeling&quot;,&quot;occlusionRatio&quot;,&quot;maximumNumberOfPeels&quot;,&quot;delegate&quot;,&quot;backgroundTexture&quot;,&quot;texturedBackground&quot;,&quot;environmentTexture&quot;,&quot;environmentTextureDiffuseStrength&quot;,&quot;environmentTextureSpecularStrength&quot;,&quot;useEnvironmentTextureAsBackground&quot;,&quot;useShadows&quot;,&quot;pass&quot;]),St(e,t,[&quot;actors&quot;,&quot;volumes&quot;,&quot;lights&quot;]),It(e,t,[&quot;background&quot;],4,1),wt(0,t,[&quot;renderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkRenderer&quot;);const n={type:&quot;ComputeVisiblePropBoundsEvent&quot;,renderer:e},r={type:&quot;ResetCameraClippingRangeEvent&quot;,renderer:e},o={type:&quot;ResetCameraEvent&quot;,renderer:e};e.updateCamera=()=>(t.activeCamera||(oh(&quot;No cameras are on, creating one.&quot;),e.getActiveCameraAndResetIfCreated()),t.activeCamera.render(e),!0),e.updateLightsGeometryToFollowCamera=()=>{const n=e.getActiveCameraAndResetIfCreated();t.lights.forEach((e=>{e.lightTypeIsSceneLight()||(e.lightTypeIsHeadLight()?(e.setPositionFrom(n.getPositionByReference()),e.setFocalPointFrom(n.getFocalPointByReference()),e.modified(n.getMTime())):e.lightTypeIsCameraLight()?e.setTransformMatrix(n.getCameraLightTransformMatrix(u())):ah(&quot;light has unknown light type&quot;,e.get()))}))},e.updateLightGeometry=()=>!t.lightFollowCamera||e.updateLightsGeometryToFollowCamera(),e.allocateTime=sh(&quot;allocateTime&quot;),e.updateGeometry=sh(&quot;updateGeometry&quot;),e.getVTKWindow=()=>t._renderWindow,e.setLayer=n=>{oh(e.getClassName(),e,&quot;setting Layer to &quot;,n),t.layer!==n&&(t.layer=n,e.modified()),e.setPreserveColorBuffer(!!n)},e.setActiveCamera=n=>t.activeCamera!==n&&(t.activeCamera=n,e.modified(),e.invokeEvent({type:&quot;ActiveCameraEvent&quot;,camera:n}),!0),e.makeCamera=()=>{const t=Ym.newInstance();return e.invokeEvent({type:&quot;CreateCameraEvent&quot;,camera:t}),t},e.getActiveCamera=()=>(t.activeCamera||(t.activeCamera=e.makeCamera()),t.activeCamera),e.getActiveCameraAndResetIfCreated=()=>(t.activeCamera||(e.getActiveCamera(),e.resetCamera()),t.activeCamera),e.getActors=()=>(t.actors=[],t.props.forEach((e=>{t.actors=t.actors.concat(e.getActors())})),t.actors),e.addActor=e.addViewProp,e.removeActor=n=>{t.actors=t.actors.filter((e=>e!==n)),e.removeViewProp(n),e.modified()},e.removeAllActors=()=>{e.getActors().forEach((t=>{e.removeViewProp(t)})),t.actors=[],e.modified()},e.getVolumes=()=>(t.volumes=[],t.props.forEach((e=>{t.volumes=t.volumes.concat(e.getVolumes())})),t.volumes),e.addVolume=e.addViewProp,e.removeVolume=n=>{t.volumes=t.volumes.filter((e=>e!==n)),e.removeViewProp(n),e.modified()},e.removeAllVolumes=()=>{e.getVolumes().forEach((t=>{e.removeViewProp(t)})),t.volumes=[],e.modified()},e.hasLight=e=>t.lights.includes(e),e.addLight=n=>{n&&!e.hasLight(n)&&(t.lights.push(n),e.modified())},e.removeLight=n=>{t.lights=t.lights.filter((e=>e!==n)),e.modified()},e.removeAllLights=()=>{t.lights=[],e.modified()},e.setLightCollection=n=>{t.lights=n,e.modified()},e.makeLight=Jm.newInstance,e.createLight=()=>{t.automaticLightCreation&&(t._createdLight&&(e.removeLight(t._createdLight),t._createdLight.delete(),t._createdLight=null),t._createdLight=e.makeLight(),e.addLight(t._createdLight),t._createdLight.setLightTypeToHeadLight(),t._createdLight.setPosition(e.getActiveCamera().getPosition()),t._createdLight.setFocalPoint(e.getActiveCamera().getFocalPoint()))},e.normalizedDisplayToWorld=(t,n,r,o)=>{let a=e.normalizedDisplayToProjection(t,n,r);return a=e.projectionToView(a[0],a[1],a[2],o),e.viewToWorld(a[0],a[1],a[2])},e.worldToNormalizedDisplay=(t,n,r,o)=>{let a=e.worldToView(t,n,r);return a=e.viewToProjection(a[0],a[1],a[2],o),e.projectionToNormalizedDisplay(a[0],a[1],a[2])},e.viewToWorld=(e,n,r)=>{if(null===t.activeCamera)return ah(&quot;ViewToWorld: no active camera, cannot compute view to world, returning 0,0,0&quot;),[0,0,0];const o=t.activeCamera.getViewMatrix();v(o,o),h(o,o);const a=new Float64Array([e,n,r]);return In(a,a,o),a},e.projectionToView=(e,n,r,o)=>{if(null===t.activeCamera)return ah(&quot;ProjectionToView: no active camera, cannot compute projection to view, returning 0,0,0&quot;),[0,0,0];const a=t.activeCamera.getProjectionMatrix(o,-1,1);v(a,a),h(a,a);const i=new Float64Array([e,n,r]);return In(i,i,a),i},e.worldToView=(e,n,r)=>{if(null===t.activeCamera)return ah(&quot;WorldToView: no active camera, cannot compute view to world, returning 0,0,0&quot;),[0,0,0];const o=t.activeCamera.getViewMatrix();h(o,o);const a=new Float64Array([e,n,r]);return In(a,a,o),a},e.viewToProjection=(e,n,r,o)=>{if(null===t.activeCamera)return ah(&quot;ViewToProjection: no active camera, cannot compute view to projection, returning 0,0,0&quot;),[0,0,0];const a=t.activeCamera.getProjectionMatrix(o,-1,1);h(a,a);const i=new Float64Array([e,n,r]);return In(i,i,a),i},e.computeVisiblePropBounds=()=>{t.allBounds[0]=Gi.INIT_BOUNDS[0],t.allBounds[1]=Gi.INIT_BOUNDS[1],t.allBounds[2]=Gi.INIT_BOUNDS[2],t.allBounds[3]=Gi.INIT_BOUNDS[3],t.allBounds[4]=Gi.INIT_BOUNDS[4],t.allBounds[5]=Gi.INIT_BOUNDS[5];let r=!0;e.invokeEvent(n);for(let e=0;e<t.props.length;++e){const n=t.props[e];if(n.getVisibility()&&n.getUseBounds()){const e=n.getBounds();e&&ya(e)&&(r=!1,e[0]<t.allBounds[0]&&(t.allBounds[0]=e[0]),e[1]>t.allBounds[1]&&(t.allBounds[1]=e[1]),e[2]<t.allBounds[2]&&(t.allBounds[2]=e[2]),e[3]>t.allBounds[3]&&(t.allBounds[3]=e[3]),e[4]<t.allBounds[4]&&(t.allBounds[4]=e[4]),e[5]>t.allBounds[5]&&(t.allBounds[5]=e[5]))}}return r&&(Ta(t.allBounds),oh(&quot;Can't compute bounds, no 3D props are visible&quot;)),t.allBounds},e.resetCamera=function(){const n=(arguments.length>0&&void 0!==arguments[0]?arguments[0]:null)||e.computeVisiblePropBounds(),r=[0,0,0];if(!ya(n))return oh(&quot;Cannot reset camera!&quot;),!1;let a=null;if(!e.getActiveCamera())return ah(&quot;Trying to reset non-existent camera&quot;),!1;a=t.activeCamera.getViewPlaneNormal(),t.activeCamera.setViewAngle(30),r[0]=(n[0]+n[1])/2,r[1]=(n[2]+n[3])/2,r[2]=(n[4]+n[5])/2;let i=n[1]-n[0],s=n[3]-n[2],l=n[5]-n[4];i*=i,s*=s,l*=l;let c=i+s+l;c=0===c?1:c,c=.5*Math.sqrt(c);const u=vo(t.activeCamera.getViewAngle()),d=c,p=c/Math.sin(.5*u),f=t.activeCamera.getViewUp();return Math.abs(Lo(f,a))>.999&&(ih(&quot;Resetting view-up since view plane normal is parallel&quot;),t.activeCamera.setViewUp(-f[2],f[0],f[1])),t.activeCamera.setFocalPoint(r[0],r[1],r[2]),t.activeCamera.setPosition(r[0]+p*a[0],r[1]+p*a[1],r[2]+p*a[2]),e.resetCameraClippingRange(n),t.activeCamera.setParallelScale(d),t.activeCamera.setPhysicalScale(c),t.activeCamera.setPhysicalTranslation(-r[0],-r[1],-r[2]),e.invokeEvent(o),!0},e.resetCameraClippingRange=function(){const n=(arguments.length>0&&void 0!==arguments[0]?arguments[0]:null)||e.computeVisiblePropBounds();if(!ya(n))return oh(&quot;Cannot reset camera clipping range!&quot;),!1;if(e.getActiveCameraAndResetIfCreated(),!t.activeCamera)return ah(&quot;Trying to reset clipping range of non-existent camera&quot;),!1;const o=t.activeCamera.computeClippingRange(n);let a=0;if(t.activeCamera.getParallelProjection())a=.2*t.activeCamera.getParallelScale();else{const e=vo(t.activeCamera.getViewAngle());a=.2*Math.tan(e/2)*o[1]}return o[1]-o[0]<a&&(a=a-o[1]+o[0],o[1]+=a/2,o[0]-=a/2),o[0]<0&&(o[0]=0),o[0]=.99*o[0]-(o[1]-o[0])*t.clippingRangeExpansion,o[1]=1.01*o[1]+(o[1]-o[0])*t.clippingRangeExpansion,o[0]=o[0]>=o[1]?.01*o[1]:o[0],t.nearClippingPlaneTolerance||(t.nearClippingPlaneTolerance=.01),o[0]<t.nearClippingPlaneTolerance*o[1]&&(o[0]=t.nearClippingPlaneTolerance*o[1]),t.activeCamera.setClippingRange(o[0],o[1]),e.invokeEvent(r),!1},e.setRenderWindow=e=>{e!==t._renderWindow&&(t._vtkWindow=e,t._renderWindow=e)},e.visibleActorCount=()=>t.props.filter((e=>e.getVisibility())).length,e.visibleVolumeCount=e.visibleActorCount,e.getMTime=()=>{let e=t.mtime;const n=t.activeCamera?t.activeCamera.getMTime():0;n>e&&(e=n);const r=t._createdLight?t._createdLight.getMTime():0;return r>e&&(e=r),e},e.getTransparent=()=>!!t.preserveColorBuffer,e.isActiveCameraCreated=()=>!!t.activeCamera}(e,t)}var uh={newInstance:Mt(ch,&quot;vtkRenderer&quot;),extend:ch};const dh=Object.create(null);function ph(e,t){dh[e]=t}function fh(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return dh[e]&&dh[e](t)}const gh={defaultViewAPI:&quot;WebGL&quot;,renderers:[],views:[],interactor:null,neverRendered:!0,numberOfLayers:1,childRenderWindows:[]};function mh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,gh,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;interactor&quot;,&quot;numberOfLayers&quot;,&quot;_views&quot;,&quot;defaultViewAPI&quot;]),Wt.get(e,t,[&quot;neverRendered&quot;]),Wt.getArray(e,t,[&quot;renderers&quot;,&quot;childRenderWindows&quot;]),Wt.moveToProtected(e,t,[&quot;views&quot;]),Wt.event(e,t,&quot;completion&quot;),function(e,t){t.classHierarchy.push(&quot;vtkRenderWindow&quot;),e.addRenderer=n=>{e.hasRenderer(n)||(n.setRenderWindow(e),t.renderers.push(n),e.modified())},e.removeRenderer=n=>{t.renderers=t.renderers.filter((e=>e!==n)),e.modified()},e.hasRenderer=e=>-1!==t.renderers.indexOf(e),e.newAPISpecificView=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return fh(e||t.defaultViewAPI,n)},e.addView=n=>{e.hasView(n)||(n.setRenderable(e),t._views.push(n),e.modified())},e.removeView=n=>{t._views=t._views.filter((e=>e!==n)),e.modified()},e.hasView=e=>-1!==t._views.indexOf(e),e.preRender=()=>{t.renderers.forEach((e=>{e.isActiveCameraCreated()||e.resetCamera()}))},e.render=()=>{e.preRender(),t.interactor?t.interactor.render():t._views.forEach((e=>e.traverseAllPasses()))},e.getStatistics=()=>{const e={propCount:0,invisiblePropCount:0,gpuMemoryMB:0};return t._views.forEach((t=>{t.getGraphicsMemoryInfo&&(e.gpuMemoryMB+=t.getGraphicsMemoryInfo()/1e6)})),t.renderers.forEach((n=>{const r=n.getViewProps(),o=t._views[0].getViewNodeFor(n);r.forEach((t=>{if(t.getVisibility()){e.propCount+=1;const n=t.getMapper&&t.getMapper();if(n&&n.getPrimitiveCount){const t=o.getViewNodeFor(n);if(t){t.getAllocatedGPUMemoryInBytes&&(e.gpuMemoryMB+=t.getAllocatedGPUMemoryInBytes()/1e6);const r=n.getPrimitiveCount();Object.keys(r).forEach((t=>{e[t]||(e[t]=0),e[t]+=r[t]}))}}}else e.invisiblePropCount+=1}))})),e.str=Object.keys(e).map((t=>`${t}: ${e[t]}`)).join(&quot;\\n&quot;),e},e.captureImages=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;image/png&quot;,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return Wt.setImmediate(e.render),t._views.map((e=>e.captureNextImage?e.captureNextImage(n,r):void 0)).filter((e=>!!e))},e.addRenderWindow=n=>!t.childRenderWindows.includes(n)&&(t.childRenderWindows.push(n),e.modified(),!0),e.removeRenderWindow=n=>{const r=t.childRenderWindows.findIndex((e=>e===n));return!(r<0||(t.childRenderWindows.splice(r,1),e.modified(),0))}}(e,t)}var hh={newInstance:Wt.newInstance(mh,&quot;vtkRenderWindow&quot;),extend:mh,registerViewConstructor:ph,listViewAPIs:function(){return Object.keys(dh)},newAPISpecificView:fh};const vh={Unknown:0,LeftController:1,RightController:2},Th={Unknown:0,Trigger:1,TrackPad:2,Grip:3,Thumbstick:4,A:5,B:6,ApplicationMenu:7};var yh={Device:vh,Input:Th,Axis:{Unknown:0,TouchpadX:1,TouchpadY:2,ThumbstickX:3,ThumbstickY:4},MouseButton:{LeftButton:1,MiddleButton:2,RightButton:3}};const{Device:bh,Input:xh}=yh,{vtkWarningMacro:Ch,vtkErrorMacro:Sh,normalizeWheel:Ah,vtkOnceErrorMacro:Ih}=Wt,wh={ctrlKey:!1,altKey:!1,shiftKey:!1},Oh={&quot;xr-standard&quot;:[xh.Trigger,xh.Grip,xh.TrackPad,xh.Thumbstick,xh.A,xh.B]},Ph=[&quot;StartAnimation&quot;,&quot;Animation&quot;,&quot;EndAnimation&quot;,&quot;PointerEnter&quot;,&quot;PointerLeave&quot;,&quot;MouseEnter&quot;,&quot;MouseLeave&quot;,&quot;StartMouseMove&quot;,&quot;MouseMove&quot;,&quot;EndMouseMove&quot;,&quot;LeftButtonPress&quot;,&quot;LeftButtonRelease&quot;,&quot;MiddleButtonPress&quot;,&quot;MiddleButtonRelease&quot;,&quot;RightButtonPress&quot;,&quot;RightButtonRelease&quot;,&quot;KeyPress&quot;,&quot;KeyDown&quot;,&quot;KeyUp&quot;,&quot;StartMouseWheel&quot;,&quot;MouseWheel&quot;,&quot;EndMouseWheel&quot;,&quot;StartPinch&quot;,&quot;Pinch&quot;,&quot;EndPinch&quot;,&quot;StartPan&quot;,&quot;Pan&quot;,&quot;EndPan&quot;,&quot;StartRotate&quot;,&quot;Rotate&quot;,&quot;EndRotate&quot;,&quot;Button3D&quot;,&quot;Move3D&quot;,&quot;StartPointerLock&quot;,&quot;EndPointerLock&quot;,&quot;StartInteraction&quot;,&quot;Interaction&quot;,&quot;EndInteraction&quot;,&quot;AnimationFrameRateUpdate&quot;];function Rh(e){e.cancelable&&e.preventDefault()}function Mh(e){const t=Object.create(null);return e.forEach((e=>{let{pointerId:n,position:r}=e;t[n]=r})),t}const Eh={renderWindow:null,interactorStyle:null,picker:null,pickingManager:null,initialized:!1,enabled:!1,enableRender:!0,currentRenderer:null,lightFollowCamera:!0,desiredUpdateRate:30,stillUpdateRate:2,container:null,recognizeGestures:!0,currentGesture:&quot;Start&quot;,animationRequest:null,lastFrameTime:.1,recentAnimationFrameRate:10,wheelTimeoutID:0,moveTimeoutID:0,lastGamepadValues:{},preventDefaultOnPointerDown:!1,preventDefaultOnPointerUp:!1,mouseScrollDebounceByPass:!1};function Vh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Eh,n),Wt.obj(e,t),t._animationExtendedEnd=0,Wt.event(e,t,&quot;RenderEvent&quot;),Ph.forEach((n=>Wt.event(e,t,n))),Wt.get(e,t,[&quot;initialized&quot;,&quot;interactorStyle&quot;,&quot;lastFrameTime&quot;,&quot;recentAnimationFrameRate&quot;,&quot;_view&quot;]),Wt.setGet(e,t,[&quot;container&quot;,&quot;lightFollowCamera&quot;,&quot;enabled&quot;,&quot;enableRender&quot;,&quot;recognizeGestures&quot;,&quot;desiredUpdateRate&quot;,&quot;stillUpdateRate&quot;,&quot;picker&quot;,&quot;preventDefaultOnPointerDown&quot;,&quot;preventDefaultOnPointerUp&quot;,&quot;mouseScrollDebounceByPass&quot;]),Wt.moveToProtected(e,t,[&quot;view&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkRenderWindowInteractor&quot;);const n={...e},r=new Set,o=new Map;let a=1;function i(n,r){t._forcedRenderer||(t.currentRenderer=e.findPokedRenderer(n,r))}e.start=()=>{(t.initialized||(e.initialize(),t.initialized))&&e.startEventLoop()},e.setRenderWindow=e=>{Sh(&quot;you want to call setView(view) instead of setRenderWindow on a vtk.js interactor&quot;)},e.setInteractorStyle=n=>{t.interactorStyle!==n&&(null!=t.interactorStyle&&t.interactorStyle.setInteractor(null),t.interactorStyle=n,null!=t.interactorStyle&&t.interactorStyle.getInteractor()!==e&&t.interactorStyle.setInteractor(e))},e.initialize=()=>{t.initialized=!0,e.enable(),e.render()},e.enable=()=>e.setEnabled(!0),e.disable=()=>e.setEnabled(!1),e.startEventLoop=()=>Ch(&quot;empty event loop&quot;),e.getCurrentRenderer=()=>(t.currentRenderer||i(0,0),t.currentRenderer);const s=t._getScreenEventPositionFor||function(e){const n=t._view.getCanvas(),r=n.getBoundingClientRect(),a=n.width/r.width,s=n.height/r.height,l={x:a*(e.clientX-r.left),y:s*(r.height-e.clientY+r.top),z:0,movementX:a*e.movementX,movementY:s*e.movementY};return(o.size<=1||!t.currentRenderer)&&i(l.x,l.y),l};function l(e){return{controlKey:e.ctrlKey,altKey:e.altKey,shiftKey:e.shiftKey}}function c(e){const t=l(e);return{key:e.key,keyCode:e.charCode,...t}}function u(e){return e.pointerType||&quot;&quot;}const d=()=>{if(null===t.container)return;const{container:n}=t;n.addEventListener(&quot;contextmenu&quot;,Rh),n.addEventListener(&quot;wheel&quot;,e.handleWheel),n.addEventListener(&quot;DOMMouseScroll&quot;,e.handleWheel),n.addEventListener(&quot;pointerenter&quot;,e.handlePointerEnter),n.addEventListener(&quot;pointerleave&quot;,e.handlePointerLeave),n.addEventListener(&quot;pointermove&quot;,e.handlePointerMove,{passive:!1}),n.addEventListener(&quot;pointerdown&quot;,e.handlePointerDown,{passive:!1}),n.addEventListener(&quot;pointerup&quot;,e.handlePointerUp),n.addEventListener(&quot;pointercancel&quot;,e.handlePointerCancel),n.addEventListener(&quot;keypress&quot;,e.handleKeyPress),n.addEventListener(&quot;keydown&quot;,e.handleKeyDown),document.addEventListener(&quot;keyup&quot;,e.handleKeyUp),document.addEventListener(&quot;pointerlockchange&quot;,e.handlePointerLockChange),n.tabIndex=0,n.style.touchAction=&quot;none&quot;,n.style.userSelect=&quot;none&quot;,n.style.webkitTapHighlightColor=&quot;rgba(0,0,0,0)&quot;};e.bindEvents=e=>{null!==e&&n.setContainer(e)&&d()};const p=()=>{clearTimeout(t.moveTimeoutID),clearTimeout(t.wheelTimeoutID),t.moveTimeoutID=0,t.wheelTimeoutID=0,a=1;const{container:n}=t;n&&(n.removeEventListener(&quot;contextmenu&quot;,Rh),n.removeEventListener(&quot;wheel&quot;,e.handleWheel),n.removeEventListener(&quot;DOMMouseScroll&quot;,e.handleWheel),n.removeEventListener(&quot;pointerenter&quot;,e.handlePointerEnter),n.removeEventListener(&quot;pointerleave&quot;,e.handlePointerLeave),n.removeEventListener(&quot;pointermove&quot;,e.handlePointerMove,{passive:!1}),n.removeEventListener(&quot;pointerdown&quot;,e.handlePointerDown,{passive:!1}),n.removeEventListener(&quot;pointerup&quot;,e.handlePointerUp),n.removeEventListener(&quot;pointercancel&quot;,e.handlePointerCancel),n.removeEventListener(&quot;keypress&quot;,e.handleKeyPress),n.removeEventListener(&quot;keydown&quot;,e.handleKeyDown)),document.removeEventListener(&quot;keyup&quot;,e.handleKeyUp),document.removeEventListener(&quot;pointerlockchange&quot;,e.handlePointerLockChange),o.clear()};function f(){t._view&&t.enabled&&t.enableRender&&(t.inRender=!0,t._view.traverseAllPasses(),t.inRender=!1),e.invokeRenderEvent()}e.unbindEvents=()=>{p(),n.setContainer(null)},e.handleKeyPress=t=>{const n=c(t);e.keyPressEvent(n)},e.handleKeyDown=t=>{const n=c(t);e.keyDownEvent(n)},e.handleKeyUp=t=>{const n=c(t);e.keyUpEvent(n)},e.handlePointerEnter=t=>{const n={...l(t),position:s(t),deviceType:u(t)};e.pointerEnterEvent(n),&quot;mouse&quot;===n.deviceType&&e.mouseEnterEvent(n)},e.handlePointerLeave=t=>{const n={...l(t),position:s(t),deviceType:u(t)};e.pointerLeaveEvent(n),&quot;mouse&quot;===n.deviceType&&e.mouseLeaveEvent(n)},e.handlePointerDown=n=>{if(!(n.button>2||e.isPointerLocked()))switch(t.preventDefaultOnPointerDown&&Rh(n),n.target.hasPointerCapture(n.pointerId)&&n.target.releasePointerCapture(n.pointerId),t.container.setPointerCapture(n.pointerId),o.has(n.pointerId)&&Ch(&quot;[RenderWindowInteractor] duplicate pointerId detected&quot;),o.set(n.pointerId,{pointerId:n.pointerId,position:s(n)}),n.pointerType){case&quot;pen&quot;:case&quot;touch&quot;:e.handleTouchStart(n);break;default:e.handleMouseDown(n)}},e.handlePointerUp=n=>{if(o.has(n.pointerId))switch(t.preventDefaultOnPointerUp&&Rh(n),o.delete(n.pointerId),t.container.releasePointerCapture(n.pointerId),n.pointerType){case&quot;pen&quot;:case&quot;touch&quot;:e.handleTouchEnd(n);break;default:e.handleMouseUp(n)}},e.handlePointerCancel=t=>{if(o.has(t.pointerId))switch(o.delete(t.pointerId),t.pointerType){case&quot;pen&quot;:case&quot;touch&quot;:e.handleTouchEnd(t);break;default:e.handleMouseUp(t)}},e.handlePointerMove=t=>{switch(o.has(t.pointerId)&&(o.get(t.pointerId).position=s(t)),t.pointerType){case&quot;pen&quot;:case&quot;touch&quot;:e.handleTouchMove(t);break;default:e.handleMouseMove(t)}},e.handleMouseDown=t=>{const n={...l(t),position:s(t),deviceType:u(t)};switch(t.button){case 0:e.leftButtonPressEvent(n);break;case 1:e.middleButtonPressEvent(n);break;case 2:e.rightButtonPressEvent(n);break;default:Sh(`Unknown mouse button pressed: ${t.button}`)}},e.requestPointerLock=()=>{t.container&&t.container.requestPointerLock()},e.exitPointerLock=()=>document.exitPointerLock?.(),e.isPointerLocked=()=>!!t.container&&document.pointerLockElement===t.container,e.handlePointerLockChange=()=>{e.isPointerLocked()?e.startPointerLockEvent():e.endPointerLockEvent()},e.requestAnimation=n=>{void 0!==n?r.has(n)?Ch(&quot;requester is already registered for animating&quot;):(r.add(n),t.animationRequest||1!==r.size||t.xrAnimation||(t._animationStartTime=Date.now(),t._animationFrameCount=0,t.animationRequest=requestAnimationFrame(e.handleAnimation),e.startAnimationEvent())):Sh(&quot;undefined requester, can not start animating&quot;)},e.extendAnimation=n=>{const o=Date.now()+n;t._animationExtendedEnd=Math.max(t._animationExtendedEnd,o),t.animationRequest||0!==r.size||t.xrAnimation||(t._animationStartTime=Date.now(),t._animationFrameCount=0,t.animationRequest=requestAnimationFrame(e.handleAnimation),e.startAnimationEvent())},e.isAnimating=()=>t.xrAnimation||null!==t.animationRequest,e.cancelAnimation=function(n){let o=arguments.length>1&&void 0!==arguments[1]&&arguments[1];if(r.has(n))r.delete(n),t.animationRequest&&0===r.size&&Date.now()>t._animationExtendedEnd&&(cancelAnimationFrame(t.animationRequest),t.animationRequest=null,e.endAnimationEvent(),e.render());else if(!o){const e=n&&n.getClassName?n.getClassName():n;Ch(`${e} did not request an animation`)}},e.switchToXRAnimation=()=>{t.animationRequest&&(cancelAnimationFrame(t.animationRequest),t.animationRequest=null),t.xrAnimation=!0},e.returnFromXRAnimation=()=>{t.xrAnimation=!1,0!==r.size&&(t.recentAnimationFrameRate=10,t.animationRequest=requestAnimationFrame(e.handleAnimation))},e.updateXRGamepads=(n,r,o)=>{n.inputSources.forEach((n=>{const a=null==n.gripSpace?null:r.getPose(n.gripSpace,o),i=null==n.gripSpace?null:r.getPose(n.targetRaySpace,o),s=n.gamepad,l=n.handedness;if(s){s.index in t.lastGamepadValues||(t.lastGamepadValues[s.index]={left:{buttons:{}},right:{buttons:{}},none:{buttons:{}}});for(let r=0;r<s.buttons.length;++r)r in t.lastGamepadValues[s.index][l].buttons||(t.lastGamepadValues[s.index][l].buttons[r]=!1),t.lastGamepadValues[s.index][l].buttons[r]!==s.buttons[r].pressed&&null!=a&&(e.button3DEvent({gamepad:s,position:a.transform.position,orientation:a.transform.orientation,targetPosition:i.transform.position,targetOrientation:i.transform.orientation,pressed:s.buttons[r].pressed,device:&quot;left&quot;===n.handedness?bh.LeftController:bh.RightController,input:Oh[s.mapping]&&Oh[s.mapping][r]?Oh[s.mapping][r]:xh.Trigger}),t.lastGamepadValues[s.index][l].buttons[r]=s.buttons[r].pressed),t.lastGamepadValues[s.index][l].buttons[r]&&null!=a&&e.move3DEvent({gamepad:s,position:a.transform.position,orientation:a.transform.orientation,targetPosition:i.transform.position,targetOrientation:i.transform.orientation,device:&quot;left&quot;===n.handedness?bh.LeftController:bh.RightController})}}))},e.handleMouseMove=n=>{const r={...l(n),position:s(n),deviceType:u(n)};0===t.moveTimeoutID?e.startMouseMoveEvent(r):(e.mouseMoveEvent(r),clearTimeout(t.moveTimeoutID)),t.moveTimeoutID=setTimeout((()=>{e.endMouseMoveEvent(),t.moveTimeoutID=0}),200)},e.handleAnimation=()=>{const n=Date.now();t._animationFrameCount++,n-t._animationStartTime>1e3&&t._animationFrameCount>1&&(t.recentAnimationFrameRate=1e3*(t._animationFrameCount-1)/(n-t._animationStartTime),t.lastFrameTime=1/t.recentAnimationFrameRate,e.animationFrameRateUpdateEvent(),t._animationStartTime=n,t._animationFrameCount=1),e.animationEvent(),f(),r.size>0||Date.now()<t._animationExtendedEnd?t.animationRequest=requestAnimationFrame(e.handleAnimation):(cancelAnimationFrame(t.animationRequest),t.animationRequest=null,e.endAnimationEvent(),e.render())},e.handleWheel=n=>{Rh(n);const r={...Ah(n),...l(n),position:s(n),deviceType:u(n)};0===t.wheelTimeoutID&&(a=Math.abs(r.spinY)>=.3?Math.abs(r.spinY):1),r.spinY/=a,0===t.wheelTimeoutID?(e.startMouseWheelEvent(r),e.mouseWheelEvent(r)):(e.mouseWheelEvent(r),clearTimeout(t.wheelTimeoutID)),t.mouseScrollDebounceByPass?(e.extendAnimation(600),e.endMouseWheelEvent(),t.wheelTimeoutID=0):t.wheelTimeoutID=setTimeout((()=>{e.extendAnimation(600),e.endMouseWheelEvent(),t.wheelTimeoutID=0}),200)},e.handleMouseUp=t=>{const n={...l(t),position:s(t),deviceType:u(t)};switch(t.button){case 0:e.leftButtonReleaseEvent(n);break;case 1:e.middleButtonReleaseEvent(n);break;case 2:e.rightButtonReleaseEvent(n);break;default:Sh(`Unknown mouse button released: ${t.button}`)}},e.handleTouchStart=n=>{const r=[...o.values()];if(t.recognizeGestures&&r.length>1){const t=Mh(o);if(2===r.length){const t={...l(wh),position:r[0].position,deviceType:u(n)};e.leftButtonReleaseEvent(t)}e.recognizeGesture(&quot;TouchStart&quot;,t)}else if(1===r.length){const t={...l(wh),position:s(n),deviceType:u(n)};e.leftButtonPressEvent(t)}},e.handleTouchMove=n=>{const r=[...o.values()];if(t.recognizeGestures&&r.length>1){const t=Mh(o);e.recognizeGesture(&quot;TouchMove&quot;,t)}else if(1===r.length){const t={...l(wh),position:r[0].position,deviceType:u(n)};e.mouseMoveEvent(t)}},e.handleTouchEnd=n=>{const r=[...o.values()];if(t.recognizeGestures)if(0===r.length){const t={...l(wh),position:s(n),deviceType:u(n)};e.leftButtonReleaseEvent(t)}else if(1===r.length){const t=Mh(o);e.recognizeGesture(&quot;TouchEnd&quot;,t);const a={...l(wh),position:r[0].position,deviceType:u(n)};e.leftButtonPressEvent(a)}else{const t=Mh(o);e.recognizeGesture(&quot;TouchMove&quot;,t)}else if(1===r.length){const t={...l(wh),position:r[0].position,deviceType:u(n)};e.leftButtonReleaseEvent(t)}},e.setView=n=>{t._view!==n&&(t._view=n,t._view.getRenderable().setInteractor(e),e.modified())},e.getFirstRenderer=()=>t._view?.getRenderable()?.getRenderersByReference()?.[0],e.findPokedRenderer=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;if(!t._view)return null;const r=t._view?.getRenderable()?.getRenderers();if(!r||0===r.length)return null;r.sort(((e,t)=>e.getLayer()-t.getLayer()));let o=null,a=null,i=null,s=r.length;for(;s--;){const l=r[s];if(t._view.isInViewport(e,n,l)&&l.getInteractive()){i=l;break}null===o&&l.getInteractive()&&(o=l),null===a&&t._view.isInViewport(e,n,l)&&(a=l)}return null===i&&(i=o),null===i&&(i=a),null==i&&(i=r[0]),i},e.render=()=>{e.isAnimating()||t.inRender||f()},Ph.forEach((n=>{const r=n.charAt(0).toLowerCase()+n.slice(1);e[`${r}Event`]=r=>{if(!t.enabled)return;if(!e.getCurrentRenderer())return void Ih(&quot;\\n          Can not forward events without a current renderer on the interactor.\\n        &quot;);const o={type:n,pokedRenderer:t.currentRenderer,firstRenderer:e.getFirstRenderer(),...r};e[`invoke${n}`](o)}})),e.recognizeGesture=(n,r)=>{if(Object.keys(r).length>2)return;if(t.startingEventPositions||(t.startingEventPositions={}),&quot;TouchStart&quot;===n)return Object.keys(r).forEach((e=>{t.startingEventPositions[e]=r[e]})),void(t.currentGesture=&quot;Start&quot;);if(&quot;TouchEnd&quot;===n)return&quot;Pinch&quot;===t.currentGesture&&(e.render(),e.endPinchEvent()),&quot;Rotate&quot;===t.currentGesture&&(e.render(),e.endRotateEvent()),&quot;Pan&quot;===t.currentGesture&&(e.render(),e.endPanEvent()),t.currentGesture=&quot;Start&quot;,void(t.startingEventPositions={});let o=0;const a=[],i=[];Object.keys(r).forEach((e=>{a[o]=r[e],i[o]=t.startingEventPositions[e],o++}));const s=Math.sqrt((i[0].x-i[1].x)*(i[0].x-i[1].x)+(i[0].y-i[1].y)*(i[0].y-i[1].y)),l=Math.sqrt((a[0].x-a[1].x)*(a[0].x-a[1].x)+(a[0].y-a[1].y)*(a[0].y-a[1].y));let c=To(Math.atan2(i[1].y-i[0].y,i[1].x-i[0].x)),u=To(Math.atan2(a[1].y-a[0].y,a[1].x-a[0].x)),d=u-c;u=u+180>=360?u-180:u+180,c=c+180>=360?c-180:c+180,Math.abs(u-c)<Math.abs(d)&&(d=u-c);const p=[];if(p[0]=(a[0].x-i[0].x+a[1].x-i[1].x)/2,p[1]=(a[0].y-i[0].y+a[1].y-i[1].y)/2,&quot;TouchMove&quot;===n)if(&quot;Start&quot;===t.currentGesture){let n=.01*Math.sqrt(t.container.clientWidth*t.container.clientWidth+t.container.clientHeight*t.container.clientHeight);n<15&&(n=15);const o=Math.abs(l-s),a=3.1415926*l*Math.abs(d)/360,i=Math.sqrt(p[0]*p[0]+p[1]*p[1]);if(o>n&&o>a&&o>i){t.currentGesture=&quot;Pinch&quot;;const n={scale:1,touches:r};e.startPinchEvent(n)}else if(a>n&&a>i){t.currentGesture=&quot;Rotate&quot;;const n={rotation:0,touches:r};e.startRotateEvent(n)}else if(i>n){t.currentGesture=&quot;Pan&quot;;const n={translation:[0,0],touches:r};e.startPanEvent(n)}}else{if(&quot;Rotate&quot;===t.currentGesture){const t={rotation:d,touches:r};e.rotateEvent(t)}if(&quot;Pinch&quot;===t.currentGesture){const t={scale:l/s,touches:r};e.pinchEvent(t)}if(&quot;Pan&quot;===t.currentGesture){const t={translation:p,touches:r};e.panEvent(t)}}},e.handleVisibilityChange=()=>{t._animationStartTime=Date.now(),t._animationFrameCount=0},e.setCurrentRenderer=e=>{t._forcedRenderer=!!e,t.currentRenderer=e},e.setContainer=e=>{p();const t=n.setContainer(e??null);return t&&d(),t},e.delete=()=>{for(;r.size;)e.cancelAnimation(r.values().next().value);void 0!==document.hidden&&document.removeEventListener(&quot;visibilitychange&quot;,e.handleVisibilityChange),t.container&&e.setContainer(null),n.delete()},void 0!==document.hidden&&document.addEventListener(&quot;visibilitychange&quot;,e.handleVisibilityChange,!1)}(e,t)}var Dh={newInstance:Wt.newInstance(Vh,&quot;vtkRenderWindowInteractor&quot;),extend:Vh,handledEvents:Ph,...yh};const{vtkErrorMacro:Lh,VOID:Bh}=Wt,Nh={enabled:!0,priority:0,processEvents:!0,subscribedEvents:[]};function Fh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Nh,n),Wt.obj(e,t),Wt.event(e,t,&quot;InteractionEvent&quot;),Wt.event(e,t,&quot;StartInteractionEvent&quot;),Wt.event(e,t,&quot;EndInteractionEvent&quot;),Wt.get(e,t,[&quot;_interactor&quot;,&quot;enabled&quot;]),Wt.setGet(e,t,[&quot;priority&quot;,&quot;processEvents&quot;]),Wt.moveToProtected(e,t,[&quot;interactor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkInteractorObserver&quot;);const n={...e};function r(){for(;t.subscribedEvents.length;)t.subscribedEvents.pop().unsubscribe()}function o(){Dh.handledEvents.forEach((n=>{e[`handle${n}`]&&t.subscribedEvents.push(t._interactor[`on${n}`]((r=>t.processEvents?e[`handle${n}`](r):Bh),t.priority))}))}e.setInteractor=n=>{n!==t._interactor&&(r(),t._interactor=n,n&&t.enabled&&o(),e.modified())},e.setEnabled=n=>{n!==t.enabled&&(r(),n&&(t._interactor?o():Lh(&quot;\\n          The interactor must be set before subscribing to events\\n        &quot;)),t.enabled=n,e.modified())},e.computeDisplayToWorld=(e,n,r,o)=>e?t._interactor.getView().displayToWorld(n,r,o,e):null,e.computeWorldToDisplay=(e,n,r,o)=>e?t._interactor.getView().worldToDisplay(n,r,o,e):null,e.setPriority=e=>{n.setPriority(e)&&t._interactor&&(r(),o())}}(e,t)}var _h={newInstance:Wt.newInstance(Fh,&quot;vtkInteractorObserver&quot;),extend:Fh,computeWorldToDisplay:function(e,t,n,r){return e.getRenderWindow().getViews()[0].worldToDisplay(t,n,r,e)},computeDisplayToWorld:function(e,t,n,r){return e.getRenderWindow().getViews()[0].displayToWorld(t,n,r,e)}},kh={States:{IS_START:0,IS_NONE:0,IS_ROTATE:1,IS_PAN:2,IS_SPIN:3,IS_DOLLY:4,IS_CAMERA_POSE:11,IS_WINDOW_LEVEL:1024,IS_SLICE:1025}};const{States:Gh}=kh,Uh={Rotate:Gh.IS_ROTATE,Pan:Gh.IS_PAN,Spin:Gh.IS_SPIN,Dolly:Gh.IS_DOLLY,CameraPose:Gh.IS_CAMERA_POSE,WindowLevel:Gh.IS_WINDOW_LEVEL,Slice:Gh.IS_SLICE},zh={state:Gh.IS_NONE,handleObservers:1,autoAdjustCameraClippingRange:1};function Wh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,zh,n),_h.extend(e,t,n),Wt.setGet(e,t,[&quot;focusedRenderer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkInteractorStyle&quot;),Object.keys(Uh).forEach((n=>{Wt.event(e,t,`Start${n}Event`),e[`start${n}`]=()=>{t.state===Gh.IS_NONE&&(t.state=Uh[n],t._interactor.requestAnimation(e),e.invokeStartInteractionEvent({type:&quot;StartInteractionEvent&quot;}),e[`invokeStart${n}Event`]({type:`Start${n}Event`}))},Wt.event(e,t,`End${n}Event`),e[`end${n}`]=()=>{t.state===Uh[n]&&(t.state=Gh.IS_NONE,t._interactor.cancelAnimation(e),e.invokeEndInteractionEvent({type:&quot;EndInteractionEvent&quot;}),e[`invokeEnd${n}Event`]({type:`End${n}Event`}),t._interactor.render())}})),t.getRenderer=e=>t.focusedRenderer||e.pokedRenderer,e.handleKeyPress=e=>{const n=t._interactor;let r=null;switch(e.key){case&quot;r&quot;:case&quot;R&quot;:t.getRenderer(e).resetCamera(),n.render();break;case&quot;w&quot;:case&quot;W&quot;:r=t.getRenderer(e).getActors(),r.forEach((e=>{const t=e.getProperty();t.setRepresentationToWireframe&&t.setRepresentationToWireframe()})),n.render();break;case&quot;s&quot;:case&quot;S&quot;:r=t.getRenderer(e).getActors(),r.forEach((e=>{const t=e.getProperty();t.setRepresentationToSurface&&t.setRepresentationToSurface()})),n.render();break;case&quot;v&quot;:case&quot;V&quot;:r=t.getRenderer(e).getActors(),r.forEach((e=>{const t=e.getProperty();t.setRepresentationToPoints&&t.setRepresentationToPoints()})),n.render()}}}(e,t)}var Hh={newInstance:Wt.newInstance(Wh,&quot;vtkInteractorStyle&quot;),extend:Wh,...kh};const{States:jh}=kh,Kh={motionFactor:10,zoomFactor:10};function $h(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Kh,n),Hh.extend(e,t,n),Wt.setGet(e,t,[&quot;motionFactor&quot;,&quot;zoomFactor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkInteractorStyleTrackballCamera&quot;),e.handleMouseMove=n=>{const r=n.position,o=t.getRenderer(n);switch(t.state){case jh.IS_ROTATE:e.handleMouseRotate(o,r),e.invokeInteractionEvent({type:&quot;InteractionEvent&quot;});break;case jh.IS_PAN:e.handleMousePan(o,r),e.invokeInteractionEvent({type:&quot;InteractionEvent&quot;});break;case jh.IS_DOLLY:e.handleMouseDolly(o,r),e.invokeInteractionEvent({type:&quot;InteractionEvent&quot;});break;case jh.IS_SPIN:e.handleMouseSpin(o,r),e.invokeInteractionEvent({type:&quot;InteractionEvent&quot;})}t.previousPosition=r},e.handleButton3D=n=>{!n||!n.pressed||n.device!==vh.RightController||n.input!==Th.Trigger&&n.input!==Th.TrackPad?!n||n.pressed||n.device!==vh.RightController||n.input!==Th.Trigger&&n.input!==Th.TrackPad||t.state!==jh.IS_CAMERA_POSE||e.endCameraPose():e.startCameraPose()},e.handleMove3D=n=>{t.state===jh.IS_CAMERA_POSE&&e.updateCameraPose(n)},e.updateCameraPose=e=>{const n=t.getRenderer(e).getActiveCamera(),r=n.getPhysicalTranslation(),o=.025*n.getPhysicalScale(),a=n.physicalOrientationToWorldDirection([e.orientation.x,e.orientation.y,e.orientation.z,e.orientation.w]);n.setPhysicalTranslation(r[0]+a[0]*o,r[1]+a[1]*o,r[2]+a[2]*o)},e.handleLeftButtonPress=n=>{const r=n.position;t.previousPosition=r,n.shiftKey?n.controlKey||n.altKey?e.startDolly():e.startPan():n.controlKey||n.altKey?e.startSpin():e.startRotate()},e.handleLeftButtonRelease=()=>{switch(t.state){case jh.IS_DOLLY:e.endDolly();break;case jh.IS_PAN:e.endPan();break;case jh.IS_SPIN:e.endSpin();break;case jh.IS_ROTATE:e.endRotate()}},e.handleStartMouseWheel=()=>{e.startDolly()},e.handleEndMouseWheel=()=>{e.endDolly()},e.handleStartPinch=n=>{t.previousScale=n.scale,e.startDolly()},e.handleEndPinch=()=>{e.endDolly()},e.handleStartRotate=n=>{t.previousRotation=n.rotation,e.startRotate()},e.handleEndRotate=()=>{e.endRotate()},e.handleStartPan=n=>{t.previousTranslation=n.translation,e.startPan()},e.handleEndPan=()=>{e.endPan()},e.handlePinch=n=>{e.dollyByFactor(t.getRenderer(n),n.scale/t.previousScale),t.previousScale=n.scale},e.handlePan=n=>{const r=t.getRenderer(n).getActiveCamera();let o=r.getFocalPoint();o=e.computeWorldToDisplay(t.getRenderer(n),o[0],o[1],o[2]);const a=o[2],i=n.translation,s=t.previousTranslation,l=e.computeDisplayToWorld(t.getRenderer(n),o[0]+i[0]-s[0],o[1]+i[1]-s[1],a),c=e.computeDisplayToWorld(t.getRenderer(n),o[0],o[1],a),u=[];u[0]=c[0]-l[0],u[1]=c[1]-l[1],u[2]=c[2]-l[2],o=r.getFocalPoint();const d=r.getPosition();r.setFocalPoint(u[0]+o[0],u[1]+o[1],u[2]+o[2]),r.setPosition(u[0]+d[0],u[1]+d[1],u[2]+d[2]),t._interactor.getLightFollowCamera()&&t.getRenderer(n).updateLightsGeometryToFollowCamera(),r.orthogonalizeViewUp(),t.previousTranslation=n.translation},e.handleRotate=e=>{const n=t.getRenderer(e).getActiveCamera();n.roll(e.rotation-t.previousRotation),n.orthogonalizeViewUp(),t.previousRotation=e.rotation},e.handleMouseRotate=(e,n)=>{if(!t.previousPosition)return;const r=t._interactor,o=n.x-t.previousPosition.x,a=n.y-t.previousPosition.y,i=r.getView().getViewportSize(e);let s=-.1,l=-.1;i[0]&&i[1]&&(s=-20/i[1],l=-20/i[0]);const c=o*l*t.motionFactor,u=a*s*t.motionFactor,d=e.getActiveCamera();Number.isNaN(c)||Number.isNaN(u)||(d.azimuth(c),d.elevation(u),d.orthogonalizeViewUp()),t.autoAdjustCameraClippingRange&&e.resetCameraClippingRange(),r.getLightFollowCamera()&&e.updateLightsGeometryToFollowCamera()},e.handleMouseSpin=(e,n)=>{if(!t.previousPosition)return;const r=t._interactor,o=e.getActiveCamera(),a=r.getView().getViewportCenter(e),i=To(Math.atan2(t.previousPosition.y-a[1],t.previousPosition.x-a[0])),s=To(Math.atan2(n.y-a[1],n.x-a[0]))-i;Number.isNaN(s)||(o.roll(s),o.orthogonalizeViewUp())},e.handleMousePan=(n,r)=>{if(!t.previousPosition)return;const o=n.getActiveCamera();let a=o.getFocalPoint();a=e.computeWorldToDisplay(n,a[0],a[1],a[2]);const i=a[2],s=e.computeDisplayToWorld(n,r.x,r.y,i),l=e.computeDisplayToWorld(n,t.previousPosition.x,t.previousPosition.y,i),c=[];c[0]=l[0]-s[0],c[1]=l[1]-s[1],c[2]=l[2]-s[2],a=o.getFocalPoint();const u=o.getPosition();o.setFocalPoint(c[0]+a[0],c[1]+a[1],c[2]+a[2]),o.setPosition(c[0]+u[0],c[1]+u[1],c[2]+u[2]),t._interactor.getLightFollowCamera()&&n.updateLightsGeometryToFollowCamera()},e.handleMouseDolly=(n,r)=>{if(!t.previousPosition)return;const o=r.y-t.previousPosition.y,a=t._interactor.getView().getViewportCenter(n),i=t.motionFactor*o/a[1];e.dollyByFactor(n,1.1**i)},e.handleMouseWheel=n=>{const r=1-n.spinY/t.zoomFactor;e.dollyByFactor(t.getRenderer(n),r)},e.dollyByFactor=(e,n)=>{if(Number.isNaN(n))return;const r=e.getActiveCamera();r.getParallelProjection()?r.setParallelScale(r.getParallelScale()/n):(r.dolly(n),t.autoAdjustCameraClippingRange&&e.resetCameraClippingRange()),t._interactor.getLightFollowCamera()&&e.updateLightsGeometryToFollowCamera()}}(e,t)}var qh={newInstance:Wt.newInstance($h,&quot;vtkInteractorStyleTrackballCamera&quot;),extend:$h};function Xh(e){return e}function Yh(e){return null===e||&quot;null&quot;===e?null:&quot;true&quot;===e||&quot;false&quot;!==e&&(void 0!==e&&&quot;undefined&quot;!==e?&quot;[&quot;===e[0]&&&quot;]&quot;===e[e.length-1]?e.substring(1,e.length-1).split(&quot;,&quot;).map((e=>Yh(e.trim()))):&quot;&quot;===e||Number.isNaN(Number(e))?e:Number(e):void 0)}var Zh=function(){let e=!(arguments.length>0&&void 0!==arguments[0])||arguments[0],t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:window.location.search;const n={},r=e?Yh:Xh;return new URLSearchParams(t).forEach(((e,t)=>{t&&(n[t]=!e||r(e))})),n};const Qh={delegates:[],currentOperation:null,preDelegateOperations:[],postDelegateOperations:[],currentParent:null};function Jh(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Qh,n),Wt.obj(e,t),Wt.get(e,t,[&quot;currentOperation&quot;]),Wt.setGet(e,t,[&quot;delegates&quot;,&quot;_currentParent&quot;,&quot;preDelegateOperations&quot;,&quot;postDelegateOperations&quot;]),Wt.moveToProtected(e,t,[&quot;currentParent&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkRenderPass&quot;),e.getOperation=()=>t.currentOperation,e.setCurrentOperation=e=>{t.currentOperation=e,t.currentTraverseOperation=`traverse${Wt.capitalize(t.currentOperation)}`},e.getTraverseOperation=()=>t.currentTraverseOperation,e.traverse=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;t.deleted||(t._currentParent=r,t.preDelegateOperations.forEach((t=>{e.setCurrentOperation(t),n.traverse(e)})),t.delegates.forEach((t=>{t.traverse(n,e)})),t.postDelegateOperations.forEach((t=>{e.setCurrentOperation(t),n.traverse(e)})))}}(e,t)}var ev={newInstance:Wt.newInstance(Jh,&quot;vtkRenderPass&quot;),extend:Jh};const{Representation:tv}=os,{vtkErrorMacro:nv}=Wt;function rv(e){const t=td.substitute(e.Fragment,&quot;//VTK::RenderPassFragmentShader::Impl&quot;,&quot;\\n      float weight = gl_FragData[0].a * pow(max(1.1 - gl_FragCoord.z, 0.0), 2.0);\\n      gl_FragData[0] = vec4(gl_FragData[0].rgb*weight, gl_FragData[0].a);\\n      gl_FragData[1].r = weight;\\n    &quot;,!1);e.Fragment=t.result}const ov={framebuffer:null,copyShader:null,tris:null};function av(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ov,n),ev.extend(e,t,n),t.VBOBuildTime={},Wt.obj(t.VBOBuildTime,{mtime:0}),t.tris=ld.newInstance(),Wt.get(e,t,[&quot;framebuffer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLOrderIndependentTranslucentPass&quot;),e.createVertexBuffer=()=>{const e=new Float32Array([-1,-1,-1,1,-1,-1,-1,1,-1,1,1,-1]),n=new Float32Array([0,0,1,0,0,1,1,1]),r=new Uint16Array([4,0,1,3,2]),o=xs.newInstance({numberOfComponents:3,values:e});o.setName(&quot;points&quot;);const a=xs.newInstance({numberOfComponents:2,values:n});a.setName(&quot;tcoords&quot;);const i=xs.newInstance({numberOfComponents:1,values:r});t.tris.getCABO().createVBO(i,&quot;polys&quot;,tv.SURFACE,{points:o,tcoords:a,cellOffset:0}),t.VBOBuildTime.modified()},e.createFramebuffer=e=>{const n=e.getSize(),r=e.getContext();t.framebuffer=Sp.newInstance(),t.framebuffer.setOpenGLRenderWindow(e),t.framebuffer.create(...n),t.framebuffer.saveCurrentBindingsAndBuffers(),t.framebuffer.bind(),t.translucentRGBATexture=Pd.newInstance(),t.translucentRGBATexture.setInternalFormat(r.RGBA16F),t.translucentRGBATexture.setFormat(r.RGBA),t.translucentRGBATexture.setOpenGLDataType(r.HALF_FLOAT),t.translucentRGBATexture.setOpenGLRenderWindow(e),t.translucentRGBATexture.create2DFromRaw({width:n[0],height:n[1],numComps:4,dataType:&quot;Float32Array&quot;,data:null}),t.translucentRTexture=Pd.newInstance(),t.translucentRTexture.setInternalFormat(r.R16F),t.translucentRTexture.setFormat(r.RED),t.translucentRTexture.setOpenGLDataType(r.HALF_FLOAT),t.translucentRTexture.setOpenGLRenderWindow(e),t.translucentRTexture.create2DFromRaw({width:n[0],height:n[1],numComps:1,dataType:&quot;Float32Array&quot;,data:null}),t.translucentZTexture=Pd.newInstance(),t.translucentZTexture.setOpenGLRenderWindow(e),t.translucentZTexture.createDepthFromRaw({width:n[0],height:n[1],dataType:&quot;Float32Array&quot;,data:null}),t.framebuffer.setColorBuffer(t.translucentRGBATexture,0),t.framebuffer.setColorBuffer(t.translucentRTexture,1),t.framebuffer.setDepthBuffer(t.translucentZTexture)},e.createCopyShader=e=>{t.copyShader=e.getShaderCache().readyShaderProgramArray([&quot;//VTK::System::Dec&quot;,&quot;attribute vec4 vertexDC;&quot;,&quot;attribute vec2 tcoordTC;&quot;,&quot;varying vec2 tcoord;&quot;,&quot;void main() { tcoord = tcoordTC; gl_Position = vertexDC; }&quot;].join(&quot;\\n&quot;),&quot;//VTK::System::Dec\\n\\nin vec2 tcoord;\\n\\nuniform sampler2D translucentRTexture;\\nuniform sampler2D translucentRGBATexture;\\n\\n// the output of this shader\\n//VTK::Output::Dec\\n\\nvoid main()\\n{\\n  vec4 t1Color = texture(translucentRGBATexture, tcoord);\\n  float t2Color = texture(translucentRTexture, tcoord).r;\\n  gl_FragData[0] = vec4(t1Color.rgb/max(t2Color,0.01), 1.0 - t1Color.a);\\n}\\n&quot;,&quot;&quot;)},e.createVBO=n=>{const r=n.getContext();t.tris.setOpenGLRenderWindow(n),e.createVertexBuffer();const o=t.copyShader;t.tris.getCABO().bind(),t.copyVAO.addAttributeArray(o,t.tris.getCABO(),&quot;vertexDC&quot;,t.tris.getCABO().getVertexOffset(),t.tris.getCABO().getStride(),r.FLOAT,3,r.FALSE)||nv(&quot;Error setting vertexDC in copy shader VAO.&quot;),t.copyVAO.addAttributeArray(o,t.tris.getCABO(),&quot;tcoordTC&quot;,t.tris.getCABO().getTCoordOffset(),t.tris.getCABO().getStride(),r.FLOAT,2,r.FALSE)||nv(&quot;Error setting vertexDC in copy shader VAO.&quot;)},e.traverse=(n,r,o)=>{if(t.deleted)return;const a=n.getSize(),i=n.getContext();if(t._supported=!1,r.getSelector()||!i||!n.getWebgl2()||!i.getExtension(&quot;EXT_color_buffer_half_float&quot;)&&!i.getExtension(&quot;EXT_color_buffer_float&quot;))return e.setCurrentOperation(&quot;translucentPass&quot;),void r.traverse(e);if(t._supported=!0,null===t.framebuffer)e.createFramebuffer(n);else{const r=t.framebuffer.getSize();null===r||r[0]!==a[0]||r[1]!==a[1]?(t.framebuffer.releaseGraphicsResources(),t.translucentRGBATexture.releaseGraphicsResources(n),t.translucentRTexture.releaseGraphicsResources(n),t.translucentZTexture.releaseGraphicsResources(n),e.createFramebuffer(n)):(t.framebuffer.saveCurrentBindingsAndBuffers(),t.framebuffer.bind())}i.drawBuffers([i.COLOR_ATTACHMENT0]),i.clearBufferfv(i.COLOR,0,[0,0,0,0]),i.clearBufferfv(i.DEPTH,0,[1]),i.colorMask(!1,!1,!1,!1),o.getOpaqueActorCount()>0&&(o.setCurrentOperation(&quot;opaqueZBufferPass&quot;),r.traverse(o)),i.colorMask(!0,!0,!0,!0),i.drawBuffers([i.COLOR_ATTACHMENT0,i.COLOR_ATTACHMENT1]),i.viewport(0,0,a[0],a[1]),i.scissor(0,0,a[0],a[1]),i.clearBufferfv(i.COLOR,0,[0,0,0,1]),i.clearBufferfv(i.COLOR,1,[0,0,0,0]),i.enable(i.DEPTH_TEST),i.enable(i.BLEND),i.blendFuncSeparate(i.ONE,i.ONE,i.ZERO,i.ONE_MINUS_SRC_ALPHA),e.setCurrentOperation(&quot;translucentPass&quot;),r.traverse(e),i.drawBuffers([i.NONE]),t.framebuffer.restorePreviousBindingsAndBuffers(),null===t.copyShader?e.createCopyShader(n):n.getShaderCache().readyShaderProgram(t.copyShader),t.copyVAO||(t.copyVAO=od.newInstance(),t.copyVAO.setOpenGLRenderWindow(n)),t.copyVAO.bind(),t.VBOBuildTime.getMTime()<e.getMTime()&&e.createVBO(n),i.blendFuncSeparate(i.SRC_ALPHA,i.ONE_MINUS_SRC_ALPHA,i.ONE,i.ONE_MINUS_SRC_ALPHA),i.depthMask(!1),i.depthFunc(i.ALWAYS),i.viewport(0,0,a[0],a[1]),i.scissor(0,0,a[0],a[1]),t.translucentRGBATexture.activate(),t.copyShader.setUniformi(&quot;translucentRGBATexture&quot;,t.translucentRGBATexture.getTextureUnit()),t.translucentRTexture.activate(),t.copyShader.setUniformi(&quot;translucentRTexture&quot;,t.translucentRTexture.getTextureUnit()),i.drawArrays(i.TRIANGLES,0,t.tris.getCABO().getElementCount()),i.depthMask(!0),i.depthFunc(i.LEQUAL),t.translucentRGBATexture.deactivate(),t.translucentRTexture.deactivate();const s=r.getTiledSizeAndOrigin();i.scissor(s.lowerLeftU,s.lowerLeftV,s.usize,s.vsize),i.viewport(s.lowerLeftU,s.lowerLeftV,s.usize,s.vsize)},e.getShaderReplacement=()=>t._supported?rv:null,e.releaseGraphicsResources=n=>{t.framebuffer&&(t.framebuffer.releaseGraphicsResources(n),t.framebuffer=null),t.translucentRGBATexture&&(t.translucentRGBATexture.releaseGraphicsResources(n),t.translucentRGBATexture=null),t.translucentRTexture&&(t.translucentRTexture.releaseGraphicsResources(n),t.translucentRTexture=null),t.translucentZTexture&&(t.translucentZTexture.releaseGraphicsResources(n),t.translucentZTexture=null),t.copyVAO&&(t.copyVAO.releaseGraphicsResources(n),t.copyVAO=null),t.copyShader&&(t.copyShader.releaseGraphicsResources(n),t.copyShader=null),t.tris&&(t.tris.releaseGraphicsResources(n),t.tris=null),e.modified()}}(e,t)}var iv={newInstance:Wt.newInstance(av,&quot;vtkOpenGLOrderIndependentTranslucentPass&quot;),extend:av};const sv={opaqueActorCount:0,translucentActorCount:0,volumeCount:0,overlayActorCount:0,framebuffer:null,depthRequested:!1};function lv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,sv,n),ev.extend(e,t,n),Wt.get(e,t,[&quot;framebuffer&quot;,&quot;opaqueActorCount&quot;,&quot;translucentActorCount&quot;,&quot;volumeCount&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkForwardPass&quot;),e.traverse=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(t.deleted)return;t._currentParent=r,e.setCurrentOperation(&quot;buildPass&quot;),n.traverse(e);const o=n.getRenderable().getNumberOfLayers(),a=n.getRenderable().getRenderersByReference();for(let r=0;r<o;r++)for(let o=0;o<a.length;o++){const i=a[o],s=n.getViewNodeFor(i);if(i.getDraw()&&i.getLayer()===r){if(t.opaqueActorCount=0,t.translucentActorCount=0,t.volumeCount=0,t.overlayActorCount=0,e.setCurrentOperation(&quot;queryPass&quot;),s.traverse(e),(t.opaqueActorCount>0||t.translucentActorCount>0)&&t.volumeCount>0||t.depthRequested){const r=n.getFramebufferSize();null===t.framebuffer&&(t.framebuffer=Sp.newInstance()),t.framebuffer.setOpenGLRenderWindow(n),t.framebuffer.saveCurrentBindingsAndBuffers();const o=t.framebuffer.getSize();null!==o&&o[0]===r[0]&&o[1]===r[1]||(t.framebuffer.create(r[0],r[1]),t.framebuffer.populateFramebuffer()),t.framebuffer.bind(),e.setCurrentOperation(&quot;zBufferPass&quot;),s.traverse(e),t.framebuffer.restorePreviousBindingsAndBuffers(),t.depthRequested=!1}e.setCurrentOperation(&quot;cameraPass&quot;),s.traverse(e),t.opaqueActorCount>0&&(e.setCurrentOperation(&quot;opaquePass&quot;),s.traverse(e)),t.translucentActorCount>0&&(t.translucentPass||(t.translucentPass=iv.newInstance()),t.translucentPass.traverse(n,s,e)),t.volumeCount>0&&(e.setCurrentOperation(&quot;volumePass&quot;),s.traverse(e)),t.overlayActorCount>0&&(e.setCurrentOperation(&quot;overlayPass&quot;),s.traverse(e))}}},e.getZBufferTexture=()=>t.framebuffer?t.framebuffer.getColorTexture():null,e.requestDepth=()=>{t.depthRequested=!0},e.incrementOpaqueActorCount=()=>t.opaqueActorCount++,e.incrementTranslucentActorCount=()=>t.translucentActorCount++,e.incrementVolumeCount=()=>t.volumeCount++,e.incrementOverlayActorCount=()=>t.overlayActorCount++}(e,t)}var cv={newInstance:Wt.newInstance(lv,&quot;vtkForwardPass&quot;),extend:lv},uv=n(292);const dv=[&quot;lastShaderProgramBound&quot;,&quot;context&quot;,&quot;_openGLRenderWindow&quot;],pv={lastShaderProgramBound:null,shaderPrograms:null,context:null};function fv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,pv,n),t.shaderPrograms={},Wt.obj(e,t),Wt.setGet(e,t,dv),Wt.moveToProtected(e,t,[&quot;openGLRenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkShaderCache&quot;),e.replaceShaderValues=(e,n,r)=>{let o=n;r.length>0&&(o=td.substitute(o,&quot;VSOut&quot;,&quot;GSOut&quot;).result);const a=t._openGLRenderWindow.getWebgl2();let i=&quot;\\n&quot;,s=&quot;#version 100\\n&quot;;a?s=&quot;#version 300 es\\n#define attribute in\\n#define textureCube texture\\n#define texture2D texture\\n#define textureCubeLod textureLod\\n#define texture2DLod textureLod\\n&quot;:(t.context.getExtension(&quot;OES_standard_derivatives&quot;),t.context.getExtension(&quot;EXT_frag_depth&quot;)&&(i=&quot;#extension GL_EXT_frag_depth : enable\\n&quot;),t.context.getExtension(&quot;EXT_shader_texture_lod&quot;)&&(i+=&quot;#extension GL_EXT_shader_texture_lod : enable\\n#define textureCubeLod textureCubeLodEXT\\n#define texture2DLod texture2DLodEXT&quot;)),o=td.substitute(o,&quot;//VTK::System::Dec&quot;,[`${s}\\n`,a?&quot;&quot;:&quot;#extension GL_OES_standard_derivatives : enable\\n&quot;,i,&quot;#ifdef GL_FRAGMENT_PRECISION_HIGH&quot;,&quot;precision highp float;&quot;,&quot;precision highp int;&quot;,&quot;#else&quot;,&quot;precision mediump float;&quot;,&quot;precision mediump int;&quot;,&quot;#endif&quot;]).result;let l=td.substitute(e,&quot;//VTK::System::Dec&quot;,[`${s}\\n`,&quot;#ifdef GL_FRAGMENT_PRECISION_HIGH&quot;,&quot;precision highp float;&quot;,&quot;precision highp int;&quot;,&quot;#else&quot;,&quot;precision mediump float;&quot;,&quot;precision mediump int;&quot;,&quot;#endif&quot;]).result;if(a){l=td.substitute(l,&quot;varying&quot;,&quot;out&quot;).result,o=td.substitute(o,&quot;varying&quot;,&quot;in&quot;).result;let e=&quot;&quot;,t=0;for(;o.includes(`gl_FragData[${t}]`);)o=td.substitute(o,`gl_FragData\\\\[${t}\\\\]`,`fragOutput${t}`).result,e+=`layout(location = ${t}) out vec4 fragOutput${t};\\n`,t++;o=td.substitute(o,&quot;//VTK::Output::Dec&quot;,e).result}return{VSSource:l,FSSource:o,GSSource:td.substitute(r,&quot;//VTK::System::Dec&quot;,s).result}},e.readyShaderProgramArray=(t,n,r)=>{const o=e.replaceShaderValues(t,n,r),a=e.getShaderProgram(o.VSSource,o.FSSource,o.GSSource);return e.readyShaderProgram(a)},e.readyShaderProgram=t=>t&&(t.getCompiled()||t.compileShader())&&e.bindShaderProgram(t)?t:null,e.getShaderProgram=(e,n,r)=>{const o=`${e}${n}${r}`,a=uv.hash(o);if(!(a in t.shaderPrograms)){const o=td.newInstance();return o.setContext(t.context),o.getVertexShader().setSource(e),o.getFragmentShader().setSource(n),r&&o.getGeometryShader().setSource(r),o.setMd5Hash(a),t.shaderPrograms[a]=o,o}return t.shaderPrograms[a]},e.releaseGraphicsResources=n=>{e.releaseCurrentShaderProgram(),Object.keys(t.shaderPrograms).map((e=>t.shaderPrograms[e])).forEach((e=>e.cleanup())),t.shaderPrograms={}},e.releaseCurrentShaderProgram=()=>{t.lastShaderProgramBound&&(t.lastShaderProgramBound.cleanup(),t.lastShaderProgramBound=null)},e.bindShaderProgram=e=>(t.lastShaderProgramBound===e||(t.lastShaderProgramBound&&t.lastShaderProgramBound.release(),e.bind(),t.lastShaderProgramBound=e),1)}(e,t)}var gv={newInstance:Wt.newInstance(fv,&quot;vtkShaderCache&quot;),extend:fv};const{vtkErrorMacro:mv}=Wt,hv={context:null,numberOfTextureUnits:0,textureUnits:0};function vv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,hv,n),Wt.obj(e,t),t.textureUnits=[],Wt.get(e,t,[&quot;numberOfTextureUnits&quot;]),Wt.setGet(e,t,[&quot;context&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkOpenGLTextureUnitManager&quot;),e.deleteTable=()=>{for(let e=0;e<t.numberOfTextureUnits;++e)!0===t.textureUnits[e]&&mv(&quot;some texture units  were not properly released&quot;);t.textureUnits=[],t.numberOfTextureUnits=0},e.setContext=n=>{if(t.context!==n){if(0!==t.context&&e.deleteTable(),t.context=n,t.context){t.numberOfTextureUnits=n.getParameter(n.MAX_TEXTURE_IMAGE_UNITS);for(let e=0;e<t.numberOfTextureUnits;++e)t.textureUnits[e]=!1}e.modified()}},e.allocate=()=>{for(let n=0;n<t.numberOfTextureUnits;n++)if(!e.isAllocated(n))return t.textureUnits[n]=!0,n;return-1},e.allocateUnit=n=>e.isAllocated(n)?-1:(t.textureUnits[n]=!0,n),e.isAllocated=e=>t.textureUnits[e],e.free=e=>{t.textureUnits[e]=!1},e.freeAll=()=>{for(let e=0;e<t.numberOfTextureUnits;++e)t.textureUnits[e]=!1}}(e,t)}var Tv={newInstance:Wt.newInstance(vv,&quot;vtkOpenGLTextureUnitManager&quot;),extend:vv};const yv={size:void 0,selector:void 0};function bv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,yv,n),t.size||(t.size=[300,300]),Wt.getArray(e,t,[&quot;size&quot;],2),Wt.get(e,t,[&quot;selector&quot;]),qt.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkRenderWindowViewNode&quot;),e.getViewNodeFactory=()=>null,e.getAspectRatio=()=>t.size[0]/t.size[1],e.getAspectRatioForRenderer=e=>{const n=e.getViewportByReference();return t.size[0]*(n[2]-n[0])/((n[3]-n[1])*t.size[1])},e.isInViewport=(t,n,r)=>{const o=r.getViewportByReference(),a=e.getFramebufferSize();return o[0]*a[0]<=t&&o[2]*a[0]>=t&&o[1]*a[1]<=n&&o[3]*a[1]>=n},e.getViewportSize=t=>{const n=t.getViewportByReference(),r=e.getFramebufferSize();return[(n[2]-n[0])*r[0],(n[3]-n[1])*r[1]]},e.getViewportCenter=t=>{const n=e.getViewportSize(t);return[.5*n[0],.5*n[1]]},e.displayToNormalizedDisplay=(t,n,r)=>{const o=e.getFramebufferSize();return[t/o[0],n/o[1],r]},e.normalizedDisplayToDisplay=(t,n,r)=>{const o=e.getFramebufferSize();return[t*o[0],n*o[1],r]},e.worldToView=(e,t,n,r)=>r.worldToView(e,t,n),e.viewToWorld=(e,t,n,r)=>r.viewToWorld(e,t,n),e.worldToDisplay=(t,n,r,o)=>{const a=o.worldToView(t,n,r),i=e.getViewportSize(o),s=o.viewToProjection(a[0],a[1],a[2],i[0]/i[1]),l=o.projectionToNormalizedDisplay(s[0],s[1],s[2]);return e.normalizedDisplayToDisplay(l[0],l[1],l[2])},e.displayToWorld=(t,n,r,o)=>{const a=e.displayToNormalizedDisplay(t,n,r),i=o.normalizedDisplayToProjection(a[0],a[1],a[2]),s=e.getViewportSize(o),l=o.projectionToView(i[0],i[1],i[2],s[0]/s[1]);return o.viewToWorld(l[0],l[1],l[2])},e.normalizedDisplayToViewport=(t,n,r,o)=>{let a=o.getViewportByReference();a=e.normalizedDisplayToDisplay(a[0],a[1],0);const i=e.normalizedDisplayToDisplay(t,n,r);return[i[0]-a[0]-.5,i[1]-a[1]-.5,r]},e.viewportToNormalizedViewport=(t,n,r,o)=>{const a=e.getViewportSize(o);return a&&0!==a[0]&&0!==a[1]?[t/(a[0]-1),n/(a[1]-1),r]:[t,n,r]},e.normalizedViewportToViewport=(t,n,r,o)=>{const a=e.getViewportSize(o);return[t*(a[0]-1),n*(a[1]-1),r]},e.displayToLocalDisplay=(t,n,r)=>[t,e.getFramebufferSize()[1]-n-1,r],e.viewportToNormalizedDisplay=(t,n,r,o)=>{let a=o.getViewportByReference();a=e.normalizedDisplayToDisplay(a[0],a[1],0);const i=t+a[0]+.5,s=n+a[1]+.5;return e.displayToNormalizedDisplay(i,s,r)},e.getComputedDevicePixelRatio=()=>t.size[0]/e.getContainerSize()[0],e.getContainerSize=()=>{Wt.vtkErrorMacro(&quot;not implemented&quot;)},e.getPixelData=(e,t,n,r)=>{Wt.vtkErrorMacro(&quot;not implemented&quot;)},e.createSelector=()=>{Wt.vtkErrorMacro(&quot;not implemented&quot;)}}(e,t)}var xv={newInstance:Wt.newInstance(bv,&quot;vtkRenderWindowViewNode&quot;),extend:bv};const{vtkDebugMacro:Cv,vtkErrorMacro:Sv}=Wt,Av={position:&quot;absolute&quot;,top:0,left:0,width:&quot;100%&quot;,height:&quot;100%&quot;},Iv=[&quot;activateTexture&quot;,&quot;deactivateTexture&quot;,&quot;disableCullFace&quot;,&quot;enableCullFace&quot;,&quot;get3DContext&quot;,&quot;getActiveFramebuffer&quot;,&quot;getContext&quot;,&quot;getDefaultTextureByteSize&quot;,&quot;getDefaultTextureInternalFormat&quot;,&quot;getDefaultToWebgl2&quot;,&quot;getGLInformations&quot;,&quot;getGraphicsMemoryInfo&quot;,&quot;getGraphicsResourceForObject&quot;,&quot;getHardwareMaximumLineWidth&quot;,&quot;getPixelData&quot;,&quot;getShaderCache&quot;,&quot;getTextureUnitForTexture&quot;,&quot;getTextureUnitManager&quot;,&quot;getWebgl2&quot;,&quot;makeCurrent&quot;,&quot;releaseGraphicsResources&quot;,&quot;registerGraphicsResourceUser&quot;,&quot;unregisterGraphicsResourceUser&quot;,&quot;restoreContext&quot;,&quot;setActiveFramebuffer&quot;,&quot;setContext&quot;,&quot;setDefaultToWebgl2&quot;,&quot;setGraphicsResourceForObject&quot;];function wv(e,t,n){const r=e.createFramebuffer(),o=e.createTexture();e.bindTexture(e.TEXTURE_2D,o),e.texImage2D(e.TEXTURE_2D,0,t,2,2,0,t,n,null),e.bindFramebuffer(e.FRAMEBUFFER,r),e.framebufferTexture2D(e.FRAMEBUFFER,e.COLOR_ATTACHMENT0,e.TEXTURE_2D,o,0);const a=e.checkFramebufferStatus(e.FRAMEBUFFER);return e.bindFramebuffer(e.FRAMEBUFFER,null),e.bindTexture(e.TEXTURE_2D,null),a===e.FRAMEBUFFER_COMPLETE}let Ov=0;const Pv=[];function Rv(e){e.preventDefault()}function Mv(e,t){let n;t.classHierarchy.push(&quot;vtkOpenGLRenderWindow&quot;),e.getViewNodeFactory=()=>t.myFactory,t.canvas.addEventListener(&quot;webglcontextlost&quot;,Rv,!1),t.canvas.addEventListener(&quot;webglcontextrestored&quot;,e.restoreContext,!1);const r=[0,0];let o;e.onModified((function(){t.renderable&&(t.size[0]===r[0]&&t.size[1]===r[1]||(r[0]=t.size[0],r[1]=t.size[1],t.canvas.setAttribute(&quot;width&quot;,t.size[0]),t.canvas.setAttribute(&quot;height&quot;,t.size[1]))),t.viewStream&&t.viewStream.setSize(t.size[0],t.size[1]),t.canvas.style.display=t.useOffScreen?&quot;none&quot;:&quot;block&quot;,t.el&&(t.el.style.cursor=t.cursorVisibility?t.cursor:&quot;none&quot;),t.containerSize=null})),e.buildPass=n=>{if(n){if(!t.renderable)return;e.prepareNodes(),e.addMissingNodes(t.renderable.getRenderersByReference()),e.addMissingNodes(t.renderable.getChildRenderWindowsByReference()),e.removeUnusedNodes(),e.initialize(),t.children.forEach((t=>{t.setOpenGLRenderWindow?.(e)}))}},e.initialize=()=>{if(!t.initialized){if(t.rootOpenGLRenderWindow=e.getLastAncestorOfType(&quot;vtkOpenGLRenderWindow&quot;),t.rootOpenGLRenderWindow)t.context2D=e.get2DContext();else{t.context=e.get3DContext(),e.resizeFromChildRenderWindows(),t.context&&(Ov++,Pv.forEach((e=>e(Ov)))),t.textureUnitManager=Tv.newInstance(),t.textureUnitManager.setContext(t.context),t.shaderCache.setContext(t.context);const n=t.context;n.blendFuncSeparate(n.SRC_ALPHA,n.ONE_MINUS_SRC_ALPHA,n.ONE,n.ONE_MINUS_SRC_ALPHA),n.depthFunc(n.LEQUAL),n.enable(n.BLEND)}t.initialized=!0}},e.makeCurrent=()=>{t.context.makeCurrent()},e.setContainer=n=>{t.el&&t.el!==n&&(t.canvas.parentNode!==t.el&&Sv(&quot;Error: canvas parent node does not match container&quot;),t.el.removeChild(t.canvas),t.el.contains(t.bgImage)&&t.el.removeChild(t.bgImage)),t.el!==n&&(t.el=n,t.el&&(t.el.appendChild(t.canvas),t.useBackgroundImage&&t.el.appendChild(t.bgImage)),e.modified())},e.getContainer=()=>t.el,e.getContainerSize=()=>{if(!t.containerSize&&t.el){const{width:e,height:n}=t.el.getBoundingClientRect();t.containerSize=[e,n]}return t.containerSize||t.size},e.getFramebufferSize=()=>{const e=t.activeFramebuffer?.getSize();return e||t.size},e.getPixelData=(e,n,r,o)=>{const a=new Uint8Array((r-e+1)*(o-n+1)*4);return t.context.readPixels(e,n,r-e+1,o-n+1,t.context.RGBA,t.context.UNSIGNED_BYTE,a),a},e.get3DContext=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{preserveDrawingBuffer:!1,depth:!0,alpha:!0,powerPreference:&quot;high-performance&quot;},r=null;const o=&quot;undefined&quot;!=typeof WebGL2RenderingContext;return t.webgl2=!1,t.defaultToWebgl2&&o&&(r=t.canvas.getContext(&quot;webgl2&quot;,e),r&&(t.webgl2=!0,Cv(&quot;using webgl2&quot;))),r||(Cv(&quot;using webgl1&quot;),r=t.canvas.getContext(&quot;webgl&quot;,e)||t.canvas.getContext(&quot;experimental-webgl&quot;,e)),new Proxy(r,(n||(n=function(){const e=new Map,t={apply(t,n,r){return e.has(r[0])?e.get(r[0]):t.apply(n,r)}},n=Object.create(null);return n.getParameter=(e,n,r,o)=>new Proxy(o.bind(e),t),n.depthMask=(t,n,r,o)=>{return new Proxy(o.bind(t),(a=t.DEPTH_WRITEMASK,{apply(t,n,r){return e.set(a,r[0]),t.apply(n,r)}}));var a},{get(e,t,r){if(&quot;__getUnderlyingContext&quot;===t)return()=>e;let o=Reflect.get(e,t,e);o instanceof Function&&(o=o.bind(e));const a=n[t];return a?a(e,t,r,o):o}}}()),n))},e.get2DContext=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};return t.canvas.getContext(&quot;2d&quot;,e)},e.restoreContext=()=>{const t=ev.newInstance();t.setCurrentOperation(&quot;Release&quot;),t.traverse(e,null)},e.activateTexture=n=>{const r=t._textureResourceIds.get(n);if(void 0!==r)return void t.context.activeTexture(t.context.TEXTURE0+r);const o=e.getTextureUnitManager().allocate();o<0?Sv(&quot;Hardware does not support the number of textures defined.&quot;):(t._textureResourceIds.set(n,o),t.context.activeTexture(t.context.TEXTURE0+o))},e.deactivateTexture=n=>{const r=t._textureResourceIds.get(n);void 0!==r&&(e.getTextureUnitManager().free(r),t._textureResourceIds.delete(n))},e.getTextureUnitForTexture=e=>{const n=t._textureResourceIds.get(e);return void 0!==n?n:-1},e.getDefaultTextureByteSize=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,r=arguments.length>2&&void 0!==arguments[2]&&arguments[2];if(t.webgl2)switch(e){case cs.CHAR:case cs.SIGNED_CHAR:case cs.UNSIGNED_CHAR:return 1;case n:case r:case cs.UNSIGNED_SHORT:case cs.SHORT:case cs.VOID:return 2;default:return 4}return 1},e.getDefaultTextureInternalFormat=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null,o=arguments.length>3&&void 0!==arguments[3]&&arguments[3];if(t.webgl2)switch(e){case cs.UNSIGNED_CHAR:switch(n){case 1:return t.context.R8;case 2:return t.context.RG8;case 3:return t.context.RGB8;default:return t.context.RGBA8}case r&&!o&&cs.UNSIGNED_SHORT:switch(n){case 1:return r.R16_EXT;case 2:return r.RG16_EXT;case 3:return r.RGB16_EXT;default:return r.RGBA16_EXT}case r&&!o&&cs.SHORT:switch(n){case 1:return r.R16_SNORM_EXT;case 2:return r.RG16_SNORM_EXT;case 3:return r.RGB16_SNORM_EXT;default:return r.RGBA16_SNORM_EXT}default:switch(n){case 1:return o?t.context.R16F:t.context.R32F;case 2:return o?t.context.RG16F:t.context.RG32F;case 3:return o?t.context.RGB16F:t.context.RGB32F;default:return o?t.context.RGBA16F:t.context.RGBA32F}}switch(n){case 1:return t.context.LUMINANCE;case 2:return t.context.LUMINANCE_ALPHA;case 3:return t.context.RGB;default:return t.context.RGBA}},e.setBackgroundImage=e=>{t.bgImage.src=e.src},e.setUseBackgroundImage=e=>{t.useBackgroundImage=e,t.useBackgroundImage&&!t.el.contains(t.bgImage)?t.el.appendChild(t.bgImage):!t.useBackgroundImage&&t.el.contains(t.bgImage)&&t.el.removeChild(t.bgImage)},e.captureNextImage=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;image/png&quot;,{resetCamera:r=!1,size:o=null,scale:a=1}=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(t.deleted)return null;t.imageFormat=n;const i=t.notifyStartCaptureImage;return t.notifyStartCaptureImage=!0,t._screenshot={size:o||1!==a?o||t.size.map((e=>e*a)):null},new Promise(((n,o)=>{const a=e.onImageReady((o=>{if(null===t._screenshot.size)t.notifyStartCaptureImage=i,a.unsubscribe(),t._screenshot.placeHolder&&(t.size=t._screenshot.originalSize,e.modified(),t._screenshot.cameras&&t._screenshot.cameras.forEach((e=>{let{restoreParamsFn:t,arg:n}=e;return t(n)})),e.traverseAllPasses(),t.el.removeChild(t._screenshot.placeHolder),t._screenshot.placeHolder.remove(),t._screenshot=null),n(o);else{const n=document.createElement(&quot;img&quot;);if(n.style=Av,n.src=o,t._screenshot.placeHolder=t.el.appendChild(n),t.canvas.style.display=&quot;none&quot;,t._screenshot.originalSize=t.size,t.size=t._screenshot.size,t.rootOpenGLRenderWindow?.resizeFromChildRenderWindows(),t._screenshot.size=null,e.modified(),r){const e=!0!==r;t._screenshot.cameras=t.renderable.getRenderers().map((t=>{const n=t.getActiveCamera(),o=n.get(&quot;focalPoint&quot;,&quot;position&quot;,&quot;parallelScale&quot;);return{resetCameraArgs:e?{renderer:t}:void 0,resetCameraFn:e?r:t.resetCamera,restoreParamsFn:n.set,arg:JSON.parse(JSON.stringify(o))}})),t._screenshot.cameras.forEach((e=>{let{resetCameraFn:t,resetCameraArgs:n}=e;return t(n)}))}e.traverseAllPasses()}}))}))},e.getHardwareMaximumLineWidth=()=>{if(null!=o)return o;const t=e.get3DContext(),n=t.getParameter(t.ALIASED_LINE_WIDTH_RANGE);return o=n[1],n[1]},e.getGLInformations=()=>{if(t._glInformation)return t._glInformation;const n=e.get3DContext(),r=n.getExtension(&quot;OES_texture_float&quot;),o=n.getExtension(&quot;OES_texture_half_float&quot;),a=n.getExtension(&quot;WEBGL_debug_renderer_info&quot;),i=n.getExtension(&quot;WEBGL_draw_buffers&quot;),s=n.getExtension(&quot;EXT_texture_filter_anisotropic&quot;)||n.getExtension(&quot;WEBKIT_EXT_texture_filter_anisotropic&quot;),l=[[&quot;Max Vertex Attributes&quot;,&quot;MAX_VERTEX_ATTRIBS&quot;,n.getParameter(n.MAX_VERTEX_ATTRIBS)],[&quot;Max Varying Vectors&quot;,&quot;MAX_VARYING_VECTORS&quot;,n.getParameter(n.MAX_VARYING_VECTORS)],[&quot;Max Vertex Uniform Vectors&quot;,&quot;MAX_VERTEX_UNIFORM_VECTORS&quot;,n.getParameter(n.MAX_VERTEX_UNIFORM_VECTORS)],[&quot;Max Fragment Uniform Vectors&quot;,&quot;MAX_FRAGMENT_UNIFORM_VECTORS&quot;,n.getParameter(n.MAX_FRAGMENT_UNIFORM_VECTORS)],[&quot;Max Fragment Texture Image Units&quot;,&quot;MAX_TEXTURE_IMAGE_UNITS&quot;,n.getParameter(n.MAX_TEXTURE_IMAGE_UNITS)],[&quot;Max Vertex Texture Image Units&quot;,&quot;MAX_VERTEX_TEXTURE_IMAGE_UNITS&quot;,n.getParameter(n.MAX_VERTEX_TEXTURE_IMAGE_UNITS)],[&quot;Max Combined Texture Image Units&quot;,&quot;MAX_COMBINED_TEXTURE_IMAGE_UNITS&quot;,n.getParameter(n.MAX_COMBINED_TEXTURE_IMAGE_UNITS)],[&quot;Max 2D Texture Size&quot;,&quot;MAX_TEXTURE_SIZE&quot;,n.getParameter(n.MAX_TEXTURE_SIZE)],[&quot;Max Cube Texture Size&quot;,&quot;MAX_CUBE_MAP_TEXTURE_SIZE&quot;,n.getParameter(n.MAX_CUBE_MAP_TEXTURE_SIZE)],[&quot;Max Texture Anisotropy&quot;,&quot;MAX_TEXTURE_MAX_ANISOTROPY_EXT&quot;,s&&n.getParameter(s.MAX_TEXTURE_MAX_ANISOTROPY_EXT)],[&quot;Point Size Range&quot;,&quot;ALIASED_POINT_SIZE_RANGE&quot;,n.getParameter(n.ALIASED_POINT_SIZE_RANGE).join(&quot; - &quot;)],[&quot;Line Width Range&quot;,&quot;ALIASED_LINE_WIDTH_RANGE&quot;,n.getParameter(n.ALIASED_LINE_WIDTH_RANGE).join(&quot; - &quot;)],[&quot;Max Viewport Dimensions&quot;,&quot;MAX_VIEWPORT_DIMS&quot;,n.getParameter(n.MAX_VIEWPORT_DIMS).join(&quot; - &quot;)],[&quot;Max Renderbuffer Size&quot;,&quot;MAX_RENDERBUFFER_SIZE&quot;,n.getParameter(n.MAX_RENDERBUFFER_SIZE)],[&quot;Framebuffer Red Bits&quot;,&quot;RED_BITS&quot;,n.getParameter(n.RED_BITS)],[&quot;Framebuffer Green Bits&quot;,&quot;GREEN_BITS&quot;,n.getParameter(n.GREEN_BITS)],[&quot;Framebuffer Blue Bits&quot;,&quot;BLUE_BITS&quot;,n.getParameter(n.BLUE_BITS)],[&quot;Framebuffer Alpha Bits&quot;,&quot;ALPHA_BITS&quot;,n.getParameter(n.ALPHA_BITS)],[&quot;Framebuffer Depth Bits&quot;,&quot;DEPTH_BITS&quot;,n.getParameter(n.DEPTH_BITS)],[&quot;Framebuffer Stencil Bits&quot;,&quot;STENCIL_BITS&quot;,n.getParameter(n.STENCIL_BITS)],[&quot;Framebuffer Subpixel Bits&quot;,&quot;SUBPIXEL_BITS&quot;,n.getParameter(n.SUBPIXEL_BITS)],[&quot;MSAA Samples&quot;,&quot;SAMPLES&quot;,n.getParameter(n.SAMPLES)],[&quot;MSAA Sample Buffers&quot;,&quot;SAMPLE_BUFFERS&quot;,n.getParameter(n.SAMPLE_BUFFERS)],[&quot;Supported Formats for UByte Render Targets     &quot;,&quot;UNSIGNED_BYTE RENDER TARGET FORMATS&quot;,[r&&wv(n,n.RGBA,n.UNSIGNED_BYTE)?&quot;RGBA&quot;:&quot;&quot;,r&&wv(n,n.RGB,n.UNSIGNED_BYTE)?&quot;RGB&quot;:&quot;&quot;,r&&wv(n,n.LUMINANCE,n.UNSIGNED_BYTE)?&quot;LUMINANCE&quot;:&quot;&quot;,r&&wv(n,n.ALPHA,n.UNSIGNED_BYTE)?&quot;ALPHA&quot;:&quot;&quot;,r&&wv(n,n.LUMINANCE_ALPHA,n.UNSIGNED_BYTE)?&quot;LUMINANCE_ALPHA&quot;:&quot;&quot;].join(&quot; &quot;)],[&quot;Supported Formats for Half Float Render Targets&quot;,&quot;HALF FLOAT RENDER TARGET FORMATS&quot;,[o&&wv(n,n.RGBA,o.HALF_FLOAT_OES)?&quot;RGBA&quot;:&quot;&quot;,o&&wv(n,n.RGB,o.HALF_FLOAT_OES)?&quot;RGB&quot;:&quot;&quot;,o&&wv(n,n.LUMINANCE,o.HALF_FLOAT_OES)?&quot;LUMINANCE&quot;:&quot;&quot;,o&&wv(n,n.ALPHA,o.HALF_FLOAT_OES)?&quot;ALPHA&quot;:&quot;&quot;,o&&wv(n,n.LUMINANCE_ALPHA,o.HALF_FLOAT_OES)?&quot;LUMINANCE_ALPHA&quot;:&quot;&quot;].join(&quot; &quot;)],[&quot;Supported Formats for Full Float Render Targets&quot;,&quot;FLOAT RENDER TARGET FORMATS&quot;,[r&&wv(n,n.RGBA,n.FLOAT)?&quot;RGBA&quot;:&quot;&quot;,r&&wv(n,n.RGB,n.FLOAT)?&quot;RGB&quot;:&quot;&quot;,r&&wv(n,n.LUMINANCE,n.FLOAT)?&quot;LUMINANCE&quot;:&quot;&quot;,r&&wv(n,n.ALPHA,n.FLOAT)?&quot;ALPHA&quot;:&quot;&quot;,r&&wv(n,n.LUMINANCE_ALPHA,n.FLOAT)?&quot;LUMINANCE_ALPHA&quot;:&quot;&quot;].join(&quot; &quot;)],[&quot;Max Multiple Render Targets Buffers&quot;,&quot;MAX_DRAW_BUFFERS_WEBGL&quot;,i?n.getParameter(i.MAX_DRAW_BUFFERS_WEBGL):0],[&quot;High Float Precision in Vertex Shader&quot;,&quot;HIGH_FLOAT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Medium Float Precision in Vertex Shader&quot;,&quot;MEDIUM_FLOAT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Low Float Precision in Vertex Shader&quot;,&quot;LOW_FLOAT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;High Float Precision in Fragment Shader&quot;,&quot;HIGH_FLOAT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Medium Float Precision in Fragment Shader&quot;,&quot;MEDIUM_FLOAT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Low Float Precision in Fragment Shader&quot;,&quot;LOW_FLOAT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_FLOAT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_FLOAT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_FLOAT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;High Int Precision in Vertex Shader&quot;,&quot;HIGH_INT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.HIGH_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Medium Int Precision in Vertex Shader&quot;,&quot;MEDIUM_INT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.MEDIUM_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Low Int Precision in Vertex Shader&quot;,&quot;LOW_INT VERTEX_SHADER&quot;,[n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.VERTEX_SHADER,n.LOW_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;High Int Precision in Fragment Shader&quot;,&quot;HIGH_INT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.HIGH_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Medium Int Precision in Fragment Shader&quot;,&quot;MEDIUM_INT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.MEDIUM_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Low Int Precision in Fragment Shader&quot;,&quot;LOW_INT FRAGMENT_SHADER&quot;,[n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_INT).precision,&quot; (-2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_INT).rangeMin,&quot;</sup> - 2<sup>&quot;,n.getShaderPrecisionFormat(n.FRAGMENT_SHADER,n.LOW_INT).rangeMax,&quot;</sup>)&quot;].join(&quot;&quot;)],[&quot;Supported Extensions&quot;,&quot;EXTENSIONS&quot;,n.getSupportedExtensions().join(&quot;<br/>\\t\\t\\t\\t\\t    &quot;)],[&quot;WebGL Renderer&quot;,&quot;RENDERER&quot;,n.getParameter(n.RENDERER)],[&quot;WebGL Vendor&quot;,&quot;VENDOR&quot;,n.getParameter(n.VENDOR)],[&quot;WebGL Version&quot;,&quot;VERSION&quot;,n.getParameter(n.VERSION)],[&quot;Shading Language Version&quot;,&quot;SHADING_LANGUAGE_VERSION&quot;,n.getParameter(n.SHADING_LANGUAGE_VERSION)],[&quot;Unmasked Renderer&quot;,&quot;UNMASKED_RENDERER&quot;,a&&n.getParameter(a.UNMASKED_RENDERER_WEBGL)],[&quot;Unmasked Vendor&quot;,&quot;UNMASKED_VENDOR&quot;,a&&n.getParameter(a.UNMASKED_VENDOR_WEBGL)],[&quot;WebGL Version&quot;,&quot;WEBGL_VERSION&quot;,t.webgl2?2:1]],c={};for(;l.length;){const[e,t,n]=l.pop();t&&(c[t]={label:e,value:n})}return t._glInformation=c,c},e.traverseAllPasses=()=>{if(t.renderPasses)for(let n=0;n<t.renderPasses.length;++n)t.renderPasses[n].traverse(e,null);e.copyParentContent(),t.notifyStartCaptureImage&&function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:t.imageFormat;const r=document.createElement(&quot;canvas&quot;),o=r.getContext(&quot;2d&quot;);r.width=t.canvas.width,r.height=t.canvas.height,o.drawImage(t.canvas,0,0);const a=t.canvas.getBoundingClientRect();t.renderable.getRenderers().forEach((e=>{e.getViewProps().forEach((e=>{if(e.getContainer){const t=e.getContainer().getElementsByTagName(&quot;canvas&quot;);for(let e=0;e<t.length;e++){const n=t[e],r=n.getBoundingClientRect(),i=r.x-a.x,s=r.y-a.y;o.drawImage(n,i,s)}}}))}));const i=r.toDataURL(n);r.remove(),e.invokeImageReady(i)}();const n=t.renderable.getChildRenderWindowsByReference();for(let t=0;t<n.length;++t)e.getViewNodeFor(n[t])?.traverseAllPasses()},e.copyParentContent=()=>{const e=t.rootOpenGLRenderWindow;if(!e||!t.context2D||t.children.some((e=>!!e.getSelector?.())))return;const n=e.getCanvas(),r=t.canvas;t.context2D.drawImage(n,0,n.height-r.height,r.width,r.height,0,0,r.width,r.height)},e.resizeFromChildRenderWindows=()=>{const n=t.renderable.getChildRenderWindowsByReference();if(n.length>0){const t=[0,0];for(let r=0;r<n.length;++r){const o=e.getViewNodeFor(n[r])?.getSize();o&&(t[0]=o[0]>t[0]?o[0]:t[0],t[1]=o[1]>t[1]?o[1]:t[1])}e.setSize(...t)}},e.disableCullFace=()=>{t.cullFaceEnabled&&(t.context.disable(t.context.CULL_FACE),t.cullFaceEnabled=!1)},e.enableCullFace=()=>{t.cullFaceEnabled||(t.context.enable(t.context.CULL_FACE),t.cullFaceEnabled=!0)},e.setViewStream=n=>t.viewStream!==n&&(t.subscription&&(t.subscription.unsubscribe(),t.subscription=null),t.viewStream=n,t.viewStream&&(t.renderable.getRenderers()[0].getBackgroundByReference()[3]=0,e.setUseBackgroundImage(!0),t.subscription=t.viewStream.onImageReady((t=>e.setBackgroundImage(t.image))),t.viewStream.setSize(t.size[0],t.size[1]),t.viewStream.invalidateCache(),t.viewStream.render(),e.modified()),!0),e.createSelector=()=>{const t=Gp.newInstance();return t.setOpenGLRenderWindow(e),t},e.delete=Wt.chain((()=>{t.context&&(Ov--,Pv.forEach((e=>e(Ov)))),e.setContainer(),e.setViewStream()}),(function(){t.canvas.removeEventListener(&quot;webglcontextlost&quot;,Rv),t.canvas.removeEventListener(&quot;webglcontextrestored&quot;,e.restoreContext)}),e.delete),e.setActiveFramebuffer=e=>{t.activeFramebuffer=e};const a=e.setSize;e.setSize=(t,n)=>{const r=a(t,n);return r&&e.invokeWindowResizeEvent({width:t,height:n}),r},e.registerGraphicsResourceUser=(n,r)=>{t._graphicsResources.has(n)||e.setGraphicsResourceForObject(n,null,null);const o=t._graphicsResources.get(n);o?.users.add(r)},e.unregisterGraphicsResourceUser=(n,r)=>{const o=t._graphicsResources.get(n);o&&(o.users.delete(r),o.users.size||(o.oglObject?.releaseGraphicsResources(e),t._graphicsResources.delete(n)))},e.getGraphicsResourceForObject=e=>t._graphicsResources.get(e),e.setGraphicsResourceForObject=(n,r,o)=>{if(!n)return;const a=t._graphicsResources.get(n);a?.oglObject?.releaseGraphicsResources(e),t._graphicsResources.set(n,{coreObject:n,oglObject:r,hash:o,users:a?.users??new Set})},e.getGraphicsMemoryInfo=()=>{let e=0;return t._graphicsResources.forEach((t=>{let{oglObject:n}=t;e+=n.getAllocatedGPUMemoryInBytes()})),e},e.releaseGraphicsResources=()=>{null!==t.shaderCache&&t.shaderCache.releaseGraphicsResources(e),t._graphicsResources.forEach((t=>{let{oglObject:n}=t;n.releaseGraphicsResources(e)})),t._graphicsResources.clear(),null!==t.textureUnitManager&&t.textureUnitManager.freeAll(),t.renderable.getRenderersByReference().forEach((t=>{const n=e.getViewNodeFor(t);n?.releaseGraphicsResources()}))};const i={...e};Iv.forEach((n=>{e[n]=function(){return t.rootOpenGLRenderWindow?t.rootOpenGLRenderWindow[n](...arguments):i[n](...arguments)}}))}const Ev={cullFaceEnabled:!1,shaderCache:null,initialized:!1,context:null,context2D:null,canvas:null,cursorVisibility:!0,cursor:&quot;pointer&quot;,textureUnitManager:null,textureResourceIds:null,containerSize:null,renderPasses:[],notifyStartCaptureImage:!1,webgl2:!1,defaultToWebgl2:!0,activeFramebuffer:null,imageFormat:&quot;image/png&quot;,useOffScreen:!1,useBackgroundImage:!1};const Vv=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ev,n),xv.extend(e,t,n),t.canvas||(t.canvas=document.createElement(&quot;canvas&quot;),t.canvas.style.width=&quot;100%&quot;),t.selector||(t.selector=Gp.newInstance(),t.selector.setOpenGLRenderWindow(e)),t.bgImage=new Image,t.bgImage.style.position=&quot;absolute&quot;,t.bgImage.style.left=&quot;0&quot;,t.bgImage.style.top=&quot;0&quot;,t.bgImage.style.width=&quot;100%&quot;,t.bgImage.style.height=&quot;100%&quot;,t.bgImage.style.zIndex=&quot;-1&quot;,t._textureResourceIds=new Map,t._graphicsResources=new Map,t._glInformation=null,t.myFactory=nn.newInstance(),t.shaderCache=gv.newInstance(),t.shaderCache.setOpenGLRenderWindow(e),t.renderPasses[0]=cv.newInstance(),Wt.get(e,t,[&quot;shaderCache&quot;,&quot;textureUnitManager&quot;,&quot;webgl2&quot;,&quot;useBackgroundImage&quot;,&quot;activeFramebuffer&quot;,&quot;rootOpenGLRenderWindow&quot;]),Wt.setGet(e,t,[&quot;initialized&quot;,&quot;context&quot;,&quot;context2D&quot;,&quot;canvas&quot;,&quot;renderPasses&quot;,&quot;notifyStartCaptureImage&quot;,&quot;defaultToWebgl2&quot;,&quot;cursor&quot;,&quot;useOffScreen&quot;]),Wt.setGetArray(e,t,[&quot;size&quot;],2),Wt.event(e,t,&quot;imageReady&quot;),Wt.event(e,t,&quot;windowResizeEvent&quot;),Mv(e,t)}),&quot;vtkOpenGLRenderWindow&quot;);ph(&quot;WebGL&quot;,Vv),Jt(&quot;vtkRenderWindow&quot;,Vv);const Dv={device:null,handle:null};function Lv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Dv,n),Wt.obj(e,t),Wt.get(e,t,[&quot;lastCameraMTime&quot;]),Wt.setGet(e,t,[&quot;device&quot;,&quot;handle&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUShaderModule&quot;),e.initialize=(e,n)=>{t.device=e,t.handle=t.device.getHandle().createShaderModule({code:n.getCode()})}}(e,t)}var Bv={newInstance:Wt.newInstance(Lv,&quot;vtkWebGPUShaderModule&quot;),extend:Lv};const Nv={shaderModules:null,device:null,window:null};function Fv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Nv,n),t._shaderModules=new Map,Wt.obj(e,t),Wt.setGet(e,t,[&quot;device&quot;,&quot;window&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUShaderCache&quot;),e.getShaderModule=e=>{const n=e.getType(),r=e.getHash(),o=t._shaderModules.keys();for(let e=0;e<o.length;e++){const a=o[e];if(a.getHash()===r&&a.getType()===n)return t._shaderModules.get(a)}const a=Bv.newInstance();return a.initialize(t.device,e),t._shaderModules.set(e,a),a}}(e,t)}var _v={newInstance:Wt.newInstance(Fv,&quot;vtkWebGPUShaderCache&quot;),extend:Fv,substitute:function(e,t,n){let r=!(arguments.length>3&&void 0!==arguments[3])||arguments[3];const o=Array.isArray(n)?n.join(&quot;\\n&quot;):n;let a=!1;-1!==e.search(t)&&(a=!0);let i=&quot;&quot;;r&&(i=&quot;g&quot;);const s=new RegExp(t,i);return{replace:a,result:e.replace(s,o)}}};const kv={device:null,handle:null,label:null};function Gv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,kv,n),Wt.obj(e,t),t.bindables=[],t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),Wt.get(e,t,[&quot;bindGroupTime&quot;,&quot;handle&quot;,&quot;sizeInBytes&quot;,&quot;usage&quot;]),Wt.setGet(e,t,[&quot;label&quot;,&quot;device&quot;,&quot;arrayInformation&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUBindGroup&quot;),e.setBindables=n=>{if(t.bindables.length===n.length){let e=!0;for(let r=0;r<t.bindables.length;r++)t.bindables[r]!==n[r]&&(e=!1);if(e)return}t.bindables=n,e.modified()},e.getBindGroupLayout=e=>{const n=[];for(let e=0;e<t.bindables.length;e++){const r=t.bindables[e].getBindGroupLayoutEntry();r.binding=e,n.push(r)}return e.getBindGroupLayout({entries:n})},e.getBindGroup=n=>{let r=e.getMTime();for(let e=0;e<t.bindables.length;e++){const n=t.bindables[e].getBindGroupTime().getMTime();r=n>r?n:r}if(r<t.bindGroupTime.getMTime())return t.bindGroup;const o=[];for(let e=0;e<t.bindables.length;e++){const n=t.bindables[e].getBindGroupEntry();n.binding=e,o.push(n)}return t.bindGroup=n.getHandle().createBindGroup({layout:e.getBindGroupLayout(n),entries:o,label:t.label}),t.bindGroupTime.modified(),t.bindGroup},e.getShaderCode=e=>{const n=[],r=e.getBindGroupLayoutCount(t.label);for(let e=0;e<t.bindables.length;e++)n.push(t.bindables[e].getShaderCode(e,r));return n.join(&quot;\\n&quot;)}}(e,t)}var Uv={newInstance:Wt.newInstance(Gv),extend:Gv};const zv={handle:null,layouts:null,renderEncoder:null,shaderDescriptions:null,vertexState:null,topology:null,pipelineDescription:null};function Wv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,zv,n),ht(e,t),t.layouts=[],t.shaderDescriptions=[],Tt(e,t,[&quot;handle&quot;,&quot;pipelineDescription&quot;]),Ct(e,t,[&quot;device&quot;,&quot;renderEncoder&quot;,&quot;topology&quot;,&quot;vertexState&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUPipeline&quot;),e.getShaderDescriptions=()=>t.shaderDescriptions,e.initialize=(e,n)=>{t.pipelineDescription=t.renderEncoder.getPipelineSettings(),t.pipelineDescription.primitive.topology=t.topology,t.pipelineDescription.vertex=t.vertexState,t.pipelineDescription.label=n;const r=[];for(let e=0;e<t.layouts.length;e++)r.push(t.layouts[e].layout);t.pipelineLayout=e.getHandle().createPipelineLayout({bindGroupLayouts:r}),t.pipelineDescription.layout=t.pipelineLayout;for(let n=0;n<t.shaderDescriptions.length;n++){const r=t.shaderDescriptions[n],o=e.getShaderModule(r);&quot;vertex&quot;===r.getType()&&(t.pipelineDescription.vertex.module=o.getHandle(),t.pipelineDescription.vertex.entryPoint=&quot;main&quot;),&quot;fragment&quot;===r.getType()&&(t.pipelineDescription.fragment.module=o.getHandle(),t.pipelineDescription.fragment.entryPoint=&quot;main&quot;)}t.handle=e.getHandle().createRenderPipeline(t.pipelineDescription)},e.getShaderDescription=e=>{for(let n=0;n<t.shaderDescriptions.length;n++)if(t.shaderDescriptions[n].getType()===e)return t.shaderDescriptions[n];return null},e.addBindGroupLayout=e=>{e&&t.layouts.push({layout:e.getBindGroupLayout(t.device),label:e.getLabel()})},e.getBindGroupLayout=e=>t.layouts[e].layout,e.getBindGroupLayoutCount=e=>{for(let n=0;n<t.layouts.length;n++)if(t.layouts[n].label===e)return n;return 0},e.bindVertexInput=(e,t)=>{t.bindBuffers(e)}}(e,t)}var Hv={newInstance:Mt(Wv,&quot;vtkWebGPUPipeline&quot;),extend:Wv};const jv={type:null,hash:null,code:null,outputNames:null,outputTypes:null};function Kv(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,jv,n),t.outputNames=[],t.outputTypes=[],t.outputInterpolations=[],t.builtinOutputNames=[],t.builtinOutputTypes=[],t.builtinInputNames=[],t.builtinInputTypes=[],Wt.obj(e,t),Wt.setGet(e,t,[&quot;type&quot;,&quot;hash&quot;,&quot;code&quot;]),Wt.getArray(e,t,[&quot;outputTypes&quot;,&quot;outputNames&quot;,&quot;outputInterpolations&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUShaderDescription&quot;),e.hasOutput=e=>t.outputNames.includes(e),e.addOutput=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:void 0;t.outputTypes.push(e),t.outputNames.push(n),t.outputInterpolations.push(r)},e.addBuiltinOutput=(e,n)=>{t.builtinOutputTypes.push(e),t.builtinOutputNames.push(n)},e.addBuiltinInput=(e,n)=>{t.builtinInputTypes.push(e),t.builtinInputNames.push(n)},e.replaceShaderCode=(e,n)=>{const r=[];let o=[];if(n&&r.push(n.getShaderCode()),e||t.builtinInputNames.length){const n=[];if(n.push(`struct ${t.type}Input\\n{`),e){const t=e.getOutputNamesByReference(),r=e.getOutputTypesByReference(),o=e.getOutputInterpolationsByReference();for(let e=0;e<t.length;e++)void 0!==o[e]?n.push(`  @location(${e}) @interpolate(${o[e]}) ${t[e]} : ${r[e]},`):n.push(`  @location(${e}) ${t[e]} : ${r[e]},`)}for(let e=0;e<t.builtinInputNames.length;e++)n.push(`  ${t.builtinInputNames[e]} : ${t.builtinInputTypes[e]},`);n.length>1&&(n.push(&quot;};&quot;),o=n,r[r.length-1]+=&quot;,&quot;,r.push(`input: ${t.type}Input`))}if(r.length&&(t.code=_v.substitute(t.code,&quot;//VTK::IOStructs::Input&quot;,r).result),t.outputNames.length+t.builtinOutputNames.length){const e=[`struct ${t.type}Output\\n{`];for(let n=0;n<t.outputNames.length;n++)void 0!==t.outputInterpolations[n]?e.push(`  @location(${n}) @interpolate(${t.outputInterpolations[n]}) ${t.outputNames[n]} : ${t.outputTypes[n]},`):e.push(`  @location(${n}) ${t.outputNames[n]} : ${t.outputTypes[n]},`);for(let n=0;n<t.builtinOutputNames.length;n++)e.push(`  ${t.builtinOutputNames[n]} : ${t.builtinOutputTypes[n]},`);e.push(&quot;};&quot;),o=o.concat(e),t.code=_v.substitute(t.code,&quot;//VTK::IOStructs::Output&quot;,[`-> ${t.type}Output`]).result}t.code=_v.substitute(t.code,&quot;//VTK::IOStructs::Dec&quot;,o).result}}(e,t)}var $v={newInstance:Wt.newInstance(Kv,&quot;vtkWebGPUShaderDescription&quot;),extend:Kv};const qv={r8unorm:{numComponents:1,nativeType:Uint8Array,stride:1,elementSize:1,sampleType:&quot;float&quot;},r8snorm:{numComponents:1,nativeType:Int8Array,stride:1,elementSize:1,sampleType:&quot;float&quot;},r8uint:{numComponents:1,nativeType:Uint8Array,stride:1,elementSize:1,sampleType:&quot;uint&quot;},r8sint:{numComponents:1,nativeType:Int8Array,stride:1,elementSize:1,sampleType:&quot;sint&quot;},r16uint:{numComponents:1,nativeType:Uint16Array,stride:2,elementSize:2,sampleType:&quot;uint&quot;},r16sint:{numComponents:1,nativeType:Int16Array,stride:2,elementSize:2,sampleType:&quot;sint&quot;},r16float:{numComponents:1,nativeType:Float32Array,stride:2,elementSize:2,sampleType:&quot;float&quot;},rg8unorm:{numComponents:2,nativeType:Uint8Array,stride:2,elementSize:1,sampleType:&quot;float&quot;},rg8snorm:{numComponents:2,nativeType:Int8Array,stride:2,elementSize:1,sampleType:&quot;float&quot;},rg8uint:{numComponents:2,nativeType:Uint8Array,stride:2,elementSize:1,sampleType:&quot;uint&quot;},rg8sint:{numComponents:2,nativeType:Int8Array,stride:2,elementSize:1,sampleType:&quot;sint&quot;},r32uint:{numComponents:1,nativeType:Uint32Array,stride:4,elementSize:4,sampleType:&quot;uint&quot;},r32sint:{numComponents:1,nativeType:Int32Array,stride:4,elementSize:4,sampleType:&quot;sint&quot;},r32float:{numComponents:1,nativeType:Float32Array,stride:4,elementSize:4,sampleType:&quot;unfilterable-float&quot;},rg16uint:{numComponents:2,nativeType:Uint16Array,stride:4,elementSize:2,sampleType:&quot;uint&quot;},rg16sint:{numComponents:2,nativeType:Int16Array,stride:4,elementSize:2,sampleType:&quot;sint&quot;},rg16float:{numComponents:2,nativeType:Float32Array,stride:4,elementSize:2,sampleType:&quot;float&quot;},rgba8unorm:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},&quot;rgba8unorm-srgb&quot;:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},rgba8snorm:{numComponents:4,nativeType:Int8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},rgba8uint:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;uint&quot;},rgba8sint:{numComponents:4,nativeType:Int8Array,stride:4,elementSize:1,sampleType:&quot;sint&quot;},bgra8unorm:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},&quot;bgra8unorm-srgb&quot;:{numComponents:4,nativeType:Uint8Array,stride:4,elementSize:1,sampleType:&quot;float&quot;},rgb9e5ufloat:{numComponents:4,nativeType:Uint32Array,stride:4,sampleType:&quot;float&quot;},rgb10a2unorm:{numComponents:4,nativeType:Uint32Array,stride:4,sampleType:&quot;float&quot;},rg11b10ufloat:{numComponents:4,nativeType:Float32Array,stride:4,sampleType:&quot;float&quot;},rg32uint:{numComponents:2,nativeType:Uint32Array,stride:8,elementSize:4,sampleType:&quot;uint&quot;},rg32sint:{numComponents:2,nativeType:Int32Array,stride:8,elementSize:4,sampleType:&quot;sint&quot;},rg32float:{numComponents:2,nativeType:Float32Array,stride:8,elementSize:4,sampleType:&quot;unfilterable-float&quot;},rgba16uint:{numComponents:4,nativeType:Uint16Array,stride:8,elementSize:2,sampleType:&quot;uint&quot;},rgba16sint:{numComponents:4,nativeType:Int16Array,stride:8,elementSize:2,sampleType:&quot;sint&quot;},rgba16float:{numComponents:4,nativeType:Float32Array,stride:8,elementSize:2,sampleType:&quot;float&quot;},rgba32uint:{numComponents:4,nativeType:Uint32Array,stride:16,elementSize:4,sampleType:&quot;uint&quot;},rgba32sint:{numComponents:4,nativeType:Int32Array,stride:16,elementSize:4,sampleType:&quot;sint&quot;},rgba32float:{numComponents:4,nativeType:Float32Array,stride:16,elementSize:4,sampleType:&quot;unfilterable-float&quot;},stencil8:{numComponents:1,nativeType:Uint8Array,stride:1,elementSize:1,sampleType:&quot;uint&quot;},depth16unorm:{numComponents:1,nativeType:Uint16Array,stride:2,elementSize:2,sampleType:&quot;depth&quot;},depth24plus:{numComponents:1,nativeType:Uint32Array,stride:4,elementSize:3,sampleType:&quot;depth&quot;},&quot;depth24plus-stencil8&quot;:{numComponents:2,nativeType:Uint32Array,stride:4,sampleType:&quot;mixed&quot;},depth32float:{numComponents:1,nativeType:Float32Array,stride:4,elementSize:4,sampleType:&quot;depth&quot;}};var Xv=function(e){return!e||e.length<6?0:e in qv==1?qv[e]:(et(`unknown format ${e}`),null)},Yv=function(e){if(!e||e.length<5)return 0;let t=1;&quot;x&quot;===e[e.length-2]&&(t=Number(e[e.length-1]));const n=1===t?e.length-1:e.length-3,r=Number(e[n]);return Number.isNaN(r)?(et(`unknown format ${e}`),0):t*(5-r/2)},Zv=function(e){if(!e||e.length<5)return 0;let t;if(&quot;f&quot;===e[0])t=&quot;Float&quot;;else if(&quot;s&quot;===e[0])t=&quot;Int&quot;;else{if(&quot;u&quot;!==e[0])return void et(`unknown format ${e}`);t=&quot;Uint&quot;}const n=e.split(&quot;x&quot;)[0],r=Number(n[n.length-1]);if(!Number.isNaN(r))return t+=8*(5-r/2),t+=&quot;Array&quot;,t;et(`unknown format ${e}`)},Qv=function(e){let t;if(&quot;f&quot;===e[0]||&quot;n&quot;===e[1])t=&quot;f32&quot;;else if(&quot;s&quot;===e[0]&&&quot;i&quot;===e[1])t=&quot;i32&quot;;else{if(&quot;u&quot;!==e[0]||&quot;i&quot;!==e[1])return void et(`unknown format ${e}`);t=&quot;u32&quot;}let n=1;return&quot;x&quot;===e[e.length-2]&&(n=Number(e[e.length-1])),4===n?`vec4<${t}>`:3===n?`vec3<${t}>`:2===n?`vec2<${t}>`:t},Jv=function(e){if(!e)return 0;let t=1;return&quot;vec&quot;===e.substring(0,3)?t=Number(e[3]):&quot;mat&quot;===e.substring(0,3)&&(t=e[3]*e[5]),4*t},eT=function(e){if(e)return e.includes(&quot;f32&quot;)?&quot;Float32Array&quot;:e.includes(&quot;i32&quot;)?&quot;Int32Array&quot;:e.includes(&quot;u32&quot;)?&quot;Uint32Array&quot;:void et(`unknown format ${e}`)};function tT(e,t){if(e===t)return!0;if(null==e||null==t)return!1;if(e.length!==t.length)return!1;for(let n=0;n<e.length;++n)if(!t.includes(e[n]))return!1;return!0}const nT={inputs:null,bindingDescriptions:!1,attributeDescriptions:null,indexBuffer:null};function rT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,nT,n),ht(e,t),t.bindingDescriptions=[],t.attributeDescriptions=[],t.inputs=[],Ct(e,t,[&quot;created&quot;,&quot;device&quot;,&quot;handle&quot;,&quot;indexBuffer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUVertexInput&quot;),e.addBuffer=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:&quot;vertex&quot;,o=n;Array.isArray(o)||(o=[o]);for(let n=0;n<t.inputs.length;n++)if(tT(t.inputs[n].names,o)){if(t.inputs[n].buffer===e)return;return void(t.inputs[n].buffer=e)}t.inputs.push({buffer:e,stepMode:r,names:o}),t.inputs=t.inputs.sort(((e,t)=>e.names[0]<t.names[0]?-1:e.names[0]>t.names[0]?1:0))},e.removeBufferIfPresent=e=>{for(let n=0;n<t.inputs.length;n++)t.inputs[n].names.includes(e)&&t.inputs.splice(n,1)},e.getBuffer=e=>{for(let n=0;n<t.inputs.length;n++)if(t.inputs[n].names.includes(e))return t.inputs[n].buffer;return null},e.hasAttribute=e=>{for(let n=0;n<t.inputs.length;n++)if(t.inputs[n].names.includes(e))return!0;return!1},e.getAttributeTime=e=>{for(let n=0;n<t.inputs.length;n++)if(t.inputs[n].names.includes(e))return t.inputs[n].buffer.getSourceTime();return 0},e.getShaderCode=()=>{let e=&quot;&quot;,n=0;for(let r=0;r<t.inputs.length;r++)for(let o=0;o<t.inputs[r].names.length;o++){const a=t.inputs[r].buffer.getArrayInformation()[o],i=Qv(a.format);n>0&&(e+=&quot;,\\n&quot;),e=`${e}  @location(${n}) ${t.inputs[r].names[o]} : ${i}`,n++}return e},e.getVertexInputInformation=()=>{const e={};if(t.inputs.length){const n=[];let r=0;for(let e=0;e<t.inputs.length;e++){const o=t.inputs[e].buffer,a={arrayStride:o.getStrideInBytes(),stepMode:t.inputs[e].stepMode,attributes:[]},i=o.getArrayInformation();for(let n=0;n<t.inputs[e].names.length;n++)a.attributes.push({shaderLocation:r,offset:i[n].offset,format:i[n].format}),r++;n.push(a)}e.buffers=n}return e},e.bindBuffers=e=>{for(let n=0;n<t.inputs.length;n++)e.setVertexBuffer(n,t.inputs[n].buffer.getHandle());t.indexBuffer&&e.setIndexBuffer(t.indexBuffer.getHandle(),t.indexBuffer.getArrayInformation()[0].format)},e.getReady=()=>{},e.releaseGraphicsResources=()=>{t.created&&(t.inputs=[],t.bindingDescriptions=[],t.attributeDescriptions=[])}}(e,t)}var oT={newInstance:Mt(rT,&quot;vtkWebGPUVertexInput&quot;),extend:rT};const aT={additionalBindables:void 0,bindGroup:null,device:null,fragmentShaderTemplate:null,numberOfInstances:1,numberOfVertices:0,pipelineHash:null,shaderReplacements:null,SSBO:null,textureViews:null,topology:&quot;triangle-list&quot;,UBO:null,vertexShaderTemplate:null,WebGPURenderer:null};function iT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,aT,n),qt.extend(e,t,n),t.textureViews=[],t.vertexInput=oT.newInstance(),t.bindGroup=Uv.newInstance({label:&quot;mapperBG&quot;}),t.additionalBindables=[],t.fragmentShaderTemplate=t.fragmentShaderTemplate||&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Color::Dec\\n\\n//VTK::Normal::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::Select::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output : fragmentOutput;\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::Light::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Select::Impl\\n\\n  // var computedColor:vec4<f32> = vec4<f32>(1.0,0.5,0.5,1.0);\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;,t.vertexShaderTemplate=t.vertexShaderTemplate||&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Color::Dec\\n\\n//VTK::Normal::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::Select::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@vertex\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output : vertexOutput;\\n\\n  // var vertex: vec4<f32> = vertexBC;\\n\\n  //VTK::Color::Impl\\n\\n  //VTK::Normal::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::Select::Impl\\n\\n  //VTK::Position::Impl\\n\\n  return output;\\n}\\n&quot;,t.shaderReplacements=new Map,Wt.get(e,t,[&quot;pipeline&quot;,&quot;vertexInput&quot;]),Wt.setGet(e,t,[&quot;additionalBindables&quot;,&quot;device&quot;,&quot;fragmentShaderTemplate&quot;,&quot;interpolate&quot;,&quot;numberOfInstances&quot;,&quot;numberOfVertices&quot;,&quot;pipelineHash&quot;,&quot;shaderReplacements&quot;,&quot;SSBO&quot;,&quot;textureViews&quot;,&quot;topology&quot;,&quot;UBO&quot;,&quot;vertexShaderTemplate&quot;,&quot;WebGPURenderer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUSimpleMapper&quot;),e.generateShaderDescriptions=(n,r,o)=>{const a=$v.newInstance({type:&quot;vertex&quot;,hash:n,code:t.vertexShaderTemplate}),i=$v.newInstance({type:&quot;fragment&quot;,hash:n,code:t.fragmentShaderTemplate}),s=r.getShaderDescriptions();s.push(a),s.push(i);const l=t.vertexShaderTemplate+t.fragmentShaderTemplate,c=new RegExp(&quot;//VTK::[^:]*::&quot;,&quot;g&quot;),u=l.match(c).filter(((e,t,n)=>n.indexOf(e)===t)),d=u.map((e=>`replaceShader${e.substring(7,e.length-2)}`));for(let e=0;e<d.length;e++){const a=d[e];&quot;replaceShaderIOStructs&quot;!==a&&t.shaderReplacements.has(a)&&t.shaderReplacements.get(a)(n,r,o)}e.replaceShaderIOStructs(n,r,o)},e.replaceShaderIOStructs=(e,t,n)=>{const r=t.getShaderDescription(&quot;vertex&quot;);r.replaceShaderCode(null,n),t.getShaderDescription(&quot;fragment&quot;).replaceShaderCode(r)},e.replaceShaderRenderEncoder=(e,n,r)=>{t.renderEncoder.replaceShaderCode(n)},t.shaderReplacements.set(&quot;replaceShaderRenderEncoder&quot;,e.replaceShaderRenderEncoder),e.replaceShaderRenderer=(e,n,r)=>{if(!t.WebGPURenderer)return;const o=t.WebGPURenderer.getBindGroup().getShaderCode(n),a=n.getShaderDescription(&quot;vertex&quot;);let i=a.getCode();i=_v.substitute(i,&quot;//VTK::Renderer::Dec&quot;,[o]).result,a.setCode(i);const s=n.getShaderDescription(&quot;fragment&quot;);i=s.getCode(),i=_v.substitute(i,&quot;//VTK::Renderer::Dec&quot;,[o]).result,s.setCode(i)},t.shaderReplacements.set(&quot;replaceShaderRenderer&quot;,e.replaceShaderRenderer),e.replaceShaderMapper=(e,n,r)=>{const o=t.bindGroup.getShaderCode(n),a=n.getShaderDescription(&quot;vertex&quot;);let i=a.getCode();i=_v.substitute(i,&quot;//VTK::Mapper::Dec&quot;,[o]).result,a.setCode(i);const s=n.getShaderDescription(&quot;fragment&quot;);s.addBuiltinInput(&quot;bool&quot;,&quot;@builtin(front_facing) frontFacing&quot;),i=s.getCode(),i=_v.substitute(i,&quot;//VTK::Mapper::Dec&quot;,[o]).result,s.setCode(i)},t.shaderReplacements.set(&quot;replaceShaderMapper&quot;,e.replaceShaderMapper),e.replaceShaderPosition=(e,t,n)=>{const r=t.getShaderDescription(&quot;vertex&quot;);r.addBuiltinOutput(&quot;vec4<f32>&quot;,&quot;@builtin(position) Position&quot;);let o=r.getCode();o=_v.substitute(o,&quot;//VTK::Position::Impl&quot;,[&quot;    output.Position = rendererUBO.SCPCMatrix*vertexBC;&quot;]).result,r.setCode(o)},t.shaderReplacements.set(&quot;replaceShaderPosition&quot;,e.replaceShaderPosition),e.replaceShaderTCoord=(e,t,n)=>{t.getShaderDescription(&quot;vertex&quot;).addOutput(&quot;vec2<f32>&quot;,&quot;tcoordVS&quot;)},t.shaderReplacements.set(&quot;replaceShaderTCoord&quot;,e.replaceShaderTCoord),e.addTextureView=e=>{t.textureViews.includes(e)||t.textureViews.push(e)},e.prepareToDraw=n=>{t.renderEncoder=n,e.updateInput(),e.updateBuffers(),e.updateBindings(),e.updatePipeline()},e.updateInput=()=>{},e.updateBuffers=()=>{},e.updateBindings=()=>{t.bindGroup.setBindables(e.getBindables())},e.computePipelineHash=()=>{},e.registerDrawCallback=n=>{n.registerDrawCallback(t.pipeline,e.draw)},e.prepareAndDraw=n=>{e.prepareToDraw(n),n.setPipeline(t.pipeline),e.draw(n)},e.draw=e=>{const n=e.getBoundPipeline();e.activateBindGroup(t.bindGroup),t.WebGPURenderer&&t.WebGPURenderer.bindUBO(e),n.bindVertexInput(e,t.vertexInput);const r=t.vertexInput.getIndexBuffer();r?e.drawIndexed(r.getIndexCount(),t.numberOfInstances,0,0,0):e.draw(t.numberOfVertices,t.numberOfInstances,0,0)},e.getBindables=()=>{const e=[...t.additionalBindables];t.UBO&&e.push(t.UBO),t.SSBO&&e.push(t.SSBO);for(let n=0;n<t.textureViews.length;n++){e.push(t.textureViews[n]);const r=t.textureViews[n].getSampler();r&&e.push(r)}return e},e.updatePipeline=()=>{e.computePipelineHash(),t.pipeline=t.device.getPipeline(t.pipelineHash),t.pipeline||(t.pipeline=Hv.newInstance(),t.pipeline.setDevice(t.device),t.WebGPURenderer&&t.pipeline.addBindGroupLayout(t.WebGPURenderer.getBindGroup()),t.pipeline.addBindGroupLayout(t.bindGroup),e.generateShaderDescriptions(t.pipelineHash,t.pipeline,t.vertexInput),t.pipeline.setTopology(t.topology),t.pipeline.setRenderEncoder(t.renderEncoder),t.pipeline.setVertexState(t.vertexInput.getVertexInputInformation()),t.device.createPipeline(t.pipelineHash,t.pipeline))}}(e,t)}var sT={newInstance:Wt.newInstance(iT,&quot;vtkWebGPUSimpleMapper&quot;),extend:iT};const lT={};function cT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,lT,n),sT.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUFullScreenQuad&quot;),e.replaceShaderPosition=(e,t,n)=>{const r=t.getShaderDescription(&quot;vertex&quot;);r.addBuiltinOutput(&quot;vec4<f32>&quot;,&quot;@builtin(position) Position&quot;),r.addOutput(&quot;vec4<f32>&quot;,&quot;vertexVC&quot;);let o=r.getCode();o=_v.substitute(o,&quot;//VTK::Position::Impl&quot;,[&quot;output.tcoordVS = vec2<f32>(vertexBC.x * 0.5 + 0.5, 1.0 - vertexBC.y * 0.5 - 0.5);&quot;,&quot;output.Position = vec4<f32>(vertexBC, 1.0);&quot;,&quot;output.vertexVC = vec4<f32>(vertexBC, 1);&quot;]).result,r.setCode(o)},t.shaderReplacements.set(&quot;replaceShaderPosition&quot;,e.replaceShaderPosition),e.updateBuffers=()=>{const e=t.device.getBufferManager().getFullScreenQuadBuffer();t.vertexInput.addBuffer(e,[&quot;vertexBC&quot;]),t.numberOfVertices=6}}(e,t)}var uT={newInstance:Wt.newInstance(cT,&quot;vtkWebGPUFullScreenQuad&quot;),extend:cT};const dT=[&quot;setBindGroup&quot;,&quot;setIndexBuffer&quot;,&quot;setVertexBuffer&quot;,&quot;draw&quot;,&quot;drawIndexed&quot;],pT={description:null,handle:null,boundPipeline:null,pipelineHash:null,pipelineSettings:null,replaceShaderCodeFunction:null,depthTextureView:null,label:null};function fT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,pT,n),ht(e,t),t.description={colorAttachments:[{view:void 0,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}],depthStencilAttachment:{view:void 0,depthLoadOp:&quot;clear&quot;,depthClearValue:0,depthStoreOp:&quot;store&quot;}},t.replaceShaderCodeFunction=e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor = computedColor;&quot;]).result,t.setCode(n)},t.pipelineSettings={primitive:{cullMode:&quot;none&quot;},depthStencil:{depthWriteEnabled:!0,depthCompare:&quot;greater-equal&quot;,format:&quot;depth32float&quot;},fragment:{targets:[{format:&quot;rgba16float&quot;,blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}},t.colorTextureViews=[],Tt(e,t,[&quot;boundPipeline&quot;,&quot;colorTextureViews&quot;]),Ct(e,t,[&quot;depthTextureView&quot;,&quot;description&quot;,&quot;handle&quot;,&quot;label&quot;,&quot;pipelineHash&quot;,&quot;pipelineSettings&quot;,&quot;replaceShaderCodeFunction&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPURenderEncoder&quot;),e.begin=e=>{t.drawCallbacks=[],t.handle=e.beginRenderPass(t.description),t.label&&t.handle.pushDebugGroup(t.label)},e.end=()=>{for(let n=0;n<t.drawCallbacks.length;n++){const r=t.drawCallbacks[n],o=r.pipeline;e.setPipeline(o);for(let t=0;t<r.callbacks.length;t++)r.callbacks[t](e)}t.label&&t.handle.popDebugGroup(),t.handle.end(),t.boundPipeline=null},e.setPipeline=e=>{if(t.boundPipeline===e)return;t.handle.setPipeline(e.getHandle());const n=e.getPipelineDescription();if(t.colorTextureViews.length!==n.fragment.targets.length)console.log(`mismatched attachment counts on pipeline ${n.fragment.targets.length} while encoder has ${t.colorTextureViews.length}`),console.trace();else for(let e=0;e<t.colorTextureViews.length;e++){const r=t.colorTextureViews[e].getTexture()?.getFormat();r&&r!==n.fragment.targets[e].format&&(console.log(`mismatched attachments for attachment ${e} on pipeline ${n.fragment.targets[e].format} while encoder has ${r}`),console.trace())}if(!t.depthTextureView!=!(&quot;depthStencil&quot;in n))console.log(&quot;mismatched depth attachments&quot;),console.trace();else if(t.depthTextureView){const e=t.depthTextureView.getTexture()?.getFormat();e&&e!==n.depthStencil.format&&(console.log(`mismatched depth attachments on pipeline ${n.depthStencil.format} while encoder has ${e}`),console.trace())}t.boundPipeline=e},e.replaceShaderCode=e=>{t.replaceShaderCodeFunction(e)},e.setColorTextureView=(e,n)=>{t.colorTextureViews[e]!==n&&(t.colorTextureViews[e]=n)},e.activateBindGroup=e=>{const n=t.boundPipeline.getDevice(),r=t.boundPipeline.getBindGroupLayoutCount(e.getLabel());t.handle.setBindGroup(r,e.getBindGroup(n));const o=n.getBindGroupLayoutDescription(e.getBindGroupLayout(n)),a=n.getBindGroupLayoutDescription(t.boundPipeline.getBindGroupLayout(r));o!==a&&(console.log(`renderEncoder ${t.pipelineHash} mismatched bind group layouts bind group has\\n${o}\\n versus pipeline\\n${a}\\n`),console.trace())},e.attachTextureViews=()=>{for(let e=0;e<t.colorTextureViews.length;e++)t.description.colorAttachments[e]?t.description.colorAttachments[e].view=t.colorTextureViews[e].getHandle():t.description.colorAttachments[e]={view:t.colorTextureViews[e].getHandle()};t.depthTextureView&&(t.description.depthStencilAttachment.view=t.depthTextureView.getHandle())},e.registerDrawCallback=(e,n)=>{for(let r=0;r<t.drawCallbacks.length;r++)if(t.drawCallbacks[r].pipeline===e)return void t.drawCallbacks[r].callbacks.push(n);t.drawCallbacks.push({pipeline:e,callbacks:[n]})};for(let n=0;n<dT.length;n++)e[dT[n]]=function(){return t.handle[dT[n]](...arguments)}}(e,t)}var gT={newInstance:Mt(fT,&quot;vtkWebGPURenderEncoder&quot;),extend:fT};const mT={device:null,handle:null,label:null,options:null};function hT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,mT,n),Wt.obj(e,t),t.options={},t.bindGroupLayoutEntry={visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,sampler:{}},t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),Wt.get(e,t,[&quot;bindGroupTime&quot;,&quot;handle&quot;,&quot;options&quot;]),Wt.setGet(e,t,[&quot;bindGroupLayoutEntry&quot;,&quot;device&quot;,&quot;label&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUSampler&quot;),e.create=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};t.device=e,t.options.addressModeU=n.addressModeU?n.addressModeU:&quot;clamp-to-edge&quot;,t.options.addressModeV=n.addressModeV?n.addressModeV:&quot;clamp-to-edge&quot;,t.options.addressModeW=n.addressModeW?n.addressModeW:&quot;clamp-to-edge&quot;,t.options.magFilter=n.magFilter?n.magFilter:&quot;nearest&quot;,t.options.minFilter=n.minFilter?n.minFilter:&quot;nearest&quot;,t.options.mipmapFilter=n.mipmapFilter?n.mipmapFilter:&quot;nearest&quot;,t.options.label=t.label,t.handle=t.device.getHandle().createSampler(t.options),t.bindGroupTime.modified()},e.getShaderCode=(e,n)=>`@binding(${e}) @group(${n}) var ${t.label}: sampler;`,e.getBindGroupEntry=()=>({resource:t.handle})}(e,t)}var vT={newInstance:Wt.newInstance(hT),extend:hT};const TT={texture:null,handle:null,sampler:null,label:null};function yT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,TT,n),Wt.obj(e,t),t.bindGroupLayoutEntry={visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,texture:{sampleType:&quot;float&quot;,viewDimension:&quot;2d&quot;}},t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),Wt.get(e,t,[&quot;bindGroupTime&quot;,&quot;texture&quot;]),Wt.setGet(e,t,[&quot;bindGroupLayoutEntry&quot;,&quot;label&quot;,&quot;sampler&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUTextureView&quot;),e.create=(e,n)=>{t.texture=e,t.options=n,t.options.dimension=t.options.dimension||&quot;2d&quot;,t.options.label=t.label,t.textureHandle=e.getHandle(),t.handle=t.textureHandle.createView(t.options),t.bindGroupLayoutEntry.texture.viewDimension=t.options.dimension;const r=Xv(t.texture.getFormat());t.bindGroupLayoutEntry.texture.sampleType=r.sampleType},e.createFromTextureHandle=(e,n)=>{t.texture=null,t.options=n,t.options.dimension=t.options.dimension||&quot;2d&quot;,t.options.label=t.label,t.textureHandle=e,t.handle=t.textureHandle.createView(t.options),t.bindGroupLayoutEntry.texture.viewDimension=t.options.dimension;const r=Xv(n.format);t.bindGroupLayoutEntry.texture.sampleType=r.sampleType,t.bindGroupTime.modified()},e.getBindGroupEntry=()=>({resource:e.getHandle()}),e.getShaderCode=(e,n)=>{let r=&quot;f32&quot;;&quot;sint&quot;===t.bindGroupLayoutEntry.texture.sampleType?r=&quot;i32&quot;:&quot;uint&quot;===t.bindGroupLayoutEntry.texture.sampleType&&(r=&quot;u32&quot;);let o=`@binding(${e}) @group(${n}) var ${t.label}: texture_${t.options.dimension}<${r}>;`;return&quot;depth&quot;===t.bindGroupLayoutEntry.texture.sampleType&&(o=`@binding(${e}) @group(${n}) var ${t.label}: texture_depth_${t.options.dimension};`),o},e.addSampler=(n,r)=>{const o=vT.newInstance({label:`${t.label}Sampler`});o.create(n,r),e.setSampler(o)},e.getBindGroupTime=()=>(t.texture&&t.texture.getHandle()!==t.textureHandle&&(t.textureHandle=t.texture.getHandle(),t.handle=t.textureHandle.createView(t.options),t.bindGroupTime.modified()),t.bindGroupTime),e.getHandle=()=>(t.texture&&t.texture.getHandle()!==t.textureHandle&&(t.textureHandle=t.texture.getHandle(),t.handle=t.textureHandle.createView(t.options),t.bindGroupTime.modified()),t.handle)}(e,t)}var bT={newInstance:Wt.newInstance(yT),extend:yT};const xT={device:null,handle:null,buffer:null,ready:!1,label:null};function CT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,xT,n),Wt.obj(e,t),Wt.get(e,t,[&quot;handle&quot;,&quot;ready&quot;,&quot;width&quot;,&quot;height&quot;,&quot;depth&quot;,&quot;format&quot;,&quot;usage&quot;]),Wt.setGet(e,t,[&quot;device&quot;,&quot;label&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUTexture&quot;),e.create=(e,n)=>{t.device=e,t.width=n.width,t.height=n.height,t.depth=n.depth?n.depth:1;const r=1===t.depth?&quot;2d&quot;:&quot;3d&quot;;t.format=n.format?n.format:&quot;rgba8unorm&quot;,t.mipLevel=n.mipLevel?n.mipLevel:0,t.usage=n.usage?n.usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST,t.handle=t.device.getHandle().createTexture({size:[t.width,t.height,t.depth],format:t.format,usage:t.usage,label:t.label,dimension:r,mipLevelCount:t.mipLevel+1})},e.assignFromHandle=(e,n,r)=>{t.device=e,t.handle=n,t.width=r.width,t.height=r.height,t.depth=r.depth?r.depth:1,t.format=r.format?r.format:&quot;rgba8unorm&quot;,t.usage=r.usage?r.usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST},e.writeImageData=n=>{let r=[];const o=r=>{t.device.getHandle().queue.copyExternalImageToTexture({source:r,flipY:n.flip},{texture:t.handle,premultipliedAlpha:!0,mipLevel:0,origin:{x:0,y:0,z:0}},[r.width,r.height,t.depth]),3!==e.getDimensionality()&&t.mipLevel>0&&vu.generateMipmaps(t.device.getHandle(),t.handle,t.mipLevel+1),t.ready=!0};if(n.canvas)return void o(n.canvas);if(n.imageBitmap)return n.width=n.imageBitmap.width,n.height=n.imageBitmap.height,n.depth=1,n.format=&quot;rgba8unorm&quot;,n.flip=!0,void o(n.imageBitmap);if(n.jsImageData)return n.width=n.jsImageData.width,n.height=n.jsImageData.height,n.depth=1,n.format=&quot;rgba8unorm&quot;,n.flip=!0,void o(n.jsImageData);if(n.image)return n.width=n.image.width,n.height=n.image.height,n.depth=1,n.format=&quot;rgba8unorm&quot;,n.flip=!0,void o(n.image);const a=Xv(t.format);let i=t.width*a.stride;n.nativeArray&&(r=n.nativeArray);const s=3===e.getDimensionality(),l=((e,t,n)=>{const r=2===a.elementSize&&&quot;float&quot;===a.sampleType,o=e.BYTES_PER_ELEMENT,i=e.length/(t*n)*o;if(!r&&i%256==0)return[e,i];const s=i/o,l=a.elementSize,c=256*Math.floor((s*l+255)/256),u=c/l,d=Wt.newTypedArray(r?&quot;Uint16Array&quot;:e.constructor.name,u*t*n),p=t*n;if(r)for(let t=0;t<p;t++){const n=t*s,r=t*u;for(let t=0;t<s;t++)d[r+t]=gd.toHalf(e[n+t])}else if(u===s)d.set(e);else for(let t=0;t<p;t++)d.set(e.subarray(t*s,(t+1)*s),t*u);return[d,c]})(r,t.height,s?t.depth:1);i=l[1];const c=l[0];t.device.getHandle().queue.writeTexture({texture:t.handle,mipLevel:0,origin:{x:0,y:0,z:0}},c,{offset:0,bytesPerRow:i,rowsPerImage:t.height},{width:t.width,height:t.height,depthOrArrayLayers:s?t.depth:1}),!s&&t.mipLevel>0&&vu.generateMipmaps(t.device.getHandle(),t.handle,t.mipLevel+1),t.ready=!0},e.getScale=()=>{const e=Xv(t.format);return 2===e.elementSize&&&quot;float&quot;===e.sampleType?1:255},e.getNumberOfComponents=()=>Xv(t.format).numComponents,e.getDimensionality=()=>{let e=0;return t.width>1&&e++,t.height>1&&e++,t.depth>1&&e++,e},e.resizeToMatch=e=>{e.getWidth()===t.width&&e.getHeight()===t.height&&e.getDepth()===t.depth||(t.width=e.getWidth(),t.height=e.getHeight(),t.depth=e.getDepth(),t.handle=t.device.getHandle().createTexture({size:[t.width,t.height,t.depth],format:t.format,usage:t.usage,label:t.label}))},e.resize=function(e,n){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1;e===t.width&&n===t.height&&r===t.depth||(t.width=e,t.height=n,t.depth=r,t.handle=t.device.getHandle().createTexture({size:[t.width,t.height,t.depth],format:t.format,usage:t.usage,label:t.label}))},e.createView=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};r.dimension||(r.dimension=1===t.depth?&quot;2d&quot;:&quot;3d&quot;);const o=bT.newInstance({label:n});return o.create(e,r),o}}(e,t)}var ST={newInstance:Wt.newInstance(CT),extend:CT};const AT={renderEncoder:null,colorTexture:null,depthTexture:null};function IT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,AT,n),ev.extend(e,t,n),Wt.get(e,t,[&quot;colorTexture&quot;,&quot;depthTexture&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUOpaquePass&quot;),e.traverse=(n,r)=>{if(t.deleted)return;t._currentParent=r;const o=r.getDevice();if(t.renderEncoder)t.colorTexture.resize(r.getCanvas().width,r.getCanvas().height),t.depthTexture.resize(r.getCanvas().width,r.getCanvas().height);else{e.createRenderEncoder(),t.colorTexture=ST.newInstance({label:&quot;opaquePassColor&quot;}),t.colorTexture.create(o,{width:r.getCanvas().width,height:r.getCanvas().height,format:&quot;rgba16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC});const n=t.colorTexture.createView(&quot;opaquePassColorTexture&quot;);t.renderEncoder.setColorTextureView(0,n),t.depthFormat=&quot;depth32float&quot;,t.depthTexture=ST.newInstance({label:&quot;opaquePassDepth&quot;}),t.depthTexture.create(o,{width:r.getCanvas().width,height:r.getCanvas().height,format:t.depthFormat,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC});const a=t.depthTexture.createView(&quot;opaquePassDepthTexture&quot;);t.renderEncoder.setDepthTextureView(a)}t.renderEncoder.attachTextureViews(),e.setCurrentOperation(&quot;opaquePass&quot;),n.setRenderEncoder(t.renderEncoder),n.traverse(e)},e.getColorTextureView=()=>t.renderEncoder.getColorTextureViews()[0],e.getDepthTextureView=()=>t.renderEncoder.getDepthTextureView(),e.createRenderEncoder=()=>{t.renderEncoder=gT.newInstance({label:&quot;OpaquePass&quot;}),t.renderEncoder.setPipelineHash(&quot;op&quot;)}}(e,t)}var wT={newInstance:Wt.newInstance(IT,&quot;vtkWebGPUOpaquePass&quot;),extend:IT};const OT={colorTextureView:null,depthTextureView:null};function PT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,OT,n),ev.extend(e,t,n),Wt.setGet(e,t,[&quot;colorTextureView&quot;,&quot;depthTextureView&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUOrderIndependentTranslucentPass&quot;),e.traverse=(n,r)=>{if(t.deleted)return;t._currentParent=r;const o=r.getDevice();if(t.translucentRenderEncoder)t.translucentColorTexture.resizeToMatch(t.colorTextureView.getTexture()),t.translucentAccumulateTexture.resizeToMatch(t.colorTextureView.getTexture());else{e.createRenderEncoder(),e.createFinalEncoder(),t.translucentColorTexture=ST.newInstance({label:&quot;translucentPassColor&quot;}),t.translucentColorTexture.create(o,{width:r.getCanvas().width,height:r.getCanvas().height,format:&quot;rgba16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING});const n=t.translucentColorTexture.createView(&quot;oitpColorTexture&quot;);t.translucentRenderEncoder.setColorTextureView(0,n),t.translucentAccumulateTexture=ST.newInstance({label:&quot;translucentPassAccumulate&quot;}),t.translucentAccumulateTexture.create(o,{width:r.getCanvas().width,height:r.getCanvas().height,format:&quot;r16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING});const a=t.translucentAccumulateTexture.createView(&quot;oitpAccumTexture&quot;);t.translucentRenderEncoder.setColorTextureView(1,a),t.fullScreenQuad=uT.newInstance(),t.fullScreenQuad.setDevice(r.getDevice()),t.fullScreenQuad.setPipelineHash(&quot;oitpfsq&quot;),t.fullScreenQuad.setTextureViews(t.translucentRenderEncoder.getColorTextureViews()),t.fullScreenQuad.setFragmentShaderTemplate(&quot;\\n//VTK::Mapper::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output: fragmentOutput;\\n\\n  var tcoord: vec2<i32> = vec2<i32>(i32(input.fragPos.x), i32(input.fragPos.y));\\n  var reveal: f32 = textureLoad(oitpAccumTexture, tcoord, 0).r;\\n  if (reveal == 1.0) { discard; }\\n  var tcolor: vec4<f32> = textureLoad(oitpColorTexture, tcoord, 0);\\n  var total: f32 = max(tcolor.a, 0.01);\\n  var computedColor: vec4<f32> = vec4<f32>(tcolor.r/total, tcolor.g/total, tcolor.b/total, 1.0 - reveal);\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;)}t.translucentRenderEncoder.setDepthTextureView(t.depthTextureView),t.translucentRenderEncoder.attachTextureViews(),e.setCurrentOperation(&quot;translucentPass&quot;),n.setRenderEncoder(t.translucentRenderEncoder),n.traverse(e),e.finalPass(r,n)},e.finalPass=(e,n)=>{t.translucentFinalEncoder.setColorTextureView(0,t.colorTextureView),t.translucentFinalEncoder.attachTextureViews(),t.translucentFinalEncoder.begin(e.getCommandEncoder()),n.scissorAndViewport(t.translucentFinalEncoder),t.fullScreenQuad.prepareAndDraw(t.translucentFinalEncoder),t.translucentFinalEncoder.end()},e.getTextures=()=>[t.translucentColorTexture,t.translucentAccumulateTexture],e.createRenderEncoder=()=>{t.translucentRenderEncoder=gT.newInstance({label:&quot;translucentRender&quot;});const e=t.translucentRenderEncoder.getDescription();e.colorAttachments=[{view:void 0,clearValue:[0,0,0,0],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;},{view:void 0,clearValue:[1,0,0,0],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;}],e.depthStencilAttachment={view:void 0,depthLoadOp:&quot;load&quot;,depthStoreOp:&quot;store&quot;},t.translucentRenderEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor&quot;),t.addOutput(&quot;f32&quot;,&quot;outAccum&quot;),t.addBuiltinInput(&quot;vec4<f32>&quot;,&quot;@builtin(position) fragPos&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;var w: f32 = computedColor.a * pow(0.1 + input.fragPos.z, 2.0);&quot;,&quot;output.outColor = vec4<f32>(computedColor.rgb*w, w);&quot;,&quot;output.outAccum = computedColor.a;&quot;]).result,t.setCode(n)})),t.translucentRenderEncoder.setPipelineHash(&quot;oitpr&quot;),t.translucentRenderEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},depthStencil:{depthWriteEnabled:!1,depthCompare:&quot;greater&quot;,format:&quot;depth32float&quot;},fragment:{targets:[{format:&quot;rgba16float&quot;,blend:{color:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;}}},{format:&quot;r16float&quot;,blend:{color:{srcFactor:&quot;zero&quot;,dstFactor:&quot;one-minus-src&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})},e.createFinalEncoder=()=>{t.translucentFinalEncoder=gT.newInstance({label:&quot;translucentFinal&quot;}),t.translucentFinalEncoder.setDescription({colorAttachments:[{view:null,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}]}),t.translucentFinalEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor&quot;),t.addBuiltinInput(&quot;vec4<f32>&quot;,&quot;@builtin(position) fragPos&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor = vec4<f32>(computedColor.rgb, computedColor.a);&quot;]).result,t.setCode(n)})),t.translucentFinalEncoder.setPipelineHash(&quot;oitpf&quot;),t.translucentFinalEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;rgba16float&quot;,blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})}}(e,t)}var RT={newInstance:Wt.newInstance(PT,&quot;vtkWebGPUOrderIndependentTranslucentPass&quot;),extend:PT},MT={BufferUsage:{Verts:0,Lines:1,Triangles:2,Strips:3,LinesFromStrips:4,LinesFromTriangles:5,Points:6,UniformArray:7,PointArray:8,NormalsFromPoints:9,Texture:10,RawVertex:11,Storage:12,Index:13},PrimitiveTypes:{Start:0,Points:0,Lines:1,Triangles:2,TriangleStrips:3,TriangleEdges:4,TriangleStripEdges:5,End:6}};const ET=[&quot;getMappedRange&quot;,&quot;mapAsync&quot;,&quot;unmap&quot;];const VT={device:null,handle:null,sizeInBytes:0,strideInBytes:0,arrayInformation:null,usage:null,label:null,sourceTime:null};function DT(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,VT,n),Wt.obj(e,t),Wt.get(e,t,[&quot;handle&quot;,&quot;sizeInBytes&quot;,&quot;usage&quot;]),Wt.setGet(e,t,[&quot;strideInBytes&quot;,&quot;device&quot;,&quot;arrayInformation&quot;,&quot;label&quot;,&quot;sourceTime&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUBuffer&quot;),e.create=(e,n)=>{t.handle=t.device.getHandle().createBuffer({size:e,usage:n,label:t.label}),t.sizeInBytes=e,t.usage=n},e.write=e=>{!function(e,t,n,r){const o=r.byteLength,a=e.createBuffer({size:o,usage:GPUBufferUsage.COPY_SRC,mappedAtCreation:!0}),i=a.getMappedRange(0,o);new Uint8Array(i).set(new Uint8Array(r)),a.unmap();const s=e.createCommandEncoder();s.copyBufferToBuffer(a,0,t,0,o);const l=s.finish();e.queue.submit([l]),a.destroy()}(t.device.getHandle(),t.handle,0,e.buffer)},e.createAndWrite=(e,n)=>{const r=4*Math.ceil(e.byteLength/4);t.handle=t.device.getHandle().createBuffer({size:r,usage:n,mappedAtCreation:!0,label:t.label}),t.sizeInBytes=r,t.usage=n,new Uint8Array(t.handle.getMappedRange()).set(new Uint8Array(e.buffer)),t.handle.unmap()};for(let n=0;n<ET.length;n++)e[ET[n]]=function(){return t.handle[ET[n]](...arguments)}}(e,t)}var LT={newInstance:Wt.newInstance(DT),extend:DT,...MT};const{Representation:BT}=os,{PrimitiveTypes:NT}=MT;class FT{constructor(){this.keys=new Uint32Array(10),this.values=new Uint32Array(10),this.count=0}clear(){this.count=0}has(e){for(let t=0;t<this.count;t++)if(this.keys[t]===e)return!0}get(e){for(let t=0;t<this.count;t++)if(this.keys[t]===e)return this.values[t]}set(e,t){this.count<9&&(this.keys[this.count]=e,this.values[this.count++]=t)}}function _T(e,t,n){let r=e.pointIdToFlatId[t];return r<0&&(r=e.flatId,e.pointIdToFlatId[t]=r,e.flatIdToPointId[e.flatId]=t,e.flatIdToCellId[e.flatId]=n,e.flatId++),r}function kT(e,t,n){const r=e.length;for(let o=0;o<r;o++){let a=e[o];if(n.cellProvokedMap.has(a)){n.ibo[n.iboId++]=n.cellProvokedMap.get(a);for(let i=o+1;i<o+r;i++){a=e[i%r];const o=_T(n,a,t);n.ibo[n.iboId++]=o}return}}for(let o=0;o<r;o++){let a=e[o];if(!n.provokedPointIds[a]){let i=_T(n,a,t);n.provokedPointIds[a]=1,n.cellProvokedMap.set(a,i),n.flatIdToCellId[i]=t,n.ibo[n.iboId++]=i;for(let s=o+1;s<o+r;s++)a=e[s%r],i=_T(n,a,t),n.ibo[n.iboId++]=i;return}}let o=e[0],a=n.flatId;n.cellProvokedMap.set(o,a),n.flatIdToPointId[n.flatId]=o,n.flatIdToCellId[n.flatId]=t,n.flatId++,n.ibo[n.iboId++]=a;for(let i=1;i<r;i++)o=e[i],a=_T(n,o,t),n.ibo[n.iboId++]=a}function GT(e,t,n){const r=e.length;n.iboSize+=r;for(let t=0;t<r;t++){const r=e[t];if(n.cellProvokedMap.has(r))return}for(let t=0;t<r;t++){const r=e[t];if(!n.provokedPointIds[r])return n.provokedPointIds[r]=1,void n.cellProvokedMap.set(r,1)}n.cellProvokedMap.set(e[0],1),n.extraPoints++}let UT;const zT=new Uint32Array(1),WT=new Uint32Array(2),HT=new Uint32Array(3),jT={anythingToPoints(e,t,n,r,o){for(let a=0;a<e;++a)zT[0]=t[n+a],UT(zT,r,o)},linesToWireframe(e,t,n,r,o){for(let a=0;a<e-1;++a)WT[0]=t[n+a],WT[1]=t[n+a+1],UT(WT,r,o)},polysToWireframe(e,t,n,r,o){if(e>2)for(let a=0;a<e;++a)WT[0]=t[n+a],WT[1]=t[n+(a+1)%e],UT(WT,r,o)},stripsToWireframe(e,t,n,r,o){if(e>2){for(let a=0;a<e-1;++a)WT[0]=t[n+a],WT[1]=t[n+a+1],UT(WT,r,o);for(let a=0;a<e-2;a++)WT[0]=t[n+a],WT[1]=t[n+a+2],UT(WT,r,o)}},polysToSurface(e,t,n,r,o){for(let a=0;a<e-2;a++)HT[0]=t[n],HT[1]=t[n+a+1],HT[2]=t[n+a+2],UT(HT,r,o)},stripsToSurface(e,t,n,r,o){for(let a=0;a<e-2;a++)HT[0]=t[n+a],HT[1]=t[n+a+1+a%2],HT[2]=t[n+a+1+(a+1)%2],UT(HT,r,o)}};const KT={flatIdToPointId:null,flatIdToCellId:null,flatSize:0,indexCount:0};function $T(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,KT,n),LT.extend(e,t,n),Wt.setGet(e,t,[&quot;flatIdToPointId&quot;,&quot;flatIdToCellId&quot;,&quot;flatSize&quot;,&quot;indexCount&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUIndexBuffer&quot;),e.buildIndexBuffer=e=>{const n=e.cells,r=e.primitiveType,o=e.representation,a=e.cellOffset,i=n.getData(),s=i.length,l=function(e){switch(e){case NT.Points:return&quot;points&quot;;case NT.Lines:return&quot;lines&quot;;case NT.Triangles:case NT.TriangleEdges:return&quot;polys&quot;;case NT.TriangleStripEdges:case NT.TriangleStrips:return&quot;strips&quot;;default:return&quot;&quot;}}(r),c=e.numberOfPoints,u={provokedPointIds:new Uint8Array(c),extraPoints:0,iboSize:0,flatId:0,iboId:0,cellProvokedMap:new FT};let d=null;d=o===BT.POINTS||r===NT.Points?jT.anythingToPoints:o===BT.WIREFRAME||r===NT.Lines?jT[`${l}ToWireframe`]:jT[`${l}ToSurface`],UT=GT;let p=a||0;for(let e=0;e<s;)u.cellProvokedMap.clear(),d(i[e],i,e+1,p,u),e+=i[e]+1,p++;u.flatIdToPointId=c<=65535?new Uint16Array(c+u.extraPoints):new Uint32Array(c+u.extraPoints),c+u.extraPoints<36863?u.pointIdToFlatId=new Int16Array(c):u.pointIdToFlatId=new Int32Array(c),c+u.extraPoints<=65535?(u.ibo=new Uint16Array(u.iboSize),e.format=&quot;uint16&quot;):(u.ibo=new Uint32Array(u.iboSize),e.format=&quot;uint32&quot;),u.flatIdToCellId=p<=65535?new Uint16Array(c+u.extraPoints):new Uint32Array(c+u.extraPoints),u.pointIdToFlatId.fill(-1),u.provokedPointIds.fill(0),UT=kT,p=a||0;for(let e=0;e<s;)u.cellProvokedMap.clear(),d(i[e],i,e+1,p,u),e+=i[e]+1,p++;delete u.provokedPointIds,delete u.pointIdToFlatId,e.nativeArray=u.ibo,t.flatIdToPointId=u.flatIdToPointId,t.flatIdToCellId=u.flatIdToCellId,t.flatSize=u.flatId,t.indexCount=u.iboId}}(e,t)}var qT={newInstance:Wt.newInstance($T),extend:$T,...MT};const{BufferUsage:XT}=MT,{vtkErrorMacro:YT}=Ht,{VtkDataTypes:ZT}=xs;function QT(e,t,n,r,o){const a={},i=e.getFlatSize();if(!i)return a;let s=[0,0,0,0];o.shift&&(o.shift.length?s=o.shift:s.fill(o.shift));let l=[1,1,1,1];o.scale&&(o.scale.length?l=o.scale:l.fill(o.scale));const c=!!Object.prototype.hasOwnProperty.call(o,&quot;packExtra&quot;)&&o.packExtra;let u,d=0;const p=at(r,i*(n+(c?1:0)));let f=e.getFlatIdToPointId();o.cellData&&(f=e.getFlatIdToCellId()),1===n?u=function(e){p[d++]=l[0]*t[e]+s[0]}:2===n?u=function(e){p[d++]=l[0]*t[e]+s[0],p[d++]=l[1]*t[e+1]+s[1]}:3!==n||c?3===n&&c?u=function(e){p[d++]=l[0]*t[e]+s[0],p[d++]=l[1]*t[e+1]+s[1],p[d++]=l[2]*t[e+2]+s[2],p[d++]=1*l[3]+s[3]}:4===n&&(u=function(e){p[d++]=l[0]*t[e]+s[0],p[d++]=l[1]*t[e+1]+s[1],p[d++]=l[2]*t[e+2]+s[2],p[d++]=l[3]*t[e+3]+s[3]}):u=function(e){p[d++]=l[0]*t[e]+s[0],p[d++]=l[1]*t[e+1]+s[1],p[d++]=l[2]*t[e+2]+s[2]};for(let e=0;e<i;e++)u(n*f[e]);return a.nativeArray=p,a}function JT(e,t,n,r){const o=[];return Bo([e[3*r]-e[3*n],e[3*r+1]-e[3*n+1],e[3*r+2]-e[3*n+2]],[e[3*t]-e[3*n],e[3*t+1]-e[3*n+1],e[3*t+2]-e[3*n+2]],o),Fo(o),o}const ey={device:null,fullScreenQuadBuffer:null};function ty(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ey,n),ht(e,t),Ct(e,t,[&quot;device&quot;]),function(e,t){function n(e){let n,r;if(e.dataArray&&!e.nativeArray&&(e.nativeArray=e.dataArray.getData()),e.usage===XT.Index&&(n=qT.newInstance({label:e.label}),n.setDevice(t.device),r=GPUBufferUsage.INDEX|GPUBufferUsage.COPY_DST,n.buildIndexBuffer(e),n.createAndWrite(e.nativeArray,r),n.setArrayInformation([{format:e.format}])),n||(n=LT.newInstance({label:e.label}),n.setDevice(t.device)),e.usage===XT.UniformArray&&(r=GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST,n.createAndWrite(e.nativeArray,r)),e.usage===XT.Storage&&(r=GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST,n.createAndWrite(e.nativeArray,r)),e.usage===XT.Texture&&(r=GPUBufferUsage.COPY_SRC,n.createAndWrite(e.nativeArray,r)),e.usage===XT.PointArray){r=GPUBufferUsage.VERTEX;const t=Zv(e.format),o=QT(e.indexBuffer,e.dataArray.getData(),e.dataArray.getNumberOfComponents(),t,{packExtra:e.packExtra,shift:e.shift,scale:e.scale,cellData:e.cellData,cellOffset:e.cellOffset});n.createAndWrite(o.nativeArray,r),n.setStrideInBytes(Yv(e.format)),n.setArrayInformation([{offset:0,format:e.format,interpolation:e.cellData?&quot;flat&quot;:&quot;perspective&quot;}])}if(e.usage===XT.NormalsFromPoints){r=GPUBufferUsage.VERTEX;const t=Zv(e.format),o=function(e,t){const n=t.getData(),r=e.getData();if(!r||!n)return null;const o=new Int8Array(4*e.getNumberOfCells()),a=r.length;let i=0;for(let e=0;e<a;){const t=JT(n,r[e+1],r[e+2],r[e+3]);o[i++]=127*t[0],o[i++]=127*t[1],o[i++]=127*t[2],o[i++]=127,e+=r[e]+1}return o}(e.cells,e.dataArray),a=QT(e.indexBuffer,o,4,t,{cellData:!0});n.createAndWrite(a.nativeArray,r),n.setStrideInBytes(Yv(e.format)),n.setArrayInformation([{offset:0,format:e.format,interpolation:&quot;flat&quot;}])}return e.usage===XT.RawVertex&&(r=GPUBufferUsage.VERTEX,n.createAndWrite(e.nativeArray,r),n.setStrideInBytes(Yv(e.format)),n.setArrayInformation([{offset:0,format:e.format}])),n.setSourceTime(e.time),n}t.classHierarchy.push(&quot;vtkWebGPUBufferManager&quot;),e.hasBuffer=e=>t.device.hasCachedObject(e),e.getBuffer=e=>e.hash?t.device.getCachedObject(e.hash,n,e):n(e),e.getBufferForPointArray=(t,n)=>{const r=function(e){let t;switch(e.getDataType()){case ZT.UNSIGNED_CHAR:t=&quot;uint8&quot;;break;case ZT.FLOAT:t=&quot;float32&quot;;break;case ZT.UNSIGNED_INT:t=&quot;uint32&quot;;break;case ZT.INT:t=&quot;sint32&quot;;break;case ZT.DOUBLE:t=&quot;float32&quot;;break;case ZT.UNSIGNED_SHORT:t=&quot;uint16&quot;;break;case ZT.SHORT:t=&quot;sin16&quot;;break;default:t=&quot;float32&quot;}switch(e.getNumberOfComponents()){case 2:t+=&quot;x2&quot;;break;case 3:t.includes(&quot;32&quot;)||YT(`unsupported x3 type for ${t}`),t+=&quot;x3&quot;;break;case 4:t+=&quot;x4&quot;}return t}(t),o={hash:`${t.getMTime()}I${n.getMTime()}${r}`,usage:XT.PointArray,format:r,dataArray:t,indexBuffer:n};return e.getBuffer(o)},e.getFullScreenQuadBuffer=()=>{if(t.fullScreenQuadBuffer)return t.fullScreenQuadBuffer;t.fullScreenQuadBuffer=LT.newInstance(),t.fullScreenQuadBuffer.setDevice(t.device);const e=new Float32Array([-1,-1,0,1,-1,0,1,1,0,-1,-1,0,1,1,0,-1,1,0]);return t.fullScreenQuadBuffer.createAndWrite(e,GPUBufferUsage.VERTEX),t.fullScreenQuadBuffer.setStrideInBytes(12),t.fullScreenQuadBuffer.setArrayInformation([{offset:0,format:&quot;float32x3&quot;}]),t.fullScreenQuadBuffer}}(e,t)}var ny={newInstance:Mt(ty),extend:ty,...MT};const{BufferUsage:ry}=ny,{vtkErrorMacro:oy}=Wt,ay={bufferEntries:null,bufferEntryNames:null,sizeInBytes:0,label:null,bindGroupLayoutEntry:null,bindGroupEntry:null};function iy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ay,n),Wt.obj(e,t),t._bufferEntryNames=new Map,t.bufferEntries=[],t.bindGroupLayoutEntry=t.bindGroupLayoutEntry||{buffer:{type:&quot;uniform&quot;}},t.sendTime={},Wt.obj(t.sendTime,{mtime:0}),t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),t.sendDirty=!0,t.sortDirty=!0,Wt.get(e,t,[&quot;binding&quot;,&quot;bindGroupTime&quot;]),Wt.setGet(e,t,[&quot;bindGroupLayoutEntry&quot;,&quot;device&quot;,&quot;label&quot;,&quot;sizeInBytes&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUUniformBuffer&quot;),e.addEntry=(e,n)=>{t._bufferEntryNames.has(e)?oy(`entry named ${e} already exists`):(t.sortDirty=!0,t._bufferEntryNames.set(e,t.bufferEntries.length),t.bufferEntries.push({name:e,type:n,sizeInBytes:Jv(n),offset:-1,nativeType:eT(n),packed:!1}))},e.sortBufferEntries=()=>{if(!t.sortDirty)return;let e=0;const n=[];let r=4;for(let e=0;e<t.bufferEntries.length;e++){const n=t.bufferEntries[e];n.sizeInBytes%16==0&&(r=Math.max(16,r)),n.sizeInBytes%8==0&&(r=Math.max(8,r))}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];!1===o.packed&&o.sizeInBytes%16==0&&(o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes)}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];if(!1===o.packed&&12===o.sizeInBytes)for(let r=0;r<t.bufferEntries.length;r++){const a=t.bufferEntries[r];if(!1===a.packed&&4===a.sizeInBytes){o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes,a.packed=!0,a.offset=e,n.push(a),e+=a.sizeInBytes;break}}}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];if(!o.packed&&o.sizeInBytes%8==0)for(let a=r+1;a<t.bufferEntries.length;a++){const r=t.bufferEntries[a];if(!r.packed&&r.sizeInBytes%8==0){o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes,r.packed=!0,r.offset=e,n.push(r),e+=r.sizeInBytes;break}}}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];if(!o.packed&&o.sizeInBytes%8==0){let r=!1;for(let a=0;!r&&a<t.bufferEntries.length;a++){const i=t.bufferEntries[a];if(!i.packed&&4===i.sizeInBytes)for(let s=a+1;s<t.bufferEntries.length;s++){const a=t.bufferEntries[s];if(!a.packed&&4===a.sizeInBytes){o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes,i.packed=!0,i.offset=e,n.push(i),e+=i.sizeInBytes,a.packed=!0,a.offset=e,n.push(a),e+=a.sizeInBytes,r=!0;break}}}}}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];!o.packed&&o.sizeInBytes>4&&(o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes)}for(let r=0;r<t.bufferEntries.length;r++){const o=t.bufferEntries[r];o.packed||(o.packed=!0,o.offset=e,n.push(o),e+=o.sizeInBytes)}t.bufferEntries=n,t._bufferEntryNames.clear();for(let e=0;e<t.bufferEntries.length;e++)t._bufferEntryNames.set(t.bufferEntries[e].name,e);t.sizeInBytes=e,t.sizeInBytes=r*Math.ceil(t.sizeInBytes/r),t.sortDirty=!1},e.sendIfNeeded=e=>{if(!t.UBO){const n={nativeArray:t.Float32Array,usage:ry.UniformArray,label:t.label};t.UBO=e.getBufferManager().getBuffer(n),t.bindGroupTime.modified(),t.sendDirty=!1}t.sendDirty&&(e.getHandle().queue.writeBuffer(t.UBO.getHandle(),0,t.arrayBuffer,0,t.sizeInBytes),t.sendDirty=!1),t.sendTime.modified()},e.createView=e=>{e in t==0&&(t.arrayBuffer||(t.arrayBuffer=new ArrayBuffer(t.sizeInBytes)),t[e]=Wt.newTypedArray(e,t.arrayBuffer))},e.setValue=(n,r)=>{e.sortBufferEntries();const o=t._bufferEntryNames.get(n);if(void 0===o)return void oy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType];a.lastValue!==r&&(i[a.offset/i.BYTES_PER_ELEMENT]=r,t.sendDirty=!0),a.lastValue=r},e.setArray=(n,r)=>{e.sortBufferEntries();const o=t._bufferEntryNames.get(n);if(void 0===o)return void oy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType];let s=!1;for(let e=0;e<r.length;e++)a.lastValue&&a.lastValue[e]===r[e]||(i[a.offset/i.BYTES_PER_ELEMENT+e]=r[e],s=!0);s&&(t.sendDirty=!0,a.lastValue=[...r])},e.getBindGroupEntry=()=>({resource:{buffer:t.UBO.getHandle()}}),e.getSendTime=()=>t.sendTime.getMTime(),e.getShaderCode=(n,r)=>{e.sortBufferEntries();const o=[`struct ${t.label}Struct\\n{`];for(let e=0;e<t.bufferEntries.length;e++){const n=t.bufferEntries[e];o.push(`  ${n.name}: ${n.type},`)}return o.push(`};\\n@binding(${n}) @group(${r}) var<uniform> ${t.label}: ${t.label}Struct;`),o.join(&quot;\\n&quot;)}}(e,t)}var sy={newInstance:Wt.newInstance(iy,&quot;vtkWebGPUUniformBuffer&quot;),extend:iy};const{BufferUsage:ly}=ny,{vtkErrorMacro:cy}=Wt,uy={bufferEntries:null,bufferEntryNames:null,sizeInBytes:0,label:null,numberOfInstances:1};function dy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,uy,n),Wt.obj(e,t),t._bufferEntryNames=new Map,t.bufferEntries=[],t._sendTime={},Wt.obj(t._sendTime,{mtime:0}),t.bindGroupTime={},Wt.obj(t.bindGroupTime,{mtime:0}),t.bindGroupLayoutEntry=t.bindGroupLayoutEntry||{buffer:{type:&quot;read-only-storage&quot;}},Wt.get(e,t,[&quot;bindGroupTime&quot;]),Wt.setGet(e,t,[&quot;device&quot;,&quot;bindGroupLayoutEntry&quot;,&quot;label&quot;,&quot;numberOfInstances&quot;,&quot;sizeInBytes&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUStorageBuffer&quot;),e.addEntry=(e,n)=>{if(t._bufferEntryNames.has(e))return void cy(`entry named ${e} already exists`);t._bufferEntryNames.set(e,t.bufferEntries.length);const r=Jv(n);t.bufferEntries.push({name:e,type:n,sizeInBytes:r,offset:t.sizeInBytes,nativeType:eT(n)}),t.sizeInBytes+=r},e.send=e=>{if(!t._buffer){const n={nativeArray:t.Float32Array,usage:ly.Storage,label:t.label};return t._buffer=e.getBufferManager().getBuffer(n),t.bindGroupTime.modified(),void t._sendTime.modified()}e.getHandle().queue.writeBuffer(t._buffer.getHandle(),0,t.arrayBuffer,0,t.sizeInBytes*t.numberOfInstances),t._sendTime.modified()},e.createView=e=>{e in t==0&&(t.arrayBuffer||(t.arrayBuffer=new ArrayBuffer(t.sizeInBytes*t.numberOfInstances)),t[e]=Wt.newTypedArray(e,t.arrayBuffer))},e.setValue=(n,r,o)=>{const a=t._bufferEntryNames.get(n);if(void 0===a)return void cy(`entry named ${n} not found in UBO`);const i=t.bufferEntries[a];e.createView(i.nativeType);const s=t[i.nativeType];s[(i.offset+r*t.sizeInBytes)/s.BYTES_PER_ELEMENT]=o},e.setArray=(n,r,o)=>{const a=t._bufferEntryNames.get(n);if(void 0===a)return void cy(`entry named ${n} not found in UBO`);const i=t.bufferEntries[a];e.createView(i.nativeType);const s=t[i.nativeType],l=(i.offset+r*t.sizeInBytes)/s.BYTES_PER_ELEMENT;for(let e=0;e<o.length;e++)s[l+e]=o[e]},e.setAllInstancesFromArray=(n,r)=>{const o=t._bufferEntryNames.get(n);if(void 0===o)return void cy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType],s=r.length/t.numberOfInstances;for(let e=0;e<t.numberOfInstances;e++){const n=(a.offset+e*t.sizeInBytes)/i.BYTES_PER_ELEMENT;for(let t=0;t<s;t++)i[n+t]=r[e*s+t]}},e.setAllInstancesFromArrayColorToFloat=(n,r)=>{const o=t._bufferEntryNames.get(n);if(void 0===o)return void cy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType],s=r.length/t.numberOfInstances;for(let e=0;e<t.numberOfInstances;e++){const n=(a.offset+e*t.sizeInBytes)/i.BYTES_PER_ELEMENT;for(let t=0;t<s;t++)i[n+t]=r[e*s+t]/255}},e.setAllInstancesFromArray3x3To4x4=(n,r)=>{const o=t._bufferEntryNames.get(n);if(void 0===o)return void cy(`entry named ${n} not found in UBO`);const a=t.bufferEntries[o];e.createView(a.nativeType);const i=t[a.nativeType];for(let e=0;e<t.numberOfInstances;e++){const n=(a.offset+e*t.sizeInBytes)/i.BYTES_PER_ELEMENT;for(let t=0;t<3;t++)for(let o=0;o<3;o++)i[n+4*t+o]=r[9*e+3*t+o]}},e.getSendTime=()=>t._sendTime.getMTime(),e.getShaderCode=(e,n)=>{const r=[`struct ${t.label}StructEntry\\n{`];for(let e=0;e<t.bufferEntries.length;e++){const n=t.bufferEntries[e];r.push(`  ${n.name}: ${n.type},`)}return r.push(`\\n};\\nstruct ${t.label}Struct\\n{\\n  values: array<${t.label}StructEntry>,\\n};\\n@binding(${e}) @group(${n}) var<storage, read> ${t.label}: ${t.label}Struct;\\n`),r.join(&quot;\\n&quot;)},e.getBindGroupEntry=()=>({resource:{buffer:t._buffer.getHandle()}}),e.clearData=()=>{t.numberOfInstances=0,t.sizeInBytes=0,t.bufferEntries=[],t._bufferEntryNames=new Map,t._buffer=null,delete t.arrayBuffer,delete t.Float32Array}}(e,t)}var py={newInstance:Wt.newInstance(dy,&quot;vtkWebGPUStorageBuffer&quot;),extend:dy};const fy=new Float64Array(16),gy=new Float64Array(16),my={volumes:null,rowLength:1024,lastVolumeLength:0};function hy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,my,n),uT.extend(e,t,n),t.fragmentShaderTemplate=&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::Volume::TraverseDec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::IOStructs::Dec\\n\\nfn getTextureValue(vTex: texture_3d<f32>, tpos: vec4<f32>) -> f32\\n{\\n  // todo multicomponent support\\n  return textureSampleLevel(vTex, clampSampler, tpos.xyz, 0.0).r;\\n}\\n\\nfn getGradient(vTex: texture_3d<f32>, tpos: vec4<f32>, vNum: i32, scalar: f32) -> vec4<f32>\\n{\\n  var result: vec4<f32>;\\n\\n  var tstep: vec4<f32> = volumeSSBO.values[vNum].tstep;\\n  result.x = getTextureValue(vTex, tpos + vec4<f32>(tstep.x, 0.0, 0.0, 1.0)) - scalar;\\n  result.y = getTextureValue(vTex, tpos + vec4<f32>(0.0, tstep.y, 0.0, 1.0)) - scalar;\\n  result.z = getTextureValue(vTex, tpos + vec4<f32>(0.0, 0.0, tstep.z, 1.0)) - scalar;\\n  result.w = 0.0;\\n\\n  // divide by spacing as that is our delta\\n  result = result / volumeSSBO.values[vNum].spacing;\\n  // now we have a gradient in unit tcoords\\n\\n  var grad: f32 = length(result.xyz);\\n  if (grad > 0.0)\\n  {\\n    // rotate to View Coords, needed for lighting and shading\\n    var nMat: mat4x4<f32> = rendererUBO.SCVCMatrix * volumeSSBO.values[vNum].planeNormals;\\n    result = nMat * result;\\n    result = result / length(result);\\n  }\\n\\n  // store gradient magnitude in .w\\n  result.w = grad;\\n\\n  return result;\\n}\\n\\nfn processVolume(vTex: texture_3d<f32>, vNum: i32, cNum: i32, posSC: vec4<f32>, tfunRows: f32) -> vec4<f32>\\n{\\n  var outColor: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);\\n\\n  // convert to tcoords and reject if outside the volume\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*posSC;\\n  if (tpos.x < 0.0 || tpos.y < 0.0 || tpos.z < 0.0 ||\\n      tpos.x > 1.0 || tpos.y > 1.0 || tpos.z > 1.0) { return outColor; }\\n\\n  var scalar: f32 = getTextureValue(vTex, tpos);\\n\\n  var coord: vec2<f32> =\\n    vec2<f32>(scalar * componentSSBO.values[cNum].cScale + componentSSBO.values[cNum].cShift,\\n      (0.5 + 2.0 * f32(vNum)) / tfunRows);\\n  var color: vec4<f32> = textureSampleLevel(tfunTexture, clampSampler, coord, 0.0);\\n\\n  var gofactor: f32 = 1.0;\\n  var normal: vec4<f32> = vec4<f32>(0.0,0.0,0.0,0.0);\\n  if (componentSSBO.values[cNum].gomin <  1.0 || volumeSSBO.values[vNum].shade[0] > 0.0)\\n  {\\n    normal = getGradient(vTex, tpos, vNum, scalar);\\n    if (componentSSBO.values[cNum].gomin <  1.0)\\n    {\\n      gofactor = clamp(normal.a*componentSSBO.values[cNum].goScale + componentSSBO.values[cNum].goShift,\\n      componentSSBO.values[cNum].gomin, componentSSBO.values[cNum].gomax);\\n    }\\n  }\\n\\n  coord.x = (scalar * componentSSBO.values[cNum].oScale + componentSSBO.values[cNum].oShift);\\n  var opacity: f32 = textureSampleLevel(ofunTexture, clampSampler, coord, 0.0).r;\\n\\n  if (volumeSSBO.values[vNum].shade[0] > 0.0)\\n  {\\n    color = color*abs(normal.z);\\n  }\\n\\n  outColor = vec4<f32>(color.rgb, gofactor * opacity);\\n\\n  return outColor;\\n}\\n\\n// adjust the start and end point of a raycast such that it intersects the unit cube.\\n// This function is used to take a raycast starting point and step vector\\n// and numSteps and return the startijng and ending steps for intersecting the\\n// unit cube. Recall for a 3D texture, the unit cube is the range of texture coordsinates\\n// that have valid values. So this funtion can be used to take a ray in texture coordinates\\n// and bound it to intersecting the texture.\\n//\\nfn adjustBounds(tpos: vec4<f32>, tstep: vec4<f32>, numSteps: f32) -> vec2<f32>\\n{\\n  var result: vec2<f32> = vec2<f32>(0.0, numSteps);\\n  var tpos2: vec4<f32> = tpos + tstep*numSteps;\\n\\n  // move tpos to the start of the volume\\n  var adjust: f32 =\\n    min(\\n      max(tpos.x/tstep.x, (tpos.x - 1.0)/tstep.x),\\n      min(\\n        max((tpos.y - 1.0)/tstep.y, tpos.y/tstep.y),\\n        max((tpos.z - 1.0)/tstep.z, tpos.z/tstep.z)));\\n  if (adjust < 0.0)\\n  {\\n    result.x = result.x - adjust;\\n  }\\n\\n  // adjust length to the end\\n  adjust =\\n    max(\\n      min(tpos2.x/tstep.x, (tpos2.x - 1.0)/tstep.x),\\n      max(\\n        min((tpos2.y - 1.0)/tstep.y, tpos2.y/tstep.y),\\n        min((tpos2.z - 1.0)/tstep.z, tpos2.z/tstep.z)));\\n  if (adjust > 0.0)\\n  {\\n    result.y = result.y - adjust;\\n  }\\n\\n  return result;\\n}\\n\\nfn getSimpleColor(scalar: f32, vNum: i32, cNum: i32) -> vec4<f32>\\n{\\n  // how many rows (tfuns) do we have in our tfunTexture\\n  var tfunRows: f32 = f32(textureDimensions(tfunTexture).y);\\n\\n  var coord: vec2<f32> =\\n    vec2<f32>(scalar * componentSSBO.values[cNum].cScale + componentSSBO.values[cNum].cShift,\\n      (0.5 + 2.0 * f32(vNum)) / tfunRows);\\n  var color: vec4<f32> = textureSampleLevel(tfunTexture, clampSampler, coord, 0.0);\\n  coord.x = (scalar * componentSSBO.values[cNum].oScale + componentSSBO.values[cNum].oShift);\\n  var opacity: f32 = textureSampleLevel(ofunTexture, clampSampler, coord, 0.0).r;\\n  return vec4<f32>(color.rgb, opacity);\\n}\\n\\nfn traverseMax(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\\n{\\n  // convert to tcoords and reject if outside the volume\\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\\n  var tstep: vec4<f32> = tpos2 - tpos;\\n\\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\\n\\n  // did we hit anything\\n  if (rayBounds.x >= rayBounds.y)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n    return;\\n  }\\n\\n  tpos = tpos + tstep*rayBounds.x;\\n  var curDist: f32 = rayBounds.x;\\n  var maxVal: f32 = -1.0e37;\\n  loop\\n  {\\n    var scalar: f32 = getTextureValue(vTex, tpos);\\n    if (scalar > maxVal)\\n    {\\n      maxVal = scalar;\\n    }\\n\\n    // increment position\\n    curDist = curDist + 1.0;\\n    tpos = tpos + tstep;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayBounds.y) { break; }\\n  }\\n\\n  // process to get the color and opacity\\n  traverseVals[vNum] = getSimpleColor(maxVal, vNum, cNum);\\n}\\n\\nfn traverseMin(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\\n{\\n  // convert to tcoords and reject if outside the volume\\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\\n  var tstep: vec4<f32> = tpos2 - tpos;\\n\\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\\n\\n  // did we hit anything\\n  if (rayBounds.x >= rayBounds.y)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n    return;\\n  }\\n\\n  tpos = tpos + tstep*rayBounds.x;\\n  var curDist: f32 = rayBounds.x;\\n  var minVal: f32 = 1.0e37;\\n  loop\\n  {\\n    var scalar: f32 = getTextureValue(vTex, tpos);\\n    if (scalar < minVal)\\n    {\\n      minVal = scalar;\\n    }\\n\\n    // increment position\\n    curDist = curDist + 1.0;\\n    tpos = tpos + tstep;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayBounds.y) { break; }\\n  }\\n\\n  // process to get the color and opacity\\n  traverseVals[vNum] = getSimpleColor(minVal, vNum, cNum);\\n}\\n\\nfn traverseAverage(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\\n{\\n  // convert to tcoords and reject if outside the volume\\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\\n  var tstep: vec4<f32> = tpos2 - tpos;\\n\\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\\n\\n  // did we hit anything\\n  if (rayBounds.x >= rayBounds.y)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n    return;\\n  }\\n\\n  let ipRange: vec4<f32> = volumeSSBO.values[vNum].ipScalarRange;\\n  tpos = tpos + tstep*rayBounds.x;\\n  var curDist: f32 = rayBounds.x;\\n  var avgVal: f32 = 0.0;\\n  var sampleCount: f32 = 0.0;\\n  loop\\n  {\\n    var sample: f32 = getTextureValue(vTex, tpos);\\n    // right now leave filtering off until WebGL changes get merged\\n    // if (ipRange.z == 0.0 || sample >= ipRange.x && sample <= ipRange.y)\\n    // {\\n      avgVal = avgVal + sample;\\n      sampleCount = sampleCount + 1.0;\\n    // }\\n\\n    // increment position\\n    curDist = curDist + 1.0;\\n    tpos = tpos + tstep;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayBounds.y) { break; }\\n  }\\n\\n  if (sampleCount <= 0.0)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n  }\\n\\n  // process to get the color and opacity\\n  traverseVals[vNum] = getSimpleColor(avgVal/sampleCount, vNum, cNum);\\n}\\n\\nfn traverseAdditive(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\\n{\\n  // convert to tcoords and reject if outside the volume\\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\\n  var tstep: vec4<f32> = tpos2 - tpos;\\n\\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\\n\\n  // did we hit anything\\n  if (rayBounds.x >= rayBounds.y)\\n  {\\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\\n    return;\\n  }\\n\\n  let ipRange: vec4<f32> = volumeSSBO.values[vNum].ipScalarRange;\\n  tpos = tpos + tstep*rayBounds.x;\\n  var curDist: f32 = rayBounds.x;\\n  var sumVal: f32 = 0.0;\\n  loop\\n  {\\n    var sample: f32 = getTextureValue(vTex, tpos);\\n    // right now leave filtering off until WebGL changes get merged\\n    // if (ipRange.z == 0.0 || sample >= ipRange.x && sample <= ipRange.y)\\n    // {\\n      sumVal = sumVal + sample;\\n    // }\\n\\n    // increment position\\n    curDist = curDist + 1.0;\\n    tpos = tpos + tstep;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayBounds.y) { break; }\\n  }\\n\\n  // process to get the color and opacity\\n  traverseVals[vNum] = getSimpleColor(sumVal, vNum, cNum);\\n}\\n\\nfn composite(rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>) -> vec4<f32>\\n{\\n  // initial ray position is at the beginning\\n  var rayPosSC: vec4<f32> = minPosSC;\\n\\n  // how many rows (tfuns) do we have in our tfunTexture\\n  var tfunRows: f32 = f32(textureDimensions(tfunTexture).y);\\n\\n  var curDist: f32 = 0.0;\\n  var computedColor: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);\\n  var sampleColor: vec4<f32>;\\n//VTK::Volume::TraverseCalls\\n\\n  loop\\n  {\\n    // for each volume, sample and accumulate color\\n//VTK::Volume::CompositeCalls\\n\\n    // increment position\\n    curDist = curDist + mapperUBO.SampleDistance;\\n    rayPosSC = rayPosSC + rayStepSC;\\n\\n    // check if we have reached a terminating condition\\n    if (curDist > rayLengthSC) { break; }\\n    if (computedColor.a > 0.98) { break; }\\n  }\\n  return computedColor;\\n}\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output: fragmentOutput;\\n\\n  var rayMax: f32 = textureSampleLevel(maxTexture, clampSampler, input.tcoordVS, 0.0).r;\\n  var rayMin: f32 = textureSampleLevel(minTexture, clampSampler, input.tcoordVS, 0.0).r;\\n\\n  // discard empty rays\\n  if (rayMax <= rayMin) { discard; }\\n  else\\n  {\\n    // compute start and end ray positions in view coordinates\\n    var minPosSC: vec4<f32> = rendererUBO.PCSCMatrix*vec4<f32>(2.0 * input.tcoordVS.x - 1.0, 1.0 - 2.0 * input.tcoordVS.y, rayMax, 1.0);\\n    minPosSC = minPosSC * (1.0 / minPosSC.w);\\n    var maxPosSC: vec4<f32> = rendererUBO.PCSCMatrix*vec4<f32>(2.0 * input.tcoordVS.x - 1.0, 1.0 - 2.0 * input.tcoordVS.y, rayMin, 1.0);\\n    maxPosSC = maxPosSC * (1.0 / maxPosSC.w);\\n\\n    var rayLengthSC: f32 = distance(minPosSC.xyz, maxPosSC.xyz);\\n    var rayStepSC: vec4<f32> = (maxPosSC - minPosSC)*(mapperUBO.SampleDistance/rayLengthSC);\\n    rayStepSC.w = 0.0;\\n\\n    var computedColor: vec4<f32>;\\n\\n//VTK::Volume::Loop\\n\\n//VTK::RenderEncoder::Impl\\n  }\\n\\n  return output;\\n}\\n&quot;,t.UBO=sy.newInstance({label:&quot;mapperUBO&quot;}),t.UBO.addEntry(&quot;SampleDistance&quot;,&quot;f32&quot;),t.SSBO=py.newInstance({label:&quot;volumeSSBO&quot;}),t.componentSSBO=py.newInstance({label:&quot;componentSSBO&quot;}),t.lutBuildTime={},Wt.obj(t.lutBuildTime,{mtime:0}),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUVolumePassFSQ&quot;),e.replaceShaderPosition=(e,t,n)=>{const r=t.getShaderDescription(&quot;vertex&quot;);r.addBuiltinOutput(&quot;vec4<f32>&quot;,&quot;@builtin(position) Position&quot;);let o=r.getCode();o=_v.substitute(o,&quot;//VTK::Position::Impl&quot;,[&quot;output.tcoordVS = vec2<f32>(vertexBC.x * 0.5 + 0.5, 1.0 - vertexBC.y * 0.5 - 0.5);&quot;,&quot;output.Position = vec4<f32>(vertexBC, 1.0);&quot;]).result,r.setCode(o),t.getShaderDescription(&quot;fragment&quot;).addBuiltinInput(&quot;vec4<f32>&quot;,&quot;@builtin(position) fragPos&quot;)},t.shaderReplacements.set(&quot;replaceShaderPosition&quot;,e.replaceShaderPosition),e.replaceShaderVolume=(e,n,r)=>{const o=n.getShaderDescription(&quot;fragment&quot;);let a=o.getCode();const i=[],s=[];for(let e=0;e<t.volumes.length;e++)t.volumes[e].getRenderable().getMapper().getBlendMode()===eg.COMPOSITE_BLEND?(i.push(`    sampleColor = processVolume(volTexture${e}, ${e}, ${t.rowStarts[e]}, rayPosSC, tfunRows);`),i.push(&quot;    computedColor = vec4<f32>(\\n          sampleColor.a * sampleColor.rgb * (1.0 - computedColor.a) + computedColor.rgb,\\n          (1.0 - computedColor.a)*sampleColor.a + computedColor.a);&quot;)):(s.push(`  sampleColor = traverseVals[${e}];`),s.push(&quot;  computedColor = vec4<f32>(\\n          sampleColor.a * sampleColor.rgb * (1.0 - computedColor.a) + computedColor.rgb,\\n          (1.0 - computedColor.a)*sampleColor.a + computedColor.a);&quot;));a=_v.substitute(a,&quot;//VTK::Volume::CompositeCalls&quot;,i).result,a=_v.substitute(a,&quot;//VTK::Volume::TraverseCalls&quot;,s).result,a=_v.substitute(a,&quot;//VTK::Volume::TraverseDec&quot;,[`var<private> traverseVals: array<vec4<f32>,${t.volumes.length}>;`]).result;let l=!1;for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getMapper().getBlendMode();n===eg.COMPOSITE_BLEND?l=!0:n===eg.MAXIMUM_INTENSITY_BLEND?a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[`    traverseMax(volTexture${e}, ${e}, ${e}, rayLengthSC, minPosSC, rayStepSC);`,`    computedColor = traverseVals[${e}];`,&quot;//VTK::Volume::Loop&quot;]).result:n===eg.MINIMUM_INTENSITY_BLEND?a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[`    traverseMin(volTexture${e}, ${e}, ${e}, rayLengthSC, minPosSC, rayStepSC);`,`    computedColor = traverseVals[${e}];`,&quot;//VTK::Volume::Loop&quot;]).result:n===eg.AVERAGE_INTENSITY_BLEND?a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[`    traverseAverage(volTexture${e}, ${e}, ${e}, rayLengthSC, minPosSC, rayStepSC);`,`    computedColor = traverseVals[${e}];`,&quot;//VTK::Volume::Loop&quot;]).result:n===eg.ADDITIVE_INTENSITY_BLEND&&(a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[`    traverseAdditive(volTexture${e}, ${e}, ${e}, rayLengthSC, minPosSC, rayStepSC);`,`    computedColor = traverseVals[${e}];`,&quot;//VTK::Volume::Loop&quot;]).result)}l&&(a=_v.substitute(a,&quot;//VTK::Volume::Loop&quot;,[&quot;    computedColor = composite(rayLengthSC, minPosSC, rayStepSC);&quot;]).result),o.setCode(a)},t.shaderReplacements.set(&quot;replaceShaderVolume&quot;,e.replaceShaderVolume),e.updateLUTImage=n=>{let r=e.getMTime();for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),o=n.getMapper().getInputData();r=Math.max(r,n.getMTime(),o.getMTime())}if(r<t.lutBuildTime.getMTime())return;t.numRows=0,t.rowStarts=[];for(let e=0;e<t.volumes.length;e++){t.rowStarts.push(t.numRows);const n=t.volumes[e].getRenderable(),r=n.getMapper(),o=n.getProperty(),a=r.getInputData(),i=(a.getPointData()&&a.getPointData().getScalars()).getNumberOfComponents(),s=o.getIndependentComponents()?i:1;t.numRows+=s}const o=new Uint8ClampedArray(2*t.numRows*t.rowLength*4),a=new Float32Array(2*t.numRows*t.rowLength);let i=0;const s=new Float32Array(3*t.rowLength),l=t.rowLength;for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),r=n.getMapper(),c=n.getProperty(),u=r.getInputData(),d=(u.getPointData()&&u.getPointData().getScalars()).getNumberOfComponents(),p=c.getIndependentComponents()?d:1;for(let e=0;e<p;++e){const n=c.getRGBTransferFunction(e),r=n.getRange();n.getTable(r[0],r[1],l,s,1);let u=i*l*4;for(let e=0;e<l;++e){o[u+4*e]=255*s[3*e],o[u+4*e+1]=255*s[3*e+1],o[u+4*e+2]=255*s[3*e+2],o[u+4*e+3]=255;for(let t=0;t<4;t++)o[u+4*(l+e)+t]=o[u+4*e+t]}const d=c.getScalarOpacity(e),p=t.sampleDist/c.getScalarOpacityUnitDistance(e),f=d.getRange();d.getTable(f[0],f[1],l,s,1),u=i*l;for(let e=0;e<l;++e)a[u+e]=1-(1-s[e])**p,a[u+e+l]=a[u+e];i+=2}}{const e={nativeArray:o,width:t.rowLength,height:2*t.numRows,depth:1,format:&quot;rgba8unorm&quot;},r=n.getTextureManager().getTexture(e).createView(&quot;tfunTexture&quot;);t.textureViews[2]=r}{const e={nativeArray:a,width:t.rowLength,height:2*t.numRows,depth:1,format:&quot;r16float&quot;},r=n.getTextureManager().getTexture(e).createView(&quot;ofunTexture&quot;);t.textureViews[3]=r}t.lutBuildTime.modified()},e.updateSSBO=n=>{let r=Math.max(e.getMTime(),t.WebGPURenderer.getStabilizedTime());for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),o=n.getMapper(),a=o.getInputData();r=Math.max(r,n.getMTime(),a.getMTime(),o.getMTime())}if(r<t.SSBO.getSendTime())return;const o=t.WebGPURenderer.getStabilizedCenterByReference();t.SSBO.clearData(),t.SSBO.setNumberOfInstances(t.volumes.length);const a=new Float64Array(16*t.volumes.length),i=new Float64Array(16*t.volumes.length),s=new Float64Array(4*t.volumes.length),l=new Float64Array(4*t.volumes.length),c=new Float64Array(4*t.volumes.length),u=new Float64Array(4*t.volumes.length);for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),r=n.getMapper().getInputData();m(fy),x(fy,fy,o);const d=n.getMatrix();h(gy,d),v(gy,gy),b(fy,gy,fy);const p=r.getWorldToIndex();b(fy,p,fy);const f=r.getDimensions();m(gy),C(gy,gy,[1/f[0],1/f[1],1/f[2]]),b(fy,gy,fy);for(let t=0;t<16;t++)a[16*e+t]=fy[t];v(fy,fy);for(let t=0;t<4;t++)i[16*e+4*t]=fy[4*t],i[16*e+4*t+1]=fy[4*t+1],i[16*e+4*t+2]=fy[4*t+2],i[16*e+4*t+3]=0;s[4*e]=1/f[0],s[4*e+1]=1/f[1],s[4*e+2]=1/f[2],s[4*e+3]=1,l[4*e]=n.getProperty().getShade()?1:0;const g=r.getSpacing();c[4*e]=g[0],c[4*e+1]=g[1],c[4*e+2]=g[2],c[4*e+3]=1;const T=t.textureViews[e+4].getTexture().getScale(),y=n.getProperty().getIpScalarRange();u[4*e]=y[0]/T,u[4*e+1]=y[1]/T,u[4*e+2]=n.getProperty().getFilterMode()}t.SSBO.addEntry(&quot;SCTCMatrix&quot;,&quot;mat4x4<f32>&quot;),t.SSBO.addEntry(&quot;planeNormals&quot;,&quot;mat4x4<f32>&quot;),t.SSBO.addEntry(&quot;shade&quot;,&quot;vec4<f32>&quot;),t.SSBO.addEntry(&quot;tstep&quot;,&quot;vec4<f32>&quot;),t.SSBO.addEntry(&quot;spacing&quot;,&quot;vec4<f32>&quot;),t.SSBO.addEntry(&quot;ipScalarRange&quot;,&quot;vec4<f32>&quot;),t.SSBO.setAllInstancesFromArray(&quot;SCTCMatrix&quot;,a),t.SSBO.setAllInstancesFromArray(&quot;planeNormals&quot;,i),t.SSBO.setAllInstancesFromArray(&quot;shade&quot;,l),t.SSBO.setAllInstancesFromArray(&quot;tstep&quot;,s),t.SSBO.setAllInstancesFromArray(&quot;spacing&quot;,c),t.SSBO.setAllInstancesFromArray(&quot;ipScalarRange&quot;,u),t.SSBO.send(n),t.componentSSBO.clearData(),t.componentSSBO.setNumberOfInstances(t.numRows);const d=new Float64Array(t.numRows),p=new Float64Array(t.numRows),f=new Float64Array(t.numRows),g=new Float64Array(t.numRows),T=new Float64Array(t.numRows),y=new Float64Array(t.numRows),S=new Float64Array(t.numRows),A=new Float64Array(t.numRows);let I=0;for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable(),r=n.getMapper(),o=n.getProperty(),a=r.getInputData(),i=(a.getPointData()&&a.getPointData().getScalars()).getNumberOfComponents(),s=o.getIndependentComponents(),l=t.textureViews[e+4].getTexture().getFormat(),c=Xv(l),u={scale:[255],offset:[0]};2===c.elementSize&&&quot;float&quot;===c.sampleType&&(u.scale[0]=1);for(let e=0;e<i;e++){const t=s?e:0,n=u.scale[e],r=o.getScalarOpacity(t).getRange(),a=n/(r[1]-r[0]),i=(u.offset[e]-r[0])/(r[1]-r[0]);g[I]=i,f[I]=a;const l=o.getRGBTransferFunction(t).getRange();if(p[I]=(u.offset[e]-l[0])/(l[1]-l[0]),d[I]=n/(l[1]-l[0]),o.getUseGradientOpacity(t)){const e=o.getGradientOpacityMinimumOpacity(t),r=o.getGradientOpacityMaximumOpacity(t);T[I]=e,y[I]=r;const a=[o.getGradientOpacityMinimumValue(t),o.getGradientOpacityMaximumValue(t)];A[I]=n*(r-e)/(a[1]-a[0]),S[I]=-a[0]*(r-e)/(a[1]-a[0])+e}else T[I]=1,y[I]=1,A[I]=0,S[I]=1;I++}}t.componentSSBO.addEntry(&quot;cScale&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;cShift&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;oScale&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;oShift&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;goShift&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;goScale&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;gomin&quot;,&quot;f32&quot;),t.componentSSBO.addEntry(&quot;gomax&quot;,&quot;f32&quot;),t.componentSSBO.setAllInstancesFromArray(&quot;cScale&quot;,d),t.componentSSBO.setAllInstancesFromArray(&quot;cShift&quot;,p),t.componentSSBO.setAllInstancesFromArray(&quot;oScale&quot;,f),t.componentSSBO.setAllInstancesFromArray(&quot;oShift&quot;,g),t.componentSSBO.setAllInstancesFromArray(&quot;goScale&quot;,A),t.componentSSBO.setAllInstancesFromArray(&quot;goShift&quot;,S),t.componentSSBO.setAllInstancesFromArray(&quot;gomin&quot;,T),t.componentSSBO.setAllInstancesFromArray(&quot;gomax&quot;,y),t.componentSSBO.send(n)};const n=e.updateBuffers;e.updateBuffers=()=>{n();let r=t.volumes[0].getRenderable().getMapper().getSampleDistance();for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getMapper().getSampleDistance();n<r&&(r=n)}t.sampleDist!==r&&(t.sampleDist=r,t.UBO.setValue(&quot;SampleDistance&quot;,r),t.UBO.sendIfNeeded(t.device));for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getMapper().getInputData(),r=t.device.getTextureManager().getTextureForImageData(n);if(!t.textureViews[e+4]||t.textureViews[e+4].getTexture()!==r){const n=r.createView(`volTexture${e}`);t.textureViews[e+4]=n}}if(t.volumes.length<t.lastVolumeLength)for(let e=t.volumes.length;e<t.lastVolumeLength;e++)t.textureViews.pop();t.lastVolumeLength=t.volumes.length,e.updateLUTImage(t.device),e.updateSSBO(t.device),t.clampSampler||(t.clampSampler=vT.newInstance({label:&quot;clampSampler&quot;}),t.clampSampler.create(t.device,{minFilter:&quot;linear&quot;,magFilter:&quot;linear&quot;}))},e.computePipelineHash=()=>{t.pipelineHash=&quot;volfsq&quot;;for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getMapper().getBlendMode();t.pipelineHash+=`${n}`}},e.setVolumes=n=>{if(!t.volumes||t.volumes.length!==n.length)return t.volumes=[...n],void e.modified();for(let r=0;r<n.length;r++)if(n[r]!==t.volumes[r])return t.volumes=[...n],void e.modified()};const r=e.getBindables;e.getBindables=()=>{const e=r();return e.push(t.componentSSBO),e.push(t.clampSampler),e}}(e,t)}var vy={newInstance:Wt.newInstance(hy,&quot;vtkWebGPUVolumePassFSQ&quot;),extend:hy};const{Representation:Ty}=os,{BufferUsage:yy,PrimitiveTypes:by}=ny,xy=[[0,4,6],[0,6,2],[1,3,7],[1,7,5],[0,5,4],[0,1,5],[2,6,7],[2,7,3],[0,3,1],[0,2,3],[4,5,7],[4,7,6]],Cy={colorTextureView:null,depthTextureView:null,volumes:null};function Sy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Cy,n),ev.extend(e,t,n),t._mapper=sT.newInstance(),t._mapper.setFragmentShaderTemplate(&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Select::Dec\\n\\n//VTK::VolumePass::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output : fragmentOutput;\\n\\n  //VTK::Select::Impl\\n\\n  //VTK::TCoord::Impl\\n\\n  //VTK::VolumePass::Impl\\n\\n  // use the maximum (closest) of the current value and the zbuffer\\n  // the blend func will then take the min to find the farthest stop value\\n  var stopval: f32 = max(input.fragPos.z, textureLoad(opaquePassDepthTexture, vec2<i32>(i32(input.fragPos.x), i32(input.fragPos.y)), 0));\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;),t._mapper.getShaderReplacements().set(&quot;replaceShaderVolumePass&quot;,((e,t,n)=>{t.getShaderDescription(&quot;fragment&quot;).addBuiltinInput(&quot;vec4<f32>&quot;,&quot;@builtin(position) fragPos&quot;)})),t._boundsPoly=gu.newInstance(),t._lastMTimes=[],Wt.setGet(e,t,[&quot;colorTextureView&quot;,&quot;depthTextureView&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUVolumePass&quot;),e.initialize=n=>{t._clearEncoder||e.createClearEncoder(n),t._mergeEncoder||e.createMergeEncoder(n),t._copyEncoder||e.createCopyEncoder(n),t._depthRangeEncoder||e.createDepthRangeEncoder(n),t.fullScreenQuad||(t.fullScreenQuad=vy.newInstance(),t.fullScreenQuad.setDevice(n.getDevice()),t.fullScreenQuad.setTextureViews([...t._depthRangeEncoder.getColorTextureViews()])),t._volumeCopyQuad||(t._volumeCopyQuad=uT.newInstance(),t._volumeCopyQuad.setPipelineHash(&quot;volpassfsq&quot;),t._volumeCopyQuad.setDevice(n.getDevice()),t._volumeCopyQuad.setFragmentShaderTemplate(&quot;\\n//VTK::Renderer::Dec\\n\\n//VTK::Mapper::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output: fragmentOutput;\\n\\n  var computedColor: vec4<f32> = textureSample(volumePassColorTexture,\\n    volumePassColorTextureSampler, mapperUBO.tscale*input.tcoordVS);\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;),t._copyUBO=sy.newInstance({label:&quot;mapperUBO&quot;}),t._copyUBO.addEntry(&quot;tscale&quot;,&quot;vec2<f32>&quot;),t._volumeCopyQuad.setUBO(t._copyUBO),t._volumeCopyQuad.setTextureViews([t._colorTextureView]))},e.traverse=(n,r)=>{if(t.deleted)return;t._currentParent=r,e.initialize(r),e.computeTiming(r),e.renderDepthBounds(n,r),t._firstGroup=!0;const o=r.getDevice(),a=o.getHandle().limits.maxSampledTexturesPerShaderStage-4;if(t.volumes.length>a){const o=n.getRenderable().getActiveCamera().getPosition(),i=[];for(let e=0;e<t.volumes.length;e++){const n=t.volumes[e].getRenderable().getBounds(),r=[.5*(n[1]+n[0]),.5*(n[3]+n[2]),.5*(n[5]+n[4])];i[e]=Go(r,o)}const s=[...Array(t.volumes.length).keys()];s.sort(((e,t)=>i[t]-i[e]));let l=[],c=s.length%a;for(let o=0;o<s.length;o++)l.push(t.volumes[s[o]]),l.length>=c&&(e.rayCastPass(r,n,l),l=[],c=a,t._firstGroup=!1)}else e.rayCastPass(r,n,t.volumes);if(t._volumeCopyQuad.setWebGPURenderer(n),t._useSmallViewport){const e=t._colorTextureView.getTexture().getWidth(),n=t._colorTextureView.getTexture().getHeight();t._copyUBO.setArray(&quot;tscale&quot;,[t._smallViewportWidth/e,t._smallViewportHeight/n])}else t._copyUBO.setArray(&quot;tscale&quot;,[1,1]);t._copyUBO.sendIfNeeded(o),t._copyEncoder.setColorTextureView(0,t.colorTextureView),t._copyEncoder.attachTextureViews(),t._copyEncoder.begin(r.getCommandEncoder()),n.scissorAndViewport(t._copyEncoder),t._volumeCopyQuad.prepareAndDraw(t._copyEncoder),t._copyEncoder.end()},e.delete=Wt.chain((()=>{t._animationRateSubscription&&(t._animationRateSubscription.unsubscribe(),t._animationRateSubscription=null)}),e.delete),e.computeTiming=e=>{const n=e.getRenderable().getInteractor();if(null==t._lastScale){const e=t.volumes[0].getRenderable().getMapper();t._lastScale=e.getInitialInteractionScale()||1}t._useSmallViewport=!1,n.isAnimating()&&t._lastScale>1.5&&(t._useSmallViewport=!0),t._colorTexture.resize(e.getCanvas().width,e.getCanvas().height),t._animationRateSubscription||(t._animationRateSubscription=n.onAnimationFrameRateUpdate((()=>{const e=t.volumes[0].getRenderable().getMapper();if(e.getAutoAdjustSampleDistances()){const e=n.getRecentAnimationFrameRate(),r=t._lastScale*n.getDesiredUpdateRate()/e;t._lastScale=r,t._lastScale>400&&(t._lastScale=400)}else t._lastScale=e.getImageSampleDistance()*e.getImageSampleDistance();t._lastScale<1.5&&(t._lastScale=1.5)})))},e.rayCastPass=(e,n,r)=>{const o=t._firstGroup?t._clearEncoder:t._mergeEncoder;o.attachTextureViews(),o.begin(e.getCommandEncoder());let a=t._colorTextureView.getTexture().getWidth(),i=t._colorTextureView.getTexture().getHeight();if(t._useSmallViewport){const n=e.getCanvas(),r=1/Math.sqrt(t._lastScale);t._smallViewportWidth=Math.ceil(r*n.width),t._smallViewportHeight=Math.ceil(r*n.height),a=t._smallViewportWidth,i=t._smallViewportHeight}o.getHandle().setViewport(0,0,a,i,0,1),o.getHandle().setScissorRect(0,0,a,i),t.fullScreenQuad.setWebGPURenderer(n),t.fullScreenQuad.setVolumes(r),t.fullScreenQuad.prepareAndDraw(o),o.end()},e.renderDepthBounds=(n,r)=>{e.updateDepthPolyData(n);const o=t._boundsPoly,a=o.getPoints(),i=o.getPolys();let s={hash:`vp${i.getMTime()}`,usage:yy.Index,cells:i,numberOfPoints:a.getNumberOfPoints(),primitiveType:by.Triangles,representation:Ty.SURFACE};const l=r.getDevice().getBufferManager().getBuffer(s);t._mapper.getVertexInput().setIndexBuffer(l),s={usage:yy.PointArray,format:&quot;float32x4&quot;,hash:`vp${a.getMTime()}${i.getMTime()}`,dataArray:a,indexBuffer:l,packExtra:!0};const c=r.getDevice().getBufferManager().getBuffer(s);t._mapper.getVertexInput().addBuffer(c,[&quot;vertexBC&quot;]),t._mapper.setNumberOfVertices(c.getSizeInBytes()/c.getStrideInBytes()),e.drawDepthRange(n,r)},e.updateDepthPolyData=e=>{let n=!1;for(let e=0;e<t.volumes.length;e++){const r=t.volumes[e].getMTime();t._lastMTimes[e]&&r===t._lastMTimes[e]||(n=!0,t._lastMTimes[e]=r)}const r=e.getStabilizedTime();if((t._lastMTimes.length<=t.volumes.length||r!==t._lastMTimes[t.volumes.length])&&(n=!0,t._lastMTimes[t.volumes.length]=r),!n)return;const o=e.getStabilizedCenterByReference(),a=8*t.volumes.length,i=new Float64Array(3*a),s=12*t.volumes.length,l=new Uint16Array(4*s);for(let e=0;e<t.volumes.length;e++){t.volumes[e].getBoundingCubePoints(i,24*e);let n=12*e*4;const r=8*e;for(let e=0;e<12;e++)l[n++]=3,l[n++]=r+xy[e][0],l[n++]=r+xy[e][1],l[n++]=r+xy[e][2]}for(let e=0;e<i.length;e+=3)i[e]-=o[0],i[e+1]-=o[1],i[e+2]-=o[2];t._boundsPoly.getPoints().setData(i,3),t._boundsPoly.getPoints().modified(),t._boundsPoly.getPolys().setData(l,1),t._boundsPoly.getPolys().modified(),t._boundsPoly.modified()},e.drawDepthRange=(n,r)=>{t._depthRangeTexture.resizeToMatch(t.colorTextureView.getTexture()),t._depthRangeTexture2.resizeToMatch(t.colorTextureView.getTexture()),t._depthRangeEncoder.attachTextureViews(),e.setCurrentOperation(&quot;volumeDepthRangePass&quot;),n.setRenderEncoder(t._depthRangeEncoder),n.volumeDepthRangePass(!0),t._mapper.setWebGPURenderer(n),t._mapper.prepareToDraw(t._depthRangeEncoder),t._mapper.registerDrawCallback(t._depthRangeEncoder),n.volumeDepthRangePass(!1)},e.createDepthRangeEncoder=e=>{const n=e.getDevice();t._depthRangeEncoder=gT.newInstance({label:&quot;VolumePass DepthRange&quot;}),t._depthRangeEncoder.setPipelineHash(&quot;volr&quot;),t._depthRangeEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor1&quot;),t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor2&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor1 = vec4<f32>(input.fragPos.z, 0.0, 0.0, 0.0);&quot;,&quot;output.outColor2 = vec4<f32>(stopval, 0.0, 0.0, 0.0);&quot;]).result,t.setCode(n)})),t._depthRangeEncoder.setDescription({colorAttachments:[{view:null,clearValue:[0,0,0,0],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;},{view:null,clearValue:[1,1,1,1],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;}]}),t._depthRangeEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;r16float&quot;,blend:{color:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;,operation:&quot;max&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;,operation:&quot;max&quot;}}},{format:&quot;r16float&quot;,blend:{color:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;,operation:&quot;min&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one&quot;,operation:&quot;min&quot;}}}]}}),t._depthRangeTexture=ST.newInstance({label:&quot;volumePassMaxDepth&quot;}),t._depthRangeTexture.create(n,{width:e.getCanvas().width,height:e.getCanvas().height,format:&quot;r16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING});const r=t._depthRangeTexture.createView(&quot;maxTexture&quot;);t._depthRangeEncoder.setColorTextureView(0,r),t._depthRangeTexture2=ST.newInstance({label:&quot;volumePassDepthMin&quot;}),t._depthRangeTexture2.create(n,{width:e.getCanvas().width,height:e.getCanvas().height,format:&quot;r16float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING});const o=t._depthRangeTexture2.createView(&quot;minTexture&quot;);t._depthRangeEncoder.setColorTextureView(1,o),t._mapper.setDevice(e.getDevice()),t._mapper.setTextureViews([t.depthTextureView])},e.createClearEncoder=e=>{t._colorTexture=ST.newInstance({label:&quot;volumePassColor&quot;}),t._colorTexture.create(e.getDevice(),{width:e.getCanvas().width,height:e.getCanvas().height,format:&quot;bgra8unorm&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC}),t._colorTextureView=t._colorTexture.createView(&quot;volumePassColorTexture&quot;),t._colorTextureView.addSampler(e.getDevice(),{minFilter:&quot;linear&quot;,magFilter:&quot;linear&quot;}),t._clearEncoder=gT.newInstance({label:&quot;VolumePass Clear&quot;}),t._clearEncoder.setColorTextureView(0,t._colorTextureView),t._clearEncoder.setDescription({colorAttachments:[{view:null,clearValue:[0,0,0,0],loadOp:&quot;clear&quot;,storeOp:&quot;store&quot;}]}),t._clearEncoder.setPipelineHash(&quot;volpf&quot;),t._clearEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;bgra8unorm&quot;,blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})},e.createCopyEncoder=e=>{t._copyEncoder=gT.newInstance({label:&quot;volumePassCopy&quot;}),t._copyEncoder.setDescription({colorAttachments:[{view:null,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}]}),t._copyEncoder.setPipelineHash(&quot;volcopypf&quot;),t._copyEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;rgba16float&quot;,blend:{color:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})},e.createMergeEncoder=e=>{t._mergeEncoder=gT.newInstance({label:&quot;volumePassMerge&quot;}),t._mergeEncoder.setColorTextureView(0,t._colorTextureView),t._mergeEncoder.setDescription({colorAttachments:[{view:null,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}]}),t._mergeEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<f32>&quot;,&quot;outColor&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor = vec4<f32>(computedColor.rgb, computedColor.a);&quot;]).result,t.setCode(n)})),t._mergeEncoder.setPipelineHash(&quot;volpf&quot;),t._mergeEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:&quot;bgra8unorm&quot;,blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}})},e.setVolumes=n=>{if(!t.volumes||t.volumes.length!==n.length)return t.volumes=[...n],void e.modified();for(let r=0;r<n.length;r++)if(n[r]!==t.volumes[r])return t.volumes=[...n],void e.modified()}}(e,t)}var Ay={newInstance:Wt.newInstance(Sy,&quot;vtkWebGPUVolumePass&quot;),extend:Sy};const Iy={opaqueActorCount:0,translucentActorCount:0,volumes:null,opaqueRenderEncoder:null,translucentPass:null,volumePass:null};function wy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Iy,n),ev.extend(e,t,n),Wt.setGet(e,t,[&quot;opaquePass&quot;,&quot;translucentPass&quot;,&quot;volumePass&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkForwardPass&quot;),e.traverse=function(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(t.deleted)return;t._currentParent=r,e.setCurrentOperation(&quot;buildPass&quot;),n.traverse(e),t.opaquePass||(t.opaquePass=wT.newInstance());const o=n.getRenderable().getNumberOfLayers(),a=n.getChildren();for(let r=0;r<o;r++)for(let o=0;o<a.length;o++){const i=a[o],s=n.getRenderable().getRenderers()[o];s.getDraw()&&s.getLayer()===r&&(t.opaqueActorCount=0,t.translucentActorCount=0,t.volumes=[],e.setCurrentOperation(&quot;queryPass&quot;),i.traverse(e),e.setCurrentOperation(&quot;cameraPass&quot;),i.traverse(e),t.opaquePass.traverse(i,n),t.translucentActorCount>0&&(t.translucentPass||(t.translucentPass=RT.newInstance()),t.translucentPass.setColorTextureView(t.opaquePass.getColorTextureView()),t.translucentPass.setDepthTextureView(t.opaquePass.getDepthTextureView()),t.translucentPass.traverse(i,n)),t.volumes.length>0&&(t.volumePass||(t.volumePass=Ay.newInstance()),t.volumePass.setColorTextureView(t.opaquePass.getColorTextureView()),t.volumePass.setDepthTextureView(t.opaquePass.getDepthTextureView()),t.volumePass.setVolumes(t.volumes),t.volumePass.traverse(i,n)),e.finalPass(n,i))}},e.finalPass=(n,r)=>{t._finalBlitEncoder||e.createFinalBlitEncoder(n),t._finalBlitOutputTextureView.createFromTextureHandle(n.getCurrentTexture(),{depth:1,format:n.getPresentationFormat()}),t._finalBlitEncoder.attachTextureViews(),t._finalBlitEncoder.begin(n.getCommandEncoder()),r.scissorAndViewport(t._finalBlitEncoder),t._fullScreenQuad.prepareAndDraw(t._finalBlitEncoder),t._finalBlitEncoder.end()},e.createFinalBlitEncoder=e=>{t._finalBlitEncoder=gT.newInstance({label:&quot;forwardPassBlit&quot;}),t._finalBlitEncoder.setDescription({colorAttachments:[{view:null,loadOp:&quot;load&quot;,storeOp:&quot;store&quot;}]}),t._finalBlitEncoder.setPipelineHash(&quot;fpf&quot;),t._finalBlitEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},fragment:{targets:[{format:e.getPresentationFormat(),blend:{color:{srcFactor:&quot;src-alpha&quot;,dstFactor:&quot;one-minus-src-alpha&quot;},alpha:{srcFactor:&quot;one&quot;,dstFactor:&quot;one-minus-src-alpha&quot;}}}]}}),t._fsqSampler=vT.newInstance({label:&quot;finalPassSampler&quot;}),t._fsqSampler.create(e.getDevice(),{minFilter:&quot;linear&quot;,magFilter:&quot;linear&quot;}),t._fullScreenQuad=uT.newInstance(),t._fullScreenQuad.setDevice(e.getDevice()),t._fullScreenQuad.setPipelineHash(&quot;fpfsq&quot;),t._fullScreenQuad.setTextureViews([t.opaquePass.getColorTextureView()]),t._fullScreenQuad.setAdditionalBindables([t._fsqSampler]),t._fullScreenQuad.setFragmentShaderTemplate(&quot;\\n//VTK::Mapper::Dec\\n\\n//VTK::TCoord::Dec\\n\\n//VTK::RenderEncoder::Dec\\n\\n//VTK::IOStructs::Dec\\n\\n@fragment\\nfn main(\\n//VTK::IOStructs::Input\\n)\\n//VTK::IOStructs::Output\\n{\\n  var output: fragmentOutput;\\n\\n  var computedColor: vec4<f32> = clamp(textureSampleLevel(opaquePassColorTexture, finalPassSampler, input.tcoordVS, 0.0),vec4<f32>(0.0),vec4<f32>(1.0));\\n\\n  //VTK::RenderEncoder::Impl\\n  return output;\\n}\\n&quot;),t._finalBlitOutputTextureView=bT.newInstance(),t._finalBlitEncoder.setColorTextureView(0,t._finalBlitOutputTextureView)},e.incrementOpaqueActorCount=()=>t.opaqueActorCount++,e.incrementTranslucentActorCount=()=>t.translucentActorCount++,e.addVolume=e=>{t.volumes.push(e)}}(e,t)}var Oy={newInstance:Wt.newInstance(wy,&quot;vtkForwardPass&quot;),extend:wy};const{VtkDataTypes:Py}=xs,Ry={handle:null,device:null};function My(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ry,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;device&quot;]),function(e,t){function n(e){if(e.imageData){e.dataArray=e.imageData.getPointData().getScalars(),e.time=e.dataArray.getMTime(),e.nativeArray=e.dataArray.getData();const t=e.imageData.getDimensions();switch(e.width=t[0],e.height=t[1],e.depth=t[2],e.dataArray.getNumberOfComponents()){case 1:e.format=&quot;r&quot;;break;case 2:e.format=&quot;rg&quot;;break;default:e.format=&quot;rgba&quot;}switch(e.dataArray.getDataType()){case Py.UNSIGNED_CHAR:e.format+=&quot;8unorm&quot;;break;case Py.FLOAT:case Py.UNSIGNED_INT:case Py.INT:case Py.DOUBLE:case Py.UNSIGNED_SHORT:case Py.SHORT:default:e.format+=&quot;16float&quot;}}e.image&&(e.width=e.image.width,e.height=e.image.height,e.depth=1,e.format=&quot;rgba8unorm&quot;,e.flip=!0,e.usage=GPUTextureUsage.STORAGE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.RENDER_ATTACHMENT),e.jsImageData&&(e.width=e.jsImageData.width,e.height=e.jsImageData.height,e.depth=1,e.format=&quot;rgba8unorm&quot;,e.flip=!0,e.nativeArray=e.jsImageData.data,e.usage=GPUTextureUsage.STORAGE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.RENDER_ATTACHMENT),e.imageBitmap&&(e.width=e.imageBitmap.width,e.height=e.imageBitmap.height,e.depth=1,e.format=&quot;rgba8unorm&quot;,e.flip=!0,e.usage=GPUTextureUsage.STORAGE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.RENDER_ATTACHMENT),e.canvas&&(e.width=e.canvas.width,e.height=e.canvas.height,e.depth=1,e.format=&quot;rgba8unorm&quot;,e.flip=!0,e.usage=GPUTextureUsage.STORAGE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.RENDER_ATTACHMENT)}function r(e){const n=ST.newInstance({label:e.label});return n.create(t.device,{width:e.width,height:e.height,depth:e.depth,format:e.format,usage:e.usage,mipLevel:e.mipLevel}),(e.nativeArray||e.image||e.canvas||e.imageBitmap)&&n.writeImageData(e),n}t.classHierarchy.push(&quot;vtkWebGPUTextureManager&quot;),e.getTexture=e=>e.hash?t.device.getCachedObject(e.hash,r,e):r(e),e.getTextureForImageData=e=>{const r={time:e.getMTime()};return r.imageData=e,n(r),r.hash=r.time+r.format+r.mipLevel,t.device.getTextureManager().getTexture(r)},e.getTextureForVTKTexture=function(e){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:void 0;const o={time:e.getMTime(),label:r};return e.getInputData()?o.imageData=e.getInputData():e.getImage()?o.image=e.getImage():e.getJsImageData()?o.jsImageData=e.getJsImageData():e.getImageBitmap()?o.imageBitmap=e.getImageBitmap():e.getCanvas()&&(o.canvas=e.getCanvas()),n(o),o.mipLevel=e.getMipLevel(),o.hash=o.time+o.format+o.mipLevel,t.device.getTextureManager().getTexture(o)}}(e,t)}var Ey={newInstance:Wt.newInstance(My),extend:My};class Vy extends Map{constructor(){super(),this.registry=new FinalizationRegistry((e=>{const t=super.get(e);t&&t.deref&&void 0===t.deref()&&super.delete(e)}))}getValue(e){const t=super.get(e);if(t){const n=t.deref();if(void 0!==n)return n;super.delete(e)}}setValue(e,t){let n;return t&&&quot;object&quot;==typeof t&&(n=new WeakRef(t),this.registry.register(t,e),super.set(e,n)),n}}const Dy={handle:null,pipelines:null,shaderCache:null,bindGroupLayouts:null,bufferManager:null,textureManager:null};function Ly(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Dy,n),ht(e,t),Ct(e,t,[&quot;handle&quot;]),Tt(e,t,[&quot;bufferManager&quot;,&quot;shaderCache&quot;,&quot;textureManager&quot;]),t.objectCache=new Vy,t.shaderCache=_v.newInstance(),t.shaderCache.setDevice(e),t.bindGroupLayouts=[],t.bufferManager=ny.newInstance(),t.bufferManager.setDevice(e),t.textureManager=Ey.newInstance(),t.textureManager.setDevice(e),t.pipelines={},function(e,t){t.classHierarchy.push(&quot;vtkWebGPUDevice&quot;),e.initialize=e=>{t.handle=e},e.createCommandEncoder=()=>t.handle.createCommandEncoder(),e.submitCommandEncoder=e=>{t.handle.queue.submit([e.finish()])},e.getShaderModule=e=>t.shaderCache.getShaderModule(e),e.getBindGroupLayout=e=>{if(!e.entries)return null;for(let t=0;t<e.entries.length;t++){const n=e.entries[t];n.binding=n.binding||0,n.visibility=n.visibility||GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT}const n=JSON.stringify(e);for(let e=0;e<t.bindGroupLayouts.length;e++)if(t.bindGroupLayouts[e].sval===n)return t.bindGroupLayouts[e].layout;const r=t.handle.createBindGroupLayout(e);return t.bindGroupLayouts.push({sval:n,layout:r}),r},e.getBindGroupLayoutDescription=e=>{for(let n=0;n<t.bindGroupLayouts.length;n++)if(t.bindGroupLayouts[n].layout===e)return t.bindGroupLayouts[n].sval;return vtkErrorMacro(&quot;layout not found&quot;),console.trace(),null},e.getPipeline=e=>e in t.pipelines?t.pipelines[e]:null,e.createPipeline=(n,r)=>{r.initialize(e,n),t.pipelines[n]=r},e.onSubmittedWorkDone=()=>t.handle.queue.onSubmittedWorkDone(),e.hasCachedObject=e=>t.objectCache.getValue(e),e.getCachedObject=function(e,n){if(!e)return vtkErrorMacro(&quot;attempt to cache an object without a hash&quot;),null;const r=t.objectCache.getValue(e);if(r)return r;for(var o=arguments.length,a=new Array(o>2?o-2:0),i=2;i<o;i++)a[i-2]=arguments[i];const s=n(...a);return t.objectCache.setValue(e,s),s}}(e,t)}var By={newInstance:Mt(Ly,&quot;vtkWebGPUDevice&quot;),extend:Ly};const Ny={selectionRenderEncoder:null,colorTexture:null,depthTexture:null};function Fy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ny,n),ev.extend(e,t,n),Wt.get(e,t,[&quot;colorTexture&quot;,&quot;depthTexture&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUHardwareSelectionPass&quot;),e.traverse=(n,r)=>{if(t.deleted)return;t._currentParent=null,e.setCurrentOperation(&quot;buildPass&quot;),n.traverse(e);const o=n.getDevice();if(t.selectionRenderEncoder)t.colorTexture.resize(n.getCanvas().width,n.getCanvas().height),t.depthTexture.resizeToMatch(t.colorTexture);else{e.createRenderEncoder(),t.colorTexture=ST.newInstance({label:&quot;hardwareSelectorColor&quot;}),t.colorTexture.create(o,{width:n.getCanvas().width,height:n.getCanvas().height,format:&quot;rgba32uint&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.COPY_SRC});const r=t.colorTexture.createView(&quot;hardwareSelectColorTexture&quot;);t.selectionRenderEncoder.setColorTextureView(0,r),t.depthTexture=ST.newInstance({label:&quot;hardwareSelectorDepth&quot;}),t.depthTexture.create(o,{width:n.getCanvas().width,height:n.getCanvas().height,format:&quot;depth32float&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.COPY_SRC});const a=t.depthTexture.createView(&quot;hardwareSelectDepthTexture&quot;);t.selectionRenderEncoder.setDepthTextureView(a)}t.selectionRenderEncoder.attachTextureViews(),r.setRenderEncoder(t.selectionRenderEncoder),e.setCurrentOperation(&quot;cameraPass&quot;),r.traverse(e),e.setCurrentOperation(&quot;opaquePass&quot;),r.traverse(e)},e.createRenderEncoder=()=>{t.selectionRenderEncoder=gT.newInstance({label:&quot;HardwareSelectionPass&quot;}),t.selectionRenderEncoder.setPipelineHash(&quot;sel&quot;),t.selectionRenderEncoder.setReplaceShaderCodeFunction((e=>{const t=e.getShaderDescription(&quot;fragment&quot;);t.addOutput(&quot;vec4<u32>&quot;,&quot;outColor&quot;);let n=t.getCode();n=_v.substitute(n,&quot;//VTK::RenderEncoder::Impl&quot;,[&quot;output.outColor = vec4<u32>(mapperUBO.PropID, compositeID, 0u, 0u);&quot;]).result,t.setCode(n)})),t.selectionRenderEncoder.getDescription().colorAttachments[0].clearValue=[0,0,0,0],t.selectionRenderEncoder.setPipelineSettings({primitive:{cullMode:&quot;none&quot;},depthStencil:{depthWriteEnabled:!0,depthCompare:&quot;greater&quot;,format:&quot;depth32float&quot;},fragment:{targets:[{format:&quot;rgba32uint&quot;,blend:void 0}]}})}}(e,t)}var _y={newInstance:Wt.newInstance(Fy,&quot;vtkWebGPUHardwareSelectionPass&quot;),extend:Fy};const{SelectionContent:ky,SelectionField:Gy}=wp,{FieldAssociations:Uy}=Us,{vtkErrorMacro:zy}=Wt;function Wy(e){return`${e.propID} ${e.compositeID}`}function Hy(e,t,n,r){const o=4*((n.height-t-1)*n.colorBufferWidth+e)+r;return n.colorValues[o]}function jy(e,t,n,r){const o=n<0?0:n;if(0===o){if(r[0]=t[0],r[1]=t[1],t[0]<0||t[0]>=e.width||t[1]<0||t[1]>=e.height)return null;const n=Hy(t[0],t[1],e,0);if(n<=0)return null;const o={};o.propID=n;let a=Hy(t[0],t[1],e,1);if((a<0||a>16777215)&&(a=0),o.compositeID=a,e.captureZValues){const n=(e.height-t[1]-1)*e.zbufferBufferWidth+t[0];o.zValue=e.depthValues[n],o.zValue=e.webGPURenderer.convertToOpenGLDepth(o.zValue),o.displayPosition=t}return o}const a=[t[0],t[1]],i=[0,0];let s=jy(e,t,0,r);if(s)return s;for(let t=1;t<o;++t){for(let n=a[1]>t?a[1]-t:0;n<=a[1]+t;++n){if(i[1]=n,a[0]>=t&&(i[0]=a[0]-t,s=jy(e,i,0,r),s))return s;if(i[0]=a[0]+t,s=jy(e,i,0,r),s)return s}for(let n=a[0]>=t?a[0]-(t-1):0;n<=a[0]+(t-1);++n){if(i[0]=n,a[1]>=t&&(i[1]=a[1]-t,s=jy(e,i,0,r),s))return s;if(i[1]=a[1]+t,s=jy(e,i,0,r),s)return s}}return r[0]=t[0],r[1]=t[1],null}const Ky={};function $y(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ky,n),bp.extend(e,t,n),t._selectionPass=_y.newInstance(),Wt.setGet(e,t,[&quot;_WebGPURenderWindow&quot;]),Wt.moveToProtected(e,t,[&quot;WebGPURenderWindow&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUHardwareSelector&quot;),e.endSelection=()=>{t.WebGPURenderer.setSelector(null)},e.getSourceDataAsync=async e=>{if(!e||!t._WebGPURenderWindow)return zy(&quot;Renderer and view must be set before calling Select.&quot;),!1;t._WebGPURenderWindow.getRenderable().preRender(),t._WebGPURenderWindow.getInitialized()||(t._WebGPURenderWindow.initialize(),await new Promise((e=>{t._WebGPURenderWindow.onInitialized(e)})));const n=t._WebGPURenderWindow.getViewNodeFor(e);if(!n)return!1;const r=n.getSuppressClear();n.setSuppressClear(!0),t._selectionPass.traverse(t._WebGPURenderWindow,n),n.setSuppressClear(r);const o=t._WebGPURenderWindow.getDevice(),a=t._selectionPass.getColorTexture(),i=t._selectionPass.getDepthTexture(),s={area:[0,0,a.getWidth()-1,a.getHeight()-1],captureZValues:t.captureZValues,fieldAssociation:t.fieldAssociation,renderer:e,webGPURenderer:n,webGPURenderWindow:t._WebGPURenderWindow,width:a.getWidth(),height:a.getHeight()};s.colorBufferWidth=16*Math.floor((s.width+15)/16),s.colorBufferSizeInBytes=s.colorBufferWidth*s.height*4*4;const l=LT.newInstance({label:&quot;hardwareSelectColorBuffer&quot;});l.setDevice(o),l.create(s.colorBufferSizeInBytes,GPUBufferUsage.MAP_READ|GPUBufferUsage.COPY_DST);const c=t._WebGPURenderWindow.getCommandEncoder();let u;c.copyTextureToBuffer({texture:a.getHandle()},{buffer:l.getHandle(),bytesPerRow:16*s.colorBufferWidth,rowsPerImage:s.height},{width:s.width,height:s.height,depthOrArrayLayers:1}),t.captureZValues&&(s.zbufferBufferWidth=64*Math.floor((s.width+63)/64),u=LT.newInstance({label:&quot;hardwareSelectDepthBuffer&quot;}),u.setDevice(o),s.zbufferSizeInBytes=s.height*s.zbufferBufferWidth*4,u.create(s.zbufferSizeInBytes,GPUBufferUsage.MAP_READ|GPUBufferUsage.COPY_DST),c.copyTextureToBuffer({texture:i.getHandle(),aspect:&quot;depth-only&quot;},{buffer:u.getHandle(),bytesPerRow:4*s.zbufferBufferWidth,rowsPerImage:s.height},{width:s.width,height:s.height,depthOrArrayLayers:1})),o.submitCommandEncoder(c);const d=l.mapAsync(GPUMapMode.READ);if(t.captureZValues){const e=u.mapAsync(GPUMapMode.READ);await Promise.all([d,e]),s.depthValues=new Float32Array(u.getMappedRange().slice()),u.unmap()}else await d;return s.colorValues=new Uint32Array(l.getMappedRange().slice()),l.unmap(),s.generateSelection=(e,t,n,r)=>function(e,t,n,r,o){const a=Math.floor(t),i=Math.floor(n),s=Math.floor(r),l=Math.floor(o),c=new Map,u=[0,0];for(let t=i;t<=l;t++)for(let n=a;n<=s;n++){const r=jy(e,[n,t],0,u);if(r){const t=Wy(r);if(c.has(t)){const n=c.get(t);n.pixelCount++,e.captureZValues&&r.zValue<n.info.zValue&&(n.info=r),-1===n.attributeIDs.indexOf(r.attributeID)&&n.attributeIDs.push(r.attributeID)}else c.set(t,{info:r,pixelCount:1,attributeIDs:[r.attributeID]})}}return function(e,t,n){const r=[];let o=0;return t.forEach(((t,a)=>{const i=wp.newInstance();switch(i.setContentType(ky.INDICES),e){case Uy.FIELD_ASSOCIATION_CELLS:i.setFieldType(Gy.CELL);break;case Uy.FIELD_ASSOCIATION_POINTS:i.setFieldType(Gy.POINT);break;default:zy(&quot;Unknown field association&quot;)}i.getProperties().propID=t.info.propID;const s=n.webGPURenderer.getPropFromID(t.info.propID);i.getProperties().prop=s.getRenderable(),i.getProperties().compositeID=t.info.compositeID,i.getProperties().pixelCount=t.pixelCount,n.captureZValues&&(i.getProperties().displayPosition=[t.info.displayPosition[0],t.info.displayPosition[1],t.info.zValue],i.getProperties().worldPosition=n.webGPURenderWindow.displayToWorld(t.info.displayPosition[0],t.info.displayPosition[1],t.info.zValue,n.renderer)),i.setSelectionList(t.attributeIDs),r[o]=i,o++})),r}(e.fieldAssociation,c,e)}(s,e,t,n,r),s}}(e,t)}var qy={newInstance:Wt.newInstance($y,&quot;vtkWebGPUHardwareSelector&quot;),extend:$y};const Xy=Object.create(null),Yy={};function Zy(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Yy,n),t.overrides=Xy,Zt.extend(e,t,n),function(e,t){t.classHierarchy.push(&quot;vtkWebGPUViewNodeFactory&quot;)}(0,t)}var Qy={newInstance:Wt.newInstance(Zy,&quot;vtkWebGPUViewNodeFactory&quot;),extend:Zy};const{vtkErrorMacro:Jy}=Wt,eb={position:&quot;absolute&quot;,top:0,left:0,width:&quot;100%&quot;,height:&quot;100%&quot;};const tb={initialized:!1,context:null,adapter:null,device:null,canvas:null,cursorVisibility:!0,cursor:&quot;pointer&quot;,containerSize:null,renderPasses:[],notifyStartCaptureImage:!1,imageFormat:&quot;image/png&quot;,useOffScreen:!1,useBackgroundImage:!1,nextPropID:1,xrSupported:!1,presentationFormat:null};const nb=Wt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,tb,n),t.canvas=document.createElement(&quot;canvas&quot;),t.canvas.style.width=&quot;100%&quot;,t.bgImage=new Image,t.bgImage.style.position=&quot;absolute&quot;,t.bgImage.style.left=&quot;0&quot;,t.bgImage.style.top=&quot;0&quot;,t.bgImage.style.width=&quot;100%&quot;,t.bgImage.style.height=&quot;100%&quot;,t.bgImage.style.zIndex=&quot;-1&quot;,xv.extend(e,t,n),t.myFactory=Qy.newInstance(),t.renderPasses[0]=Oy.newInstance(),t.selector||(t.selector=qy.newInstance(),t.selector.setWebGPURenderWindow(e)),Wt.event(e,t,&quot;imageReady&quot;),Wt.event(e,t,&quot;initialized&quot;),Wt.get(e,t,[&quot;commandEncoder&quot;,&quot;device&quot;,&quot;presentationFormat&quot;,&quot;useBackgroundImage&quot;,&quot;xrSupported&quot;]),Wt.setGet(e,t,[&quot;initialized&quot;,&quot;context&quot;,&quot;canvas&quot;,&quot;device&quot;,&quot;renderPasses&quot;,&quot;notifyStartCaptureImage&quot;,&quot;cursor&quot;,&quot;useOffScreen&quot;]),Wt.setGetArray(e,t,[&quot;size&quot;],2),Wt.event(e,t,&quot;windowResizeEvent&quot;),function(e,t){t.classHierarchy.push(&quot;vtkWebGPURenderWindow&quot;),e.getViewNodeFactory=()=>t.myFactory;const n=[0,0];e.onModified((function(){t.renderable&&(t.size[0]===n[0]&&t.size[1]===n[1]||(n[0]=t.size[0],n[1]=t.size[1],t.canvas.setAttribute(&quot;width&quot;,t.size[0]),t.canvas.setAttribute(&quot;height&quot;,t.size[1]),e.recreateSwapChain())),t.viewStream&&t.viewStream.setSize(t.size[0],t.size[1]),t.canvas.style.display=t.useOffScreen?&quot;none&quot;:&quot;block&quot;,t.el&&(t.el.style.cursor=t.cursorVisibility?t.cursor:&quot;none&quot;),t.containerSize=null})),e.recreateSwapChain=()=>{t.context&&(t.context.unconfigure(),t.presentationFormat=navigator.gpu.getPreferredCanvasFormat(t.adapter),t.context.configure({device:t.device.getHandle(),format:t.presentationFormat,alphaMode:&quot;premultiplied&quot;,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.COPY_DST,width:t.size[0],height:t.size[1]}),t._configured=!0)},e.getCurrentTexture=()=>t.context.getCurrentTexture(),e.buildPass=n=>{if(n){if(!t.renderable)return;e.prepareNodes(),e.addMissingNodes(t.renderable.getRenderersByReference()),e.removeUnusedNodes(),e.initialize()}else t.initialized&&(t._configured||e.recreateSwapChain(),t.commandEncoder=t.device.createCommandEncoder())},e.initialize=()=>{if(!t.initializing){if(t.initializing=!0,!navigator.gpu)return void Jy(&quot;WebGPU is not enabled.&quot;);e.create3DContextAsync().then((()=>{t.initialized=!0,t.deleted||e.invokeInitialized()}))}},e.setContainer=n=>{t.el&&t.el!==n&&(t.canvas.parentNode!==t.el&&Jy(&quot;Error: canvas parent node does not match container&quot;),t.el.removeChild(t.canvas),t.el.contains(t.bgImage)&&t.el.removeChild(t.bgImage)),t.el!==n&&(t.el=n,t.el&&(t.el.appendChild(t.canvas),t.useBackgroundImage&&t.el.appendChild(t.bgImage)),e.modified())},e.getContainer=()=>t.el,e.getContainerSize=()=>{if(!t.containerSize&&t.el){const{width:e,height:n}=t.el.getBoundingClientRect();t.containerSize=[e,n]}return t.containerSize||t.size},e.getFramebufferSize=()=>t.size,e.create3DContextAsync=async()=>{t.adapter=await navigator.gpu.requestAdapter({powerPreference:&quot;high-performance&quot;}),t.deleted||(t.device=By.newInstance(),t.device.initialize(await t.adapter.requestDevice()),t.deleted?t.device=null:t.context=t.canvas.getContext(&quot;webgpu&quot;))},e.releaseGraphicsResources=()=>{const n=ev.newInstance();n.setCurrentOperation(&quot;Release&quot;),n.traverse(e,null),t.adapter=null,t.device=null,t.context=null,t.initialized=!1,t.initializing=!1},e.setBackgroundImage=e=>{t.bgImage.src=e.src},e.setUseBackgroundImage=e=>{t.useBackgroundImage=e,t.useBackgroundImage&&!t.el.contains(t.bgImage)?t.el.appendChild(t.bgImage):!t.useBackgroundImage&&t.el.contains(t.bgImage)&&t.el.removeChild(t.bgImage)},e.captureNextImage=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;image/png&quot;,{resetCamera:r=!1,size:o=null,scale:a=1}=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(t.deleted)return null;t.imageFormat=n;const i=t.notifyStartCaptureImage;return t.notifyStartCaptureImage=!0,t._screenshot={size:o||1!==a?o||t.size.map((e=>e*a)):null},new Promise(((n,o)=>{const a=e.onImageReady((o=>{if(null===t._screenshot.size)t.notifyStartCaptureImage=i,a.unsubscribe(),t._screenshot.placeHolder&&(t.size=t._screenshot.originalSize,e.modified(),t._screenshot.cameras&&t._screenshot.cameras.forEach((e=>{let{restoreParamsFn:t,arg:n}=e;return t(n)})),e.traverseAllPasses(),t.el.removeChild(t._screenshot.placeHolder),t._screenshot.placeHolder.remove(),t._screenshot=null),n(o);else{const n=document.createElement(&quot;img&quot;);if(n.style=eb,n.src=o,t._screenshot.placeHolder=t.el.appendChild(n),t.canvas.style.display=&quot;none&quot;,t._screenshot.originalSize=t.size,t.size=t._screenshot.size,t._screenshot.size=null,e.modified(),r){const e=!0!==r;t._screenshot.cameras=t.renderable.getRenderers().map((t=>{const n=t.getActiveCamera(),o=n.get(&quot;focalPoint&quot;,&quot;position&quot;,&quot;parallelScale&quot;);return{resetCameraArgs:e?{renderer:t}:void 0,resetCameraFn:e?r:t.resetCamera,restoreParamsFn:n.set,arg:JSON.parse(JSON.stringify(o))}})),t._screenshot.cameras.forEach((e=>{let{resetCameraFn:t,resetCameraArgs:n}=e;return t(n)}))}e.traverseAllPasses()}}))}))},e.traverseAllPasses=()=>{if(!t.deleted)if(t.initialized){if(t.renderPasses)for(let n=0;n<t.renderPasses.length;++n)t.renderPasses[n].traverse(e,null);t.commandEncoder&&(t.device.submitCommandEncoder(t.commandEncoder),t.commandEncoder=null,t.notifyStartCaptureImage&&t.device.onSubmittedWorkDone().then((()=>{!async function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:t.imageFormat;const r=document.createElement(&quot;canvas&quot;),o=r.getContext(&quot;2d&quot;);r.width=t.canvas.width,r.height=t.canvas.height;const a=await e.getPixelsAsync(),i=new ImageData(a.colorValues,a.width,a.height);o.putImageData(i,0,0);const s=t.canvas.getBoundingClientRect();t.renderable.getRenderers().forEach((e=>{e.getViewProps().forEach((e=>{if(e.getContainer){const t=e.getContainer().getElementsByTagName(&quot;canvas&quot;);for(let e=0;e<t.length;e++){const n=t[e],r=n.getBoundingClientRect(),a=r.x-s.x,i=r.y-s.y;o.drawImage(n,a,i)}}}))}));const l=r.toDataURL(n);r.remove(),e.invokeImageReady(l)}()})))}else{e.initialize();const t=e.onInitialized((()=>{t.unsubscribe(),e.traverseAllPasses()}))}},e.setViewStream=n=>t.viewStream!==n&&(t.subscription&&(t.subscription.unsubscribe(),t.subscription=null),t.viewStream=n,t.viewStream&&(t.renderable.getRenderers()[0].getBackgroundByReference()[3]=0,e.setUseBackgroundImage(!0),t.subscription=t.viewStream.onImageReady((t=>e.setBackgroundImage(t.image))),t.viewStream.setSize(t.size[0],t.size[1]),t.viewStream.invalidateCache(),t.viewStream.render(),e.modified()),!0),e.getUniquePropID=()=>t.nextPropID++,e.getPropFromID=e=>{for(let n=0;n<t.children.length;n++){const r=t.children[n].getPropFromID(e);if(null!==r)return r}return null},e.getPixelsAsync=async()=>{const e=t.device,n=t.renderPasses[0].getOpaquePass().getColorTexture(),r={width:n.getWidth(),height:n.getHeight()};r.colorBufferWidth=32*Math.floor((r.width+31)/32),r.colorBufferSizeInBytes=r.colorBufferWidth*r.height*8;const o=LT.newInstance();o.setDevice(e),o.create(r.colorBufferSizeInBytes,GPUBufferUsage.MAP_READ|GPUBufferUsage.COPY_DST);const a=t.device.createCommandEncoder();a.copyTextureToBuffer({texture:n.getHandle()},{buffer:o.getHandle(),bytesPerRow:8*r.colorBufferWidth,rowsPerImage:r.height},{width:r.width,height:r.height,depthOrArrayLayers:1}),e.submitCommandEncoder(a);const i=o.mapAsync(GPUMapMode.READ);await i,r.colorValues=new Uint16Array(o.getMappedRange().slice()),o.unmap();const s=new Uint8ClampedArray(r.height*r.width*4);for(let e=0;e<r.height;e++)for(let t=0;t<r.width;t++){const n=4*(e*r.width+t),o=4*(e*r.colorBufferWidth+t);s[n]=255*gd.fromHalf(r.colorValues[o]),s[n+1]=255*gd.fromHalf(r.colorValues[o+1]),s[n+2]=255*gd.fromHalf(r.colorValues[o+2]),s[n+3]=255*gd.fromHalf(r.colorValues[o+3])}return r.colorValues=s,r},e.createSelector=()=>{const t=qy.newInstance();return t.setWebGPURenderWindow(e),t};const r=e.setSize;e.setSize=(t,n)=>{const o=r(t,n);return o&&e.invokeWindowResizeEvent({width:t,height:n}),o},e.delete=Wt.chain(e.delete,e.setViewStream)}(e,t)}),&quot;vtkWebGPURenderWindow&quot;);var rb;ph(&quot;WebGPU&quot;,nb),rb=nb,Xy.vtkRenderWindow=rb;const ob=Zh(),ab={margin:&quot;0&quot;,padding:&quot;0&quot;,position:&quot;absolute&quot;,top:&quot;0&quot;,left:&quot;0&quot;,width:&quot;100%&quot;,height:&quot;100%&quot;,overflow:&quot;hidden&quot;},ib={position:&quot;absolute&quot;,left:&quot;25px&quot;,top:&quot;25px&quot;,backgroundColor:&quot;white&quot;,borderRadius:&quot;5px&quot;,listStyle:&quot;none&quot;,padding:&quot;5px 10px&quot;,margin:&quot;0&quot;,display:&quot;block&quot;,border:&quot;solid 1px black&quot;,maxWidth:&quot;calc(100% - 70px)&quot;,maxHeight:&quot;calc(100% - 60px)&quot;,overflow:&quot;auto&quot;};function sb(e,t){Object.keys(t).forEach((n=>{e.style[n]=t[n]}))}const lb={background:[.32,.34,.43],containerStyle:null,controlPanelStyle:null,listenWindowResize:!0,resizeCallback:null,controllerVisibility:!0};function cb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,lb,n),Wt.obj(e,t),Wt.get(e,t,[&quot;renderWindow&quot;,&quot;renderer&quot;,&quot;apiSpecificRenderWindow&quot;,&quot;interactor&quot;,&quot;rootContainer&quot;,&quot;container&quot;,&quot;controlContainer&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkFullScreenRenderWindow&quot;);const n=document.querySelector(&quot;body&quot;);function r(t){&quot;c&quot;===String.fromCharCode(t.charCode)&&e.toggleControllerVisibility()}t.rootContainer||(t.rootContainer=n),t.container||(t.container=document.createElement(&quot;div&quot;),sb(t.container,t.containerStyle||ab),t.rootContainer.appendChild(t.container)),t.rootContainer===n&&(document.documentElement.style.height=&quot;100%&quot;,n.style.height=&quot;100%&quot;,n.style.padding=&quot;0&quot;,n.style.margin=&quot;0&quot;),t.renderWindow=hh.newInstance(),t.renderer=uh.newInstance(),t.renderWindow.addRenderer(t.renderer),t.apiSpecificRenderWindow=t.renderWindow.newAPISpecificView(ob.viewAPI??t.defaultViewAPI),t.apiSpecificRenderWindow.setContainer(t.container),t.renderWindow.addView(t.apiSpecificRenderWindow),t.interactor=Dh.newInstance(),t.interactor.setInteractorStyle(qh.newInstance()),t.interactor.setView(t.apiSpecificRenderWindow),t.interactor.initialize(),t.interactor.bindEvents(t.container),e.setBackground=t.renderer.setBackground,e.removeController=()=>{const e=t.controlContainer;e&&e.parentNode.removeChild(e)},e.setControllerVisibility=e=>{t.controllerVisibility=e,t.controlContainer&&(t.controlContainer.style.display=e?&quot;block&quot;:&quot;none&quot;)},e.toggleControllerVisibility=()=>{e.setControllerVisibility(!t.controllerVisibility)},e.addController=n=>{t.controlContainer=document.createElement(&quot;div&quot;),sb(t.controlContainer,t.controlPanelStyle||ib),t.rootContainer.appendChild(t.controlContainer),t.controlContainer.innerHTML=n,e.setControllerVisibility(t.controllerVisibility),t.rootContainer.addEventListener(&quot;keypress&quot;,r)},e.setBackground(...t.background),e.addRepresentation=e=>{e.getActors().forEach((e=>{t.renderer.addActor(e)}))},e.removeRepresentation=e=>{e.getActors().forEach((e=>t.renderer.removeActor(e)))},e.delete=Wt.chain(e.setContainer,t.apiSpecificRenderWindow.delete,(()=>{t.rootContainer?.removeEventListener(&quot;keypress&quot;,r),window.removeEventListener(&quot;resize&quot;,e.resize)}),e.delete),e.resize=()=>{const e=t.container.getBoundingClientRect(),n=window.devicePixelRatio||1;t.apiSpecificRenderWindow.setSize(Math.floor(e.width*n),Math.floor(e.height*n)),t.resizeCallback&&t.resizeCallback(e),t.renderWindow.render()},e.setResizeCallback=n=>{t.resizeCallback=n,e.resize()},t.listenWindowResize&&window.addEventListener(&quot;resize&quot;,e.resize),e.resize()}(e,t)}var ub={newInstance:Wt.newInstance(cb),extend:cb},db={ColorSpace:{RGB:0,HSV:1,LAB:2,DIVERGING:3},Scale:{LINEAR:0,LOG10:1}};const{ColorSpace:pb,Scale:fb}=db,{ScalarMappingTarget:gb}=cl,{vtkDebugMacro:mb,vtkErrorMacro:hb,vtkWarningMacro:vb}=Wt;function Tb(e,t){const n=e[0],r=e[1],o=e[2],a=Math.sqrt(n*n+r*r+o*o),i=a>.001?Math.acos(n/a):0,s=i>.001?Math.atan2(o,r):0;t[0]=a,t[1]=i,t[2]=s}function yb(e,t){if(e[0]>=t-.1)return e[2];const n=e[1]*Math.sqrt(t*t-e[0]*e[0])/(e[0]*Math.sin(e[1]));return e[2]>-.3*Math.PI?e[2]+n:e[2]-n}function bb(e,t,n,r){const o=[],a=[];ha(t,o),ha(n,a);const i=[],s=[];Tb(o,i),Tb(a,s);let l=e;if(i[1]>.05&&s[1]>.05&&function(e,t){let n=e-t;for(n<0&&(n=-n);n>=2*Math.PI;)n-=2*Math.PI;return n>Math.PI&&(n=2*Math.PI-n),n}(i[2],s[2])>.33*Math.PI){let t=Math.max(i[0],s[0]);t=Math.max(88,t),e<.5?(s[0]=t,s[1]=0,s[2]=0,l*=2):(i[0]=t,i[1]=0,i[2]=0,l=2*l-1)}i[1]<.05&&s[1]>.05?i[2]=yb(s,i[0]):s[1]<.05&&i[1]>.05&&(s[2]=yb(i,s[0]));const c=[];c[0]=(1-l)*i[0]+l*s[0],c[1]=(1-l)*i[1]+l*s[1],c[2]=(1-l)*i[2]+l*s[2];const u=[];!function(e,t){const n=e[0],r=e[1],o=e[2];t[0]=n*Math.cos(r),t[1]=n*Math.sin(r)*Math.cos(o),t[2]=n*Math.sin(r)*Math.sin(o)}(c,u),va(u,r)}const xb={clamping:!0,colorSpace:pb.RGB,hSVWrap:!0,scale:fb.LINEAR,nanColor:null,belowRangeColor:null,aboveRangeColor:null,useAboveRangeColor:!1,useBelowRangeColor:!1,allowDuplicateScalars:!1,table:null,tableSize:0,buildTime:null,nodes:null,discretize:!1,numberOfValues:256};function Cb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,xb,n),cl.extend(e,t,n),t.table=[],t.nodes=[],t.nanColor=[.5,0,0,1],t.belowRangeColor=[0,0,0,1],t.aboveRangeColor=[1,1,1,1],t.buildTime={},Wt.obj(t.buildTime),Wt.get(e,t,[&quot;buildTime&quot;,&quot;mappingRange&quot;]),Wt.setGet(e,t,[&quot;useAboveRangeColor&quot;,&quot;useBelowRangeColor&quot;,&quot;discretize&quot;,&quot;numberOfValues&quot;,{type:&quot;enum&quot;,name:&quot;colorSpace&quot;,enum:pb},{type:&quot;enum&quot;,name:&quot;scale&quot;,enum:fb}]),Wt.setArray(e,t,[&quot;nanColor&quot;,&quot;belowRangeColor&quot;,&quot;aboveRangeColor&quot;],4),Wt.getArray(e,t,[&quot;nanColor&quot;,&quot;belowRangeColor&quot;,&quot;aboveRangeColor&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkColorTransferFunction&quot;),e.getSize=()=>t.nodes.length,e.addRGBPoint=(t,n,r,o)=>e.addRGBPointLong(t,n,r,o,.5,0),e.addRGBPointLong=function(n,r,o,a){let i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:.5,s=arguments.length>5&&void 0!==arguments[5]?arguments[5]:0;if(i<0||i>1)return hb(&quot;Midpoint outside range [0.0, 1.0]&quot;),-1;if(s<0||s>1)return hb(&quot;Sharpness outside range [0.0, 1.0]&quot;),-1;t.allowDuplicateScalars||e.removePoint(n);const l={x:n,r:r,g:o,b:a,midpoint:i,sharpness:s};t.nodes.push(l),e.sortAndUpdateRange();let c=0;for(;c<t.nodes.length&&t.nodes[c].x!==n;c++);return c<t.nodes.length?c:-1},e.addHSVPoint=(t,n,r,o)=>e.addHSVPointLong(t,n,r,o,.5,0),e.addHSVPointLong=function(t,n,r,o){let a=arguments.length>4&&void 0!==arguments[4]?arguments[4]:.5,i=arguments.length>5&&void 0!==arguments[5]?arguments[5]:0;const s=[];return da([n,r,o],s),e.addRGBPoint(t,s[0],s[1],s[2],a,i)},e.setNodes=n=>{if(t.nodes!==n){const r=JSON.stringify(t.nodes);t.nodes=n;const o=JSON.stringify(t.nodes);if(e.sortAndUpdateRange()||r!==o)return e.modified(),!0}return!1},e.sortAndUpdateRange=()=>{const n=JSON.stringify(t.nodes);t.nodes.sort(((e,t)=>e.x-t.x));const r=JSON.stringify(t.nodes),o=e.updateRange();return o||n===r?o:(e.modified(),!0)},e.updateRange=()=>{const n=[2];n[0]=t.mappingRange[0],n[1]=t.mappingRange[1];const r=t.nodes.length;return r?(t.mappingRange[0]=t.nodes[0].x,t.mappingRange[1]=t.nodes[r-1].x):(t.mappingRange[0]=0,t.mappingRange[1]=0),(n[0]!==t.mappingRange[0]||n[1]!==t.mappingRange[1])&&(e.modified(),!0)},e.removePoint=n=>{let r=0;for(;r<t.nodes.length&&t.nodes[r].x!==n;r++);const o=r;if(r>=t.nodes.length)return-1;let a=!1;return t.nodes.splice(r,1),0!==r&&r!==t.nodes.length||(a=e.updateRange()),a||e.modified(),o},e.movePoint=(n,r)=>{if(n!==r){e.removePoint(r);for(let o=0;o<t.nodes.length;o++)if(t.nodes[o].x===n){t.nodes[o].x=r,e.sortAndUpdateRange();break}}},e.removeAllPoints=()=>{t.nodes=[],e.sortAndUpdateRange()},e.addRGBSegment=(n,r,o,a,i,s,l,c)=>{e.sortAndUpdateRange();for(let e=0;e<t.nodes.length;)t.nodes[e].x>=n&&t.nodes[e].x<=i?t.nodes.splice(e,1):e++;e.addRGBPointLong(n,r,o,a,.5,0),e.addRGBPointLong(i,s,l,c,.5,0),e.modified()},e.addHSVSegment=(t,n,r,o,a,i,s,l)=>{const c=[i,s,l],u=[],d=[];da([n,r,o],u),da(c,d),e.addRGBSegment(t,u[0],u[1],u[2],a,d[0],d[1],d[2])},e.mapValue=t=>{const n=[];return e.getColor(t,n),[Math.floor(255*n[0]+.5),Math.floor(255*n[1]+.5),Math.floor(255*n[2]+.5),255]},e.getColor=(n,r)=>{if(t.indexedLookup){const t=e.getSize(),o=e.getAnnotatedValueIndexInternal(n);if(o<0||0===t){const t=e.getNanColorByReference();r[0]=t[0],r[1]=t[1],r[2]=t[2]}else{const n=[];e.getNodeValue(o%t,n),r[0]=n[1],r[1]=n[2],r[2]=n[3]}}else e.getTable(n,n,1,r)},e.getRedValue=t=>{const n=[];return e.getColor(t,n),n[0]},e.getGreenValue=t=>{const n=[];return e.getColor(t,n),n[1]},e.getBlueValue=t=>{const n=[];return e.getColor(t,n),n[2]},e.logScaleEnabled=()=>t.scale===fb.LOG10,e.usingLogScale=()=>e.logScaleEnabled()&&t.mappingRange[0]>0,e.getTable=(n,r,o,a)=>{const i=e.usingLogScale(),s=i?Math.log10(Number(n)):Number(n),l=i?Math.log10(Number(r)):Number(r);if(Oa(s)||Oa(l)){for(let e=0;e<o;e++)a[3*e+0]=t.nanColor[0],a[3*e+1]=t.nanColor[1],a[3*e+2]=t.nanColor[2];return}let c=0;const u=t.nodes.length;let d=0,p=0,f=0;0!==u&&(d=t.nodes[u-1].r,p=t.nodes[u-1].g,f=t.nodes[u-1].b);let g=0,m=0,h=0;const v=[0,0,0],T=[0,0,0];let y=0,b=0;const x=[];let C=t.mappingRange;i&&(C=[Math.log10(t.mappingRange[0]),Math.log10(t.mappingRange[1])]);for(let n=0;n<o;n++){const r=3*n;if(g=o>1?s+n/(o-1)*(l-s):.5*(s+l),t.discretize){const e=C;if(g>=e[0]&&g<=e[1]){const n=t.numberOfValues,r=e[1]-e[0];if(n<=1)g=e[0]+r/2;else{const t=(g-e[0])/r,o=bo(n*t);g=e[0]+o/(n-1)*r}}}for(;c<u&&g>t.nodes[c].x;)c++,c<u&&(m=t.nodes[c-1].x,h=t.nodes[c].x,v[0]=t.nodes[c-1].r,T[0]=t.nodes[c].r,v[1]=t.nodes[c-1].g,T[1]=t.nodes[c].g,v[2]=t.nodes[c-1].b,T[2]=t.nodes[c].b,y=t.nodes[c-1].midpoint,b=t.nodes[c-1].sharpness,y<1e-5&&(y=1e-5),y>.99999&&(y=.99999));if(g>C[1])a[r]=0,a[r+1]=0,a[r+2]=0,t.clamping&&(e.getUseAboveRangeColor()?(a[r]=t.aboveRangeColor[0],a[r+1]=t.aboveRangeColor[1],a[r+2]=t.aboveRangeColor[2]):(a[r]=d,a[r+1]=p,a[r+2]=f));else if(g<C[0]||Aa(g)&&g<0)a[r]=0,a[r+1]=0,a[r+2]=0,t.clamping&&(e.getUseBelowRangeColor()?(a[r]=t.belowRangeColor[0],a[r+1]=t.belowRangeColor[1],a[r+2]=t.belowRangeColor[2]):u>0&&(a[r]=t.nodes[0].r,a[r+1]=t.nodes[0].g,a[r+2]=t.nodes[0].b));else if(0===c&&(Math.abs(g-s)<1e-6||t.discretize))u>0?(a[r]=t.nodes[0].r,a[r+1]=t.nodes[0].g,a[r+2]=t.nodes[0].b):(a[r]=0,a[r+1]=0,a[r+2]=0);else{let e=0;if(e=(g-m)/(h-m),e=e<y?.5*e/y:.5+.5*(e-y)/(1-y),b>.99){if(e<.5){a[r]=v[0],a[r+1]=v[1],a[r+2]=v[2];continue}a[r]=T[0],a[r+1]=T[1],a[r+2]=T[2];continue}if(b<.01){if(t.colorSpace===pb.RGB)a[r]=(1-e)*v[0]+e*T[0],a[r+1]=(1-e)*v[1]+e*T[1],a[r+2]=(1-e)*v[2]+e*T[2];else if(t.colorSpace===pb.HSV){const n=[],o=[];ua(v,n),ua(T,o),t.hSVWrap&&(n[0]-o[0]>.5||o[0]-n[0]>.5)&&(n[0]>o[0]?n[0]-=1:o[0]-=1);const i=[];i[0]=(1-e)*n[0]+e*o[0],i[0]<0&&(i[0]+=1),i[1]=(1-e)*n[1]+e*o[1],i[2]=(1-e)*n[2]+e*o[2],da(i,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]}else if(t.colorSpace===pb.LAB){const t=[],n=[];ha(v,t),ha(T,n);const o=[];o[0]=(1-e)*t[0]+e*n[0],o[1]=(1-e)*t[1]+e*n[1],o[2]=(1-e)*t[2]+e*n[2],va(o,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]}else t.colorSpace===pb.DIVERGING?(bb(e,v,T,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]):hb(&quot;ColorSpace set to invalid value.&quot;,t.colorSpace);continue}e<.5?e=.5*(2*e)**(1+10*b):e>.5&&(e=1-.5*(2*(1-e))**(1+10*b));const n=e*e,o=n*e,i=2*o-3*n+1,s=-2*o+3*n,l=o-2*n+e,c=o-n;let u,d;if(t.colorSpace===pb.RGB)for(let e=0;e<3;e++)u=T[e]-v[e],d=(1-b)*u,a[r+e]=i*v[e]+s*T[e]+l*d+c*d;else if(t.colorSpace===pb.HSV){const e=[],n=[];ua(v,e),ua(T,n),t.hSVWrap&&(e[0]-n[0]>.5||n[0]-e[0]>.5)&&(e[0]>n[0]?e[0]-=1:n[0]-=1);const o=[];for(let t=0;t<3;t++)u=n[t]-e[t],d=(1-b)*u,o[t]=i*e[t]+s*n[t]+l*d+c*d,0===t&&o[t]<0&&(o[t]+=1);da(o,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]}else if(t.colorSpace===pb.LAB){const e=[],t=[];ha(v,e),ha(T,t);const n=[];for(let r=0;r<3;r++)u=t[r]-e[r],d=(1-b)*u,n[r]=i*e[r]+s*t[r]+l*d+c*d;va(n,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]}else t.colorSpace===pb.DIVERGING?(bb(e,v,T,x),a[r]=x[0],a[r+1]=x[1],a[r+2]=x[2]):hb(&quot;ColorSpace set to invalid value.&quot;);for(let e=0;e<3;e++)a[r+e]=a[r+e]<0?0:a[r+e],a[r+e]=a[r+e]>1?1:a[r+e]}}},e.getUint8Table=function(n,r,o){let a=arguments.length>3&&void 0!==arguments[3]&&arguments[3];if(e.getMTime()<=t.buildTime&&t.tableSize===o&&t.tableWithAlpha!==a)return t.table;if(0===t.nodes.length)return hb(&quot;Attempting to lookup a value with no points in the function&quot;),t.table;const i=a?4:3;t.tableSize===o&&t.tableWithAlpha===a||(t.table=new Uint8Array(o*i),t.tableSize=o,t.tableWithAlpha=a);const s=[];e.getTable(n,r,o,s);for(let e=0;e<o;e++)t.table[e*i+0]=Math.floor(255*s[3*e+0]+.5),t.table[e*i+1]=Math.floor(255*s[3*e+1]+.5),t.table[e*i+2]=Math.floor(255*s[3*e+2]+.5),a&&(t.table[e*i+3]=255);return t.buildTime.modified(),t.table},e.buildFunctionFromArray=n=>{e.removeAllPoints();const r=n.getNumberOfComponents();for(let e=0;e<n.getNumberOfTuples();e++)switch(r){case 3:t.nodes.push({x:e,r:n.getComponent(e,0),g:n.getComponent(e,1),b:n.getComponent(e,2),midpoint:.5,sharpness:0});break;case 4:t.nodes.push({x:n.getComponent(e,0),r:n.getComponent(e,1),g:n.getComponent(e,2),b:n.getComponent(e,3),midpoint:.5,sharpness:0});break;case 5:t.nodes.push({x:e,r:n.getComponent(e,0),g:n.getComponent(e,1),b:n.getComponent(e,2),midpoint:n.getComponent(e,4),sharpness:n.getComponent(e,5)});break;case 6:t.nodes.push({x:n.getComponent(e,0),r:n.getComponent(e,1),g:n.getComponent(e,2),b:n.getComponent(e,3),midpoint:n.getComponent(e,4),sharpness:n.getComponent(e,5)})}e.sortAndUpdateRange()},e.buildFunctionFromTable=(n,r,o,a)=>{let i=0;e.removeAllPoints(),o>1&&(i=(r-n)/(o-1));for(let e=0;e<o;e++){const r={x:n+i*e,r:a[3*e],g:a[3*e+1],b:a[3*e+2],sharpness:0,midpoint:.5};t.nodes.push(r)}e.sortAndUpdateRange()},e.getNodeValue=(e,n)=>e<0||e>=t.nodes.length?(hb(&quot;Index out of range!&quot;),-1):(n[0]=t.nodes[e].x,n[1]=t.nodes[e].r,n[2]=t.nodes[e].g,n[3]=t.nodes[e].b,n[4]=t.nodes[e].midpoint,n[5]=t.nodes[e].sharpness,1),e.setNodeValue=(n,r)=>{if(n<0||n>=t.nodes.length)return hb(&quot;Index out of range!&quot;),-1;const o=t.nodes[n].x;return t.nodes[n].x=r[0],t.nodes[n].r=r[1],t.nodes[n].g=r[2],t.nodes[n].b=r[3],t.nodes[n].midpoint=r[4],t.nodes[n].sharpness=r[5],o!==r[0]?e.sortAndUpdateRange():e.modified(),1},e.getNumberOfAvailableColors=()=>{if(t.indexedLookup&&e.getSize())return e.getSize();if(t.tableSize)return t.tableSize;const n=t.nodes?.length??0;return Math.max(4094,n)},e.getIndexedColor=(t,n)=>{const r=e.getSize();if(r>0&&t>=0){const o=[];e.getNodeValue(t%r,o);for(let e=0;e<3;++e)n[e]=o[e+1];return void(n[3]=1)}const o=e.getNanColorByReference();n[0]=o[0],n[1]=o[1],n[2]=o[2],n[3]=1},e.fillFromDataPointer=(t,n)=>{if(!(t<=0)&&n){e.removeAllPoints();for(let r=0;r<t;r++)e.addRGBPoint(n[4*r],n[4*r+1],n[4*r+2],n[4*r+3])}},e.setMappingRange=(n,r)=>{const o=[n,r],a=[n,r],i=e.getRange(),s=e.logScaleEnabled();if(i[1]===o[1]&&i[0]===o[0])return;if(o[1]===o[0])return void hb(&quot;attempt to set zero width color range&quot;);s&&(o[0]<=0?console.warn(&quot;attempt to set log scale color range with non-positive minimum&quot;):(a[0]=Math.log10(o[0]),a[1]=Math.log10(o[1])));const l=(a[1]-a[0])/(i[1]-i[0]),c=a[0]-i[0]*l;for(let e=0;e<t.nodes.length;++e)t.nodes[e].x=t.nodes[e].x*l+c;t.mappingRange[0]=o[0],t.mappingRange[1]=o[1],e.modified()},e.adjustRange=n=>{const r=e.getRange(),o=[];r[0]<n[0]?(e.getColor(n[0],o),e.addRGBPoint(n[0],o[0],o[1],o[2])):(e.getColor(r[0],o),e.addRGBPoint(n[0],o[0],o[1],o[2])),r[1]>n[1]?(e.getColor(n[1],o),e.addRGBPoint(n[1],o[0],o[1],o[2])):(e.getColor(r[1],o),e.addRGBPoint(n[1],o[0],o[1],o[2])),e.sortAndUpdateRange();for(let e=0;e<t.nodes.length;)t.nodes[e].x>=n[0]&&t.nodes[e].x<=n[1]?t.nodes.splice(e,1):++e;return 1},e.estimateMinNumberOfSamples=(t,n)=>{const r=e.findMinimumXDistance();return Math.ceil((n-t)/r)},e.findMinimumXDistance=()=>{if(t.nodes.length<2)return-1;let e=Number.MAX_VALUE;for(let n=0;n<t.nodes.length-1;n++){const r=t.nodes[n+1].x-t.nodes[n].x;r<e&&(e=r)}return e},e.mapScalarsThroughTable=(n,r,o,a)=>{0!==e.getSize()?t.indexedLookup?e.mapDataIndexed(n,r,o,a):e.mapData(n,r,o,a):mb(&quot;Transfer Function Has No Points!&quot;)},e.mapData=(t,n,r,o)=>{if(0===e.getSize())return void vb(&quot;Transfer Function Has No Points!&quot;);const a=Math.floor(255*e.getAlpha()+.5),i=t.getNumberOfTuples(),s=t.getNumberOfComponents(),l=n.getData(),c=t.getData(),u=[];if(r===gb.RGBA)for(let t=0;t<i;t++){const n=c[t*s+o];e.getColor(n,u),l[4*t]=Math.floor(255*u[0]+.5),l[4*t+1]=Math.floor(255*u[1]+.5),l[4*t+2]=Math.floor(255*u[2]+.5),l[4*t+3]=a}if(r===gb.RGB)for(let t=0;t<i;t++){const n=c[t*s+o];e.getColor(n,u),l[3*t]=Math.floor(255*u[0]+.5),l[3*t+1]=Math.floor(255*u[1]+.5),l[3*t+2]=Math.floor(255*u[2]+.5)}if(r===gb.LUMINANCE)for(let t=0;t<i;t++){const n=c[t*s+o];e.getColor(n,u),l[t]=Math.floor(76.5*u[0]+150.45*u[1]+28.05*u[2]+.5)}if(r===gb.LUMINANCE_ALPHA)for(let t=0;t<i;t++){const n=c[t*s+o];e.getColor(n,u),l[2*t]=Math.floor(76.5*u[0]+150.45*u[1]+28.05*u[2]+.5),l[2*t+1]=a}},e.applyColorMap=n=>{const r=JSON.stringify(t.colorSpace);n.ColorSpace&&(t.colorSpace=pb[n.ColorSpace.toUpperCase()],void 0===t.colorSpace&&(hb(`ColorSpace ${n.ColorSpace} not supported, using RGB instead`),t.colorSpace=pb.RGB));let o=r!==JSON.stringify(t.colorSpace);const a=o||JSON.stringify(t.nanColor);if(n.NanColor)for(t.nanColor=[].concat(n.NanColor);t.nanColor.length<4;)t.nanColor.push(1);o=o||a!==JSON.stringify(t.nanColor);const i=o||JSON.stringify(t.nodes);if(n.RGBPoints){const e=n.RGBPoints.length;t.nodes=[];const r=.5,o=0;for(let a=0;a<e;a+=4)t.nodes.push({x:n.RGBPoints[a],r:n.RGBPoints[a+1],g:n.RGBPoints[a+2],b:n.RGBPoints[a+3],midpoint:r,sharpness:o})}const s=e.sortAndUpdateRange(),l=!s&&(o||i!==JSON.stringify(t.nodes));return l&&e.modified(),s||l}}(e,t)}var Sb={newInstance:Wt.newInstance(Cb,&quot;vtkColorTransferFunction&quot;),extend:Cb,...db},Ab={OrientationModes:{DIRECTION:0,ROTATION:1,MATRIX:2},ScaleModes:{SCALE_BY_CONSTANT:0,SCALE_BY_MAGNITUDE:1,SCALE_BY_COMPONENTS:2}};const{OrientationModes:Ib,ScaleModes:wb}=Ab,{vtkErrorMacro:Ob}=Wt,Pb={orient:!0,orientationMode:Ib.DIRECTION,orientationArray:null,scaling:!0,scaleFactor:1,scaleMode:wb.SCALE_BY_MAGNITUDE,scaleArray:null,matrixArray:null,normalArray:null,colorArray:null};function Rb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Pb,n),Gl.extend(e,t,n),Wt.algo(e,t,2,0),t.buildTime={},Wt.obj(t.buildTime,{mtime:0}),t.boundsTime={},Wt.obj(t.boundsTime,{mtime:0}),Wt.setGet(e,t,[&quot;orient&quot;,&quot;orientationMode&quot;,&quot;orientationArray&quot;,&quot;scaleArray&quot;,&quot;scaleFactor&quot;,&quot;scaleMode&quot;,&quot;scaling&quot;]),Wt.get(e,t,[&quot;colorArray&quot;,&quot;matrixArray&quot;,&quot;normalArray&quot;,&quot;buildTime&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkGlyph3DMapper&quot;),e.getOrientationModeAsString=()=>Wt.enumToString(Ib,t.orientationMode),e.setOrientationModeToDirection=()=>e.setOrientationMode(Ib.DIRECTION),e.setOrientationModeToRotation=()=>e.setOrientationMode(Ib.ROTATION),e.setOrientationModeToMatrix=()=>e.setOrientationMode(Ib.MATRIX),e.getOrientationArrayData=()=>{const n=e.getInputData(0);return n&&n.getPointData()?t.orientationArray?n.getPointData().getArray(t.orientationArray):n.getPointData().getVectors():null},e.getScaleModeAsString=()=>Wt.enumToString(wb,t.scaleMode),e.setScaleModeToScaleByMagnitude=()=>e.setScaleMode(wb.SCALE_BY_MAGNITUDE),e.setScaleModeToScaleByComponents=()=>e.setScaleMode(wb.SCALE_BY_COMPONENTS),e.setScaleModeToScaleByConstant=()=>e.setScaleMode(wb.SCALE_BY_CONSTANT),e.getScaleArrayData=()=>{const n=e.getInputData(0);return n&&n.getPointData()?t.scaleArray?n.getPointData().getArray(t.scaleArray):n.getPointData().getScalars():null},e.getBounds=()=>{const n=e.getInputData(0),r=e.getInputData(1);return n&&r?(e.buildArrays(),t.bounds):Pa()},e.buildArrays=()=>{const n=e.getInputData(0),r=e.getInputData(1);if(t.buildTime.getMTime()<r.getMTime()||t.buildTime.getMTime()<n.getMTime()||t.buildTime.getMTime()<e.getMTime()){const o=n.getPoints().getData();let a=e.getScaleArrayData(),i=null,s=0;a&&(i=a.getData(),s=a.getNumberOfComponents()),t.scaling&&a&&t.scaleMode===wb.SCALE_BY_COMPONENTS&&3!==a.getNumberOfComponents()&&(Ob(&quot;Cannot scale by components since scale array does not have 3 components.&quot;),a=null);const l=r.getBounds(),c=[];Gi.getCorners(l,c),t.bounds[0]=Gi.INIT_BOUNDS[0],t.bounds[1]=Gi.INIT_BOUNDS[1],t.bounds[2]=Gi.INIT_BOUNDS[2],t.bounds[3]=Gi.INIT_BOUNDS[3],t.bounds[4]=Gi.INIT_BOUNDS[4],t.bounds[5]=Gi.INIT_BOUNDS[5];const u=new Float64Array(3),d=e.getOrientationArrayData(),p=m(new Float64Array(16)),f=[],g=[],h=o.length/3;t.matrixArray=new Float32Array(16*h);const v=t.matrixArray.buffer;t.normalArray=new Float32Array(9*h);const T=t.normalArray.buffer,y=[],O=[];for(let e=0;e<h;++e){const n=new Float32Array(v,64*e,16);if(f[0]=o[3*e],f[1]=o[3*e+1],f[2]=o[3*e+2],x(n,p,f),d)switch(d.getTuple(e,O),t.orientationMode){case Ib.MATRIX:b(n,n,[...O.slice(0,3),0,...O.slice(3,6),0,...O.slice(6,9),0,0,0,0,1]);break;case Ib.ROTATION:w(n,n,O[2]),A(n,n,O[0]),I(n,n,O[1]);break;case Ib.DIRECTION:if(0===O[1]&&0===O[2])O[0]<0&&I(n,n,3.1415926);else{const e=No(O),t=[];t[0]=(O[0]+e)/2,t[1]=O[1]/2,t[2]=O[2]/2,S(n,n,3.1415926,t)}}if(t.scaling){if(g[0]=t.scaleFactor,g[1]=t.scaleFactor,g[2]=t.scaleFactor,a)switch(t.scaleMode){case wb.SCALE_BY_MAGNITUDE:for(let t=0;t<s;++t)y[t]=i[e*s+t];g[0]*=No(y,s),g[1]=g[0],g[2]=g[0];break;case wb.SCALE_BY_COMPONENTS:for(let t=0;t<s;++t)y[t]=i[e*s+t];g[0]*=y[0],g[1]*=y[1],g[2]*=y[2];case wb.SCALE_BY_CONSTANT:}0===g[0]&&(g[0]=1e-10),0===g[1]&&(g[1]=1e-10),0===g[2]&&(g[2]=1e-10),C(n,n,g)}for(let e=0;e<8;++e)In(u,c[e],n),u[0]<t.bounds[0]&&(t.bounds[0]=u[0]),u[1]<t.bounds[2]&&(t.bounds[2]=u[1]),u[2]<t.bounds[4]&&(t.bounds[4]=u[2]),u[0]>t.bounds[1]&&(t.bounds[1]=u[0]),u[1]>t.bounds[3]&&(t.bounds[3]=u[1]),u[2]>t.bounds[5]&&(t.bounds[5]=u[2]);const r=new Float32Array(T,36*e,9);le(r,n),me(r,r),ge(r,r)}const P=e.getAbstractScalars(n,t.scalarMode,t.arrayAccessMode,t.arrayId,t.colorByArrayName).scalars;t.useLookupTableScalarRange||e.getLookupTable().setRange(t.scalarRange[0],t.scalarRange[1]),t.colorArray=null;const R=e.getLookupTable();R&&P&&(R.build(),t.colorArray=R.mapScalars(P,t.colorMode,0)),t.buildTime.modified()}},e.getPrimitiveCount=()=>{const t=e.getInputData(1),n=e.getInputData().getPoints().getNumberOfValues()/3;return{points:n*t.getPoints().getNumberOfValues()/3,verts:n*(t.getVerts().getNumberOfValues()-t.getVerts().getNumberOfCells()),lines:n*(t.getLines().getNumberOfValues()-2*t.getLines().getNumberOfCells()),triangles:n*(t.getPolys().getNumberOfValues()-3*t.getLines().getNumberOfCells())}},e.setSourceConnection=t=>e.setInputConnection(t,1)}(e,t)}var Mb={newInstance:Wt.newInstance(Rb,&quot;vtkGlyph3DMapper&quot;),extend:Rb,...Ab};const{vtkErrorMacro:Eb}=Wt,Vb={range:[0,0],clamping:!0,allowDuplicateScalars:!1};function Db(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Vb,n),Wt.obj(e,t),t.nodes=[],Wt.setGet(e,t,[&quot;allowDuplicateScalars&quot;,&quot;clamping&quot;]),Wt.setArray(e,t,[&quot;range&quot;],2),Wt.getArray(e,t,[&quot;range&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkPiecewiseFunction&quot;),e.getSize=()=>t.nodes.length,e.getType=()=>{let e,n=0,r=0;t.nodes.length>0&&(n=t.nodes[0].y);for(let o=1;o<t.nodes.length;o++){if(e=t.nodes[o].y,e!==n)if(e>n)switch(r){case 0:case 1:r=1;break;default:r=3}else switch(r){case 0:case 2:r=2;break;default:r=3}if(n=e,3===r)break}switch(r){case 0:return&quot;Constant&quot;;case 1:return&quot;NonDecreasing&quot;;case 2:return&quot;NonIncreasing&quot;;default:return&quot;Varied&quot;}},e.getDataPointer=()=>{const e=t.nodes.length;if(t.function=null,e>0){t.function=[];for(let n=0;n<e;n++)t.function[2*n]=t.nodes[n].x,t.function[2*n+1]=t.nodes[n].y}return t.function},e.getFirstNonZeroValue=()=>{if(0===t.nodes.length)return 0;let e=1,n=0,r=0;for(;r<t.nodes.length;r++)if(0!==t.nodes[r].y){e=0;break}return n=e?Number.MAX_VALUE:r>0?t.nodes[r-1].x:t.clamping?-Number.MAX_VALUE:t.nodes[0].x,n},e.getNodeValue=(e,n)=>{const r=t.nodes.length;return e<0||e>=r?(Eb(&quot;Index out of range!&quot;),-1):(n[0]=t.nodes[e].x,n[1]=t.nodes[e].y,n[2]=t.nodes[e].midpoint,n[3]=t.nodes[e].sharpness,1)},e.setNodeValue=(n,r)=>{const o=t.nodes.length;if(n<0||n>=o)return Eb(&quot;Index out of range!&quot;),-1;const a=t.nodes[n].x;return t.nodes[n].x=r[0],t.nodes[n].y=r[1],t.nodes[n].midpoint=r[2],t.nodes[n].sharpness=r[3],a!==r[0]?e.sortAndUpdateRange():e.modified(),1},e.addPoint=(t,n)=>e.addPointLong(t,n,.5,0),e.addPointLong=(n,r,o,a)=>{if(o<0||o>1)return Eb(&quot;Midpoint outside range [0.0, 1.0]&quot;),-1;if(a<0||a>1)return Eb(&quot;Sharpness outside range [0.0, 1.0]&quot;),-1;t.allowDuplicateScalars||e.removePoint(n);const i={x:n,y:r,midpoint:o,sharpness:a};let s;for(t.nodes.push(i),e.sortAndUpdateRange(),s=0;s<t.nodes.length&&t.nodes[s].x!==n;s++);return s<t.nodes.length?s:-1},e.setNodes=n=>{t.nodes!==n&&(t.nodes=n,e.sortAndUpdateRange())},e.sortAndUpdateRange=()=>{t.nodes.sort(((e,t)=>e.x-t.x)),e.updateRange()||e.modified()},e.updateRange=()=>{const n=t.range.slice(),r=t.nodes.length;return r?(t.range[0]=t.nodes[0].x,t.range[1]=t.nodes[r-1].x):(t.range[0]=0,t.range[1]=0),(n[0]!==t.range[0]||n[1]!==t.range[1])&&(e.modified(),!0)},e.removePoint=n=>{let r;for(r=0;r<t.nodes.length&&t.nodes[r].x!==n;r++);if(r>=t.nodes.length)return-1;const o=r;let a=!1;return t.nodes.splice(r,1),0!==r&&r!==t.nodes.length||(a=e.updateRange()),a||e.modified(),o},e.removeAllPoints=()=>{t.nodes=[],e.sortAndUpdateRange()},e.addSegment=(n,r,o,a)=>{e.sortAndUpdateRange();for(let e=0;e<t.nodes.length;)t.nodes[e].x>=n&&t.nodes[e].x<=o?t.nodes.splice(e,1):e++;e.addPoint(n,r,.5,0),e.addPoint(o,a,.5,0)},e.getValue=t=>{const n=[];return e.getTable(t,t,1,n),n[0]},e.adjustRange=n=>{if(n.length<2)return 0;const r=e.getRange();r[0]<n[0]?e.addPoint(n[0],e.getValue(n[0])):e.addPoint(n[0],e.getValue(r[0])),r[1]>n[1]?e.addPoint(n[1],e.getValue(n[1])):e.addPoint(n[1],e.getValue(r[1])),e.sortAndUpdateRange();for(let e=0;e<t.nodes.length;)t.nodes[e].x>=n[0]&&t.nodes[e].x<=n[1]?t.nodes.splice(e,1):++e;return e.sortAndUpdateRange(),1},e.estimateMinNumberOfSamples=(t,n)=>{const r=e.findMinimumXDistance();return Math.ceil((n-t)/r)},e.findMinimumXDistance=()=>{const e=t.nodes.length;if(e<2)return-1;let n=t.nodes[1].x-t.nodes[0].x;for(let r=0;r<e-1;r++){const e=t.nodes[r+1].x-t.nodes[r].x;e<n&&(n=e)}return n},e.getTable=function(e,n,r,o){let a,i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:1,s=0;const l=t.nodes.length;let c=0;0!==l&&(c=t.nodes[l-1].y);let u=0,d=0,p=0,f=0,g=0,m=0,h=0;for(a=0;a<r;a++){const v=i*a;for(u=r>1?e+a/(r-1)*(n-e):.5*(e+n);s<l&&u>t.nodes[s].x;)s++,s<l&&(d=t.nodes[s-1].x,p=t.nodes[s].x,f=t.nodes[s-1].y,g=t.nodes[s].y,m=t.nodes[s-1].midpoint,h=t.nodes[s-1].sharpness,m<1e-5&&(m=1e-5),m>.99999&&(m=.99999));if(s>=l)o[v]=t.clamping?c:0;else if(0===s)o[v]=t.clamping?t.nodes[0].y:0;else{let e=(u-d)/(p-d);if(e=e<m?.5*e/m:.5+.5*(e-m)/(1-m),h>.99){if(e<.5){o[v]=f;continue}o[v]=g;continue}if(h<.01){o[v]=(1-e)*f+e*g;continue}e<.5?e=.5*(2*e)**(1+10*h):e>.5&&(e=1-.5*(2*(1-e))**(1+10*h));const t=e*e,n=t*e,r=2*n-3*t+1,a=-2*n+3*t,i=n-2*t+e,s=n-t,l=(1-h)*(g-f);o[v]=r*f+a*g+i*l+s*l;const c=f<g?f:g,T=f>g?f:g;o[v]=o[v]<c?c:o[v],o[v]=o[v]>T?T:o[v]}}}}(e,t)}var Lb={newInstance:Wt.newInstance(Db,&quot;vtkPiecewiseFunction&quot;),extend:Db};const{InterpolationType:Bb,OpacityMode:Nb,FilterMode:Fb,ColorMixPreset:_b}=Jf,{vtkErrorMacro:kb}=Wt;function Gb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};if(Object.assign(t,(e=>({colorMixPreset:_b.DEFAULT,independentComponents:!0,interpolationType:Bb.FAST_LINEAR,shade:!1,ambient:.1,diffuse:.7,specular:.2,specularPower:10,useLabelOutline:!1,labelOutlineThickness:[1],labelOutlineOpacity:1,ipScalarRange:[-1e6,1e6],filterMode:Fb.OFF,preferSizeOverAccuracy:!1,computeNormalFromOpacity:!1,volumetricScatteringBlending:0,globalIlluminationReach:0,anisotropy:0,localAmbientOcclusion:!1,LAOKernelSize:15,LAOKernelRadius:7,updatedExtents:[],...e}))(n)),Wt.obj(e,t),!t.componentData){t.componentData=[];for(let e=0;e<4;++e)t.componentData.push({colorChannels:1,grayTransferFunction:null,rGBTransferFunction:null,scalarOpacity:null,scalarOpacityUnitDistance:1,opacityMode:Nb.FRACTIONAL,gradientOpacityMinimumValue:0,gradientOpacityMinimumOpacity:0,gradientOpacityMaximumValue:1,gradientOpacityMaximumOpacity:1,useGradientOpacity:!1,componentWeight:1,forceNearestInterpolation:!1})}Wt.setGet(e,t,[&quot;colorMixPreset&quot;,&quot;independentComponents&quot;,&quot;interpolationType&quot;,&quot;shade&quot;,&quot;ambient&quot;,&quot;diffuse&quot;,&quot;specular&quot;,&quot;specularPower&quot;,&quot;useLabelOutline&quot;,&quot;labelOutlineOpacity&quot;,&quot;filterMode&quot;,&quot;preferSizeOverAccuracy&quot;,&quot;computeNormalFromOpacity&quot;,&quot;volumetricScatteringBlending&quot;,&quot;globalIlluminationReach&quot;,&quot;anisotropy&quot;,&quot;localAmbientOcclusion&quot;,&quot;LAOKernelSize&quot;,&quot;LAOKernelRadius&quot;,&quot;updatedExtents&quot;]),Wt.setGetArray(e,t,[&quot;ipScalarRange&quot;],2),Wt.setGetArray(e,t,[&quot;labelOutlineThickness&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkVolumeProperty&quot;);const n={...e};e.getMTime=()=>{let e,n=t.mtime;for(let r=0;r<4;r++)1===t.componentData[r].colorChannels?t.componentData[r].grayTransferFunction&&(e=t.componentData[r].grayTransferFunction.getMTime(),n=n>e?n:e):3===t.componentData[r].colorChannels&&t.componentData[r].rGBTransferFunction&&(e=t.componentData[r].rGBTransferFunction.getMTime(),n=n>e?n:e),t.componentData[r].scalarOpacity&&(e=t.componentData[r].scalarOpacity.getMTime(),n=n>e?n:e),t.componentData[r].gradientOpacity&&(t.componentData[r].disableGradientOpacity||(e=t.componentData[r].gradientOpacity.getMTime(),n=n>e?n:e));return n},e.getColorChannels=e=>e<0||e>3?(kb(&quot;Bad index - must be between 0 and 3&quot;),0):t.componentData[e].colorChannels,e.setGrayTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,o=!1;return t.componentData[n].grayTransferFunction!==r&&(t.componentData[n].grayTransferFunction=r,o=!0),1!==t.componentData[n].colorChannels&&(t.componentData[n].colorChannels=1,o=!0),o&&e.modified(),o},e.getGrayTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return null===t.componentData[n].grayTransferFunction&&(t.componentData[n].grayTransferFunction=Lb.newInstance(),t.componentData[n].grayTransferFunction.addPoint(0,0),t.componentData[n].grayTransferFunction.addPoint(1024,1),1!==t.componentData[n].colorChannels&&(t.componentData[n].colorChannels=1),e.modified()),t.componentData[n].grayTransferFunction},e.setRGBTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,o=!1;return t.componentData[n].rGBTransferFunction!==r&&(t.componentData[n].rGBTransferFunction=r,o=!0),3!==t.componentData[n].colorChannels&&(t.componentData[n].colorChannels=3,o=!0),o&&e.modified(),o},e.getRGBTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return null===t.componentData[n].rGBTransferFunction&&(t.componentData[n].rGBTransferFunction=Sb.newInstance(),t.componentData[n].rGBTransferFunction.addRGBPoint(0,0,0,0),t.componentData[n].rGBTransferFunction.addRGBPoint(1024,1,1,1),3!==t.componentData[n].colorChannels&&(t.componentData[n].colorChannels=3),e.modified()),t.componentData[n].rGBTransferFunction},e.setScalarOpacity=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;return t.componentData[n].scalarOpacity!==r&&(t.componentData[n].scalarOpacity=r,e.modified(),!0)},e.getScalarOpacity=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return null===t.componentData[n].scalarOpacity&&(t.componentData[n].scalarOpacity=Lb.newInstance(),t.componentData[n].scalarOpacity.addPoint(0,1),t.componentData[n].scalarOpacity.addPoint(1024,1),e.modified()),t.componentData[n].scalarOpacity},e.setComponentWeight=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;if(n<0||n>=4)return kb(&quot;Invalid index&quot;),!1;const o=Math.min(1,Math.max(0,r));return t.componentData[n].componentWeight!==o&&(t.componentData[n].componentWeight=o,e.modified(),!0)},e.getComponentWeight=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return e<0||e>=4?(kb(&quot;Invalid index&quot;),0):t.componentData[e].componentWeight},e.setInterpolationTypeToNearest=()=>e.setInterpolationType(Bb.NEAREST),e.setInterpolationTypeToLinear=()=>e.setInterpolationType(Bb.LINEAR),e.setInterpolationTypeToFastLinear=()=>e.setInterpolationType(Bb.FAST_LINEAR),e.getInterpolationTypeAsString=()=>Wt.enumToString(Bb,t.interpolationType),[&quot;useGradientOpacity&quot;,&quot;scalarOpacityUnitDistance&quot;,&quot;gradientOpacityMinimumValue&quot;,&quot;gradientOpacityMinimumOpacity&quot;,&quot;gradientOpacityMaximumValue&quot;,&quot;gradientOpacityMaximumOpacity&quot;,&quot;opacityMode&quot;,&quot;forceNearestInterpolation&quot;].forEach((n=>{const r=Wt.capitalize(n);e[`set${r}`]=(r,o)=>t.componentData[r][`${n}`]!==o&&(t.componentData[r][`${n}`]=o,e.modified(),!0)})),[&quot;useGradientOpacity&quot;,&quot;scalarOpacityUnitDistance&quot;,&quot;gradientOpacityMinimumValue&quot;,&quot;gradientOpacityMinimumOpacity&quot;,&quot;gradientOpacityMaximumValue&quot;,&quot;gradientOpacityMaximumOpacity&quot;,&quot;opacityMode&quot;,&quot;forceNearestInterpolation&quot;].forEach((n=>{const r=Wt.capitalize(n);e[`get${r}`]=e=>t.componentData[e][`${n}`]})),e.setAverageIPScalarRange=(t,n)=>{console.warn(&quot;setAverageIPScalarRange is deprecated use setIpScalarRange&quot;),e.setIpScalarRange(t,n)},e.getFilterModeAsString=()=>Wt.enumToString(Fb,t.filterMode),e.setFilterModeToOff=()=>{e.setFilterMode(Fb.OFF)},e.setFilterModeToNormalized=()=>{e.setFilterMode(Fb.NORMALIZED)},e.setFilterModeToRaw=()=>{e.setFilterMode(Fb.RAW)},e.setGlobalIlluminationReach=e=>n.setGlobalIlluminationReach(ba(e,0,1)),e.setVolumetricScatteringBlending=e=>n.setVolumetricScatteringBlending(ba(e,0,1)),e.setAnisotropy=e=>n.setAnisotropy(ba(e,-.99,.99)),e.setLAOKernelSize=e=>n.setLAOKernelSize(bo(ba(e,1,32))),e.setLAOKernelRadius=e=>n.setLAOKernelRadius(e>=1?e:1)}(e,t)}var Ub={newInstance:Wt.newInstance(Gb,&quot;vtkVolumeProperty&quot;),extend:Gb,...Jf};const zb={mapper:null};function Wb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,zb,n),Xi.extend(e,t,n),t.boundsMTime={},Wt.obj(t.boundsMTime),Wt.setGet(e,t,[&quot;mapper&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkVolume&quot;),e.getVolumes=()=>[e],e.makeProperty=Ub.newInstance,e.getRedrawMTime=()=>{let e=t.mtime;if(null!==t.mapper){let n=t.mapper.getMTime();e=n>e?n:e,null!==t.mapper.getInput()&&(t.mapper.getInputAlgorithm().update(),n=t.mapper.getInput().getMTime(),e=n>e?n:e)}return e}}(e,t)}var Hb={newInstance:Wt.newInstance(Wb,&quot;vtkVolume&quot;),extend:Wb};const{BlendMode:jb}=tg,Kb=[&quot;getAnisotropy&quot;,&quot;getComputeNormalFromOpacity&quot;,&quot;getFilterMode&quot;,&quot;getFilterModeAsString&quot;,&quot;getGlobalIlluminationReach&quot;,&quot;getIpScalarRange&quot;,&quot;getIpScalarRangeByReference&quot;,&quot;getLAOKernelRadius&quot;,&quot;getLAOKernelSize&quot;,&quot;getLocalAmbientOcclusion&quot;,&quot;getPreferSizeOverAccuracy&quot;,&quot;getVolumetricScatteringBlending&quot;,&quot;setAnisotropy&quot;,&quot;setAverageIPScalarRange&quot;,&quot;setComputeNormalFromOpacity&quot;,&quot;setFilterMode&quot;,&quot;setFilterModeToNormalized&quot;,&quot;setFilterModeToOff&quot;,&quot;setFilterModeToRaw&quot;,&quot;setGlobalIlluminationReach&quot;,&quot;setIpScalarRange&quot;,&quot;setIpScalarRangeFrom&quot;,&quot;setLAOKernelRadius&quot;,&quot;setLAOKernelSize&quot;,&quot;setLocalAmbientOcclusion&quot;,&quot;setPreferSizeOverAccuracy&quot;,&quot;setVolumetricScatteringBlending&quot;],$b={createRadonTransferFunction:function(e,t,n,r,o){let a=null;return o?(a=o,a.removeAllPoints()):a=Lb.newInstance(),a.addPointLong(-1024,0,1,1),a.addPoint(e,t),a.addPoint(n,r),a}};function qb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,(e=>({bounds:[...Gi.INIT_BOUNDS],sampleDistance:1,imageSampleDistance:1,maximumSamplesPerRay:1e3,autoAdjustSampleDistances:!0,initialInteractionScale:1,interactionSampleDistanceFactor:1,blendMode:jb.COMPOSITE_BLEND,volumeShadowSamplingDistFactor:5,colorTextureWidth:1024,opacityTextureWidth:1024,labelOutlineTextureWidth:1024,...e}))(n)),As(e,t,n),Wt.setGet(e,t,[&quot;sampleDistance&quot;,&quot;imageSampleDistance&quot;,&quot;maximumSamplesPerRay&quot;,&quot;autoAdjustSampleDistances&quot;,&quot;initialInteractionScale&quot;,&quot;interactionSampleDistanceFactor&quot;,&quot;blendMode&quot;,&quot;volumeShadowSamplingDistFactor&quot;,&quot;colorTextureWidth&quot;,&quot;opacityTextureWidth&quot;,&quot;labelOutlineTextureWidth&quot;]),Wt.event(e,t,&quot;lightingActivated&quot;),function(e,t){t.classHierarchy.push(&quot;vtkVolumeMapper&quot;);const n={...e};e.getBounds=()=>(t.static||e.update(),t.bounds=[...e.getInputData().getBounds()],t.bounds),e.setBlendModeToComposite=()=>{e.setBlendMode(jb.COMPOSITE_BLEND)},e.setBlendModeToMaximumIntensity=()=>{e.setBlendMode(jb.MAXIMUM_INTENSITY_BLEND)},e.setBlendModeToMinimumIntensity=()=>{e.setBlendMode(jb.MINIMUM_INTENSITY_BLEND)},e.setBlendModeToAverageIntensity=()=>{e.setBlendMode(jb.AVERAGE_INTENSITY_BLEND)},e.setBlendModeToAdditiveIntensity=()=>{e.setBlendMode(jb.ADDITIVE_INTENSITY_BLEND)},e.setBlendModeToRadonTransform=()=>{e.setBlendMode(jb.RADON_TRANSFORM_BLEND)},e.getBlendModeAsString=()=>Wt.enumToString(jb,t.blendMode),e.setVolumeShadowSamplingDistFactor=e=>n.setVolumeShadowSamplingDistFactor(e>=1?e:1),Kb.forEach((t=>{e[t]=()=>{throw new Error(`The method &quot;volumeMapper.${t}()&quot; doesn't exist anymore. It is a rendering property that has been moved to the volume property. Replace your code with:\\nvolumeActor.getProperty().${t}()\\n`)}}))}(e,t)}var Xb={newInstance:Wt.newInstance(qb,&quot;vtkVolumeMapper&quot;),extend:qb,...$b};const{InterpolationType:Yb}=Rf,{vtkErrorMacro:Zb}=Wt;function Qb(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};if(Object.assign(t,(e=>({independentComponents:!1,interpolationType:Yb.LINEAR,colorWindow:255,colorLevel:127.5,ambient:1,diffuse:0,opacity:1,useLookupTableScalarRange:!1,useLabelOutline:!1,labelOutlineThickness:[1],labelOutlineOpacity:1,updatedExtents:[],...e}))(n)),Wt.obj(e,t),!t.componentData){t.componentData=[];for(let e=0;e<4;e++)t.componentData.push({rGBTransferFunction:null,piecewiseFunction:null,componentWeight:1})}Wt.setGet(e,t,[&quot;independentComponents&quot;,&quot;interpolationType&quot;,&quot;colorWindow&quot;,&quot;colorLevel&quot;,&quot;ambient&quot;,&quot;diffuse&quot;,&quot;opacity&quot;,&quot;useLookupTableScalarRange&quot;,&quot;useLabelOutline&quot;,&quot;labelOutlineOpacity&quot;,&quot;updatedExtents&quot;]),Wt.setGetArray(e,t,[&quot;labelOutlineThickness&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkImageProperty&quot;),e.getMTime=()=>{let e,n=t.mtime;for(let r=0;r<4;r++)t.componentData[r].rGBTransferFunction&&(e=t.componentData[r].rGBTransferFunction.getMTime(),n=n>e?n:e),t.componentData[r].piecewiseFunction&&(e=t.componentData[r].piecewiseFunction.getMTime(),n=n>e?n:e);return n},e.setRGBTransferFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=n,o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;return Number.isInteger(n)||(o=n,r=0),t.componentData[r].rGBTransferFunction!==o&&(t.componentData[r].rGBTransferFunction=o,e.modified(),!0)},e.getRGBTransferFunction=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.componentData[e].rGBTransferFunction},e.setPiecewiseFunction=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=n,o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;return Number.isInteger(n)||(o=n,r=0),t.componentData[r].piecewiseFunction!==o&&(t.componentData[r].piecewiseFunction=o,e.modified(),!0)},e.getPiecewiseFunction=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return t.componentData[e].piecewiseFunction},e.setScalarOpacity=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,n=t,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;return Number.isInteger(t)||(r=t,n=0),e.setPiecewiseFunction(n,r)},e.getScalarOpacity=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return e.getPiecewiseFunction(t)},e.setComponentWeight=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;if(n<0||n>=4)return Zb(&quot;Invalid index&quot;),!1;const o=Math.min(1,Math.max(0,r));return t.componentData[n].componentWeight!==o&&(t.componentData[n].componentWeight=o,e.modified(),!0)},e.getComponentWeight=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;return e<0||e>=4?(Zb(&quot;Invalid index&quot;),0):t.componentData[e].componentWeight},e.setInterpolationTypeToNearest=()=>e.setInterpolationType(Yb.NEAREST),e.setInterpolationTypeToLinear=()=>e.setInterpolationType(Yb.LINEAR),e.getInterpolationTypeAsString=()=>Wt.enumToString(Yb,t.interpolationType)}(e,t)}var Jb={newInstance:Wt.newInstance(Qb,&quot;vtkImageProperty&quot;),extend:Qb};const ex={mapper:null,forceOpaque:!1,forceTranslucent:!1};function tx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ex,n),Xi.extend(e,t,n),t.boundsMTime={},Wt.obj(t.boundsMTime),Wt.setGet(e,t,[&quot;mapper&quot;,&quot;forceOpaque&quot;,&quot;forceTranslucent&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkImageSlice&quot;),e.getActors=()=>e,e.getImages=()=>e,e.getIsOpaque=()=>{if(t.forceOpaque)return!0;if(t.forceTranslucent)return!1;t.properties[0]||e.getProperty();let n=t.properties[0].getOpacity()>=1;return n=n&&(!t.mapper||t.mapper.getIsOpaque()),n},e.hasTranslucentPolygonalGeometry=()=>!1,e.makeProperty=Jb.newInstance,e.getBoundsForSlice=(n,r)=>{const o=t.mapper.getBoundsForSlice(n,r);if(!Gi.isValid(o))return o;e.computeMatrix();const a=new Float64Array(16);return h(a,t.matrix),Gi.transformBounds(o,a)},e.getMinXBound=()=>e.getBounds()[0],e.getMaxXBound=()=>e.getBounds()[1],e.getMinYBound=()=>e.getBounds()[2],e.getMaxYBound=()=>e.getBounds()[3],e.getMinZBound=()=>e.getBounds()[4],e.getMaxZBound=()=>e.getBounds()[5],e.getRedrawMTime=()=>{let e=t.mtime;if(null!==t.mapper){let n=t.mapper.getMTime();e=n>e?n:e,null!==t.mapper.getInput()&&(t.mapper.getInputAlgorithm().update(),n=t.mapper.getInput().getMTime(),e=n>e?n:e)}return t.properties.forEach((t=>{e=Math.max(e,t.getMTime());const n=t.getRGBTransferFunction();null!==n&&(e=Math.max(e,n.getMTime()))})),e},e.getSupportsSelection=()=>!!t.mapper&&t.mapper.getSupportsSelection()}(e,t)}var nx={newInstance:Wt.newInstance(tx,&quot;vtkImageSlice&quot;),extend:tx};const rx={slice:0,customDisplayExtent:[0,0,0,0,0,0],useCustomExtents:!1,backgroundColor:[0,0,0,1],colorTextureWidth:1024,opacityTextureWidth:1024,labelOutlineTextureWidth:1024};var ox=function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,rx,n),As(e,t,n),Wt.setGet(e,t,[&quot;slice&quot;,&quot;useCustomExtents&quot;,&quot;colorTextureWidth&quot;,&quot;opacityTextureWidth&quot;,&quot;labelOutlineTextureWidth&quot;]),Wt.setGetArray(e,t,[&quot;customDisplayExtent&quot;],6),Wt.setGetArray(e,t,[&quot;backgroundColor&quot;],4),function(e,t){t.classHierarchy.push(&quot;vtkAbstractImageMapper&quot;),e.getIsOpaque=()=>!0,e.getCurrentImage=()=>null,e.getBoundsForSlice=()=>(Wt.vtkErrorMacro(&quot;vtkAbstractImageMapper.getBoundsForSlice - NOT IMPLEMENTED&quot;),Pa())}(e,t)};function ax(e,t,n){const r=n.getCurrentImage(),o=r.getExtent(),a=[o[0],o[2],o[4]],{ijkMode:i}=n.getClosestIJKAxis();let s=n.isA(&quot;vtkImageArrayMapper&quot;)?n.getSubSlice():n.getSlice();i!==n.getSlicingMode()&&(s=n.getSliceAtPosition(s)),a[i]+=s;const l=[0,0,0];r.indexToWorld(a,l),a[i]+=1;const c=[0,0,0];r.indexToWorld(a,c),c[0]-=l[0],c[1]-=l[1],c[2]-=l[2],Cn(c,c);const u=ei.intersectWithLine(e,t,l,c);if(u.intersection){const e=u.x,t=[0,0,0];return r.worldToIndex(e,t),{t:u.t,absoluteIJK:t}}return null}const{staticOffsetAPI:ix,otherStaticMethods:sx}=Sl,{SlicingMode:lx}=Lf;const cx={slicingMode:lx.NONE,closestIJKAxis:{ijkMode:lx.NONE,flip:!1},renderToRectangle:!1,sliceAtFocalPoint:!1,preferSizeOverAccuracy:!1};function ux(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,cx,n),ox(e,t,n),Wt.get(e,t,[&quot;slicingMode&quot;]),Wt.setGet(e,t,[&quot;closestIJKAxis&quot;,&quot;renderToRectangle&quot;,&quot;sliceAtFocalPoint&quot;,&quot;preferSizeOverAccuracy&quot;]),Sl.implementCoincidentTopologyMethods(e,t),function(e,t){function n(){let n;switch(t.slicingMode){case lx.X:n=0;break;case lx.Y:n=1;break;case lx.Z:n=2;break;default:return void(t.closestIJKAxis={ijkMode:t.slicingMode,flip:!1})}const r=Ra(e.getCurrentImage().getDirection());let o=0;for(;o<3&&0===r[n+3*o];++o);const a=r[n+3*o]<0;t.closestIJKAxis={ijkMode:o,flip:a}}t.classHierarchy.push(&quot;vtkImageMapper&quot;),e.getSliceAtPosition=n=>{const r=e.getCurrentImage();let o;if(3===n.length)o=n;else if(Number.isFinite(n)){const e=r.getBounds();switch(t.slicingMode){case lx.X:o=[n,(e[3]+e[2])/2,(e[5]+e[4])/2];break;case lx.Y:o=[(e[1]+e[0])/2,n,(e[5]+e[4])/2];break;case lx.Z:o=[(e[1]+e[0])/2,(e[3]+e[2])/2,n]}}const a=[0,0,0];r.worldToIndex(o,a);const i=r.getExtent(),{ijkMode:s}=e.getClosestIJKAxis();let l=0;switch(s){case lx.I:l=ba(a[0],i[0],i[1]);break;case lx.J:l=ba(a[1],i[2],i[3]);break;case lx.K:l=ba(a[2],i[4],i[5]);break;default:return 0}return l},e.setSliceFromCamera=n=>{const r=n.getFocalPoint();switch(t.slicingMode){case lx.I:case lx.J:case lx.K:{const t=e.getSliceAtPosition(r);e.setSlice(t)}break;case lx.X:e.setSlice(r[0]);break;case lx.Y:e.setSlice(r[1]);break;case lx.Z:e.setSlice(r[2])}},e.setXSlice=t=>{e.setSlicingMode(lx.X),e.setSlice(t)},e.setYSlice=t=>{e.setSlicingMode(lx.Y),e.setSlice(t)},e.setZSlice=t=>{e.setSlicingMode(lx.Z),e.setSlice(t)},e.setISlice=t=>{e.setSlicingMode(lx.I),e.setSlice(t)},e.setJSlice=t=>{e.setSlicingMode(lx.J),e.setSlice(t)},e.setKSlice=t=>{e.setSlicingMode(lx.K),e.setSlice(t)},e.getSlicingModeNormal=()=>{const n=[0,0,0],r=e.getCurrentImage().getDirection();switch(t.slicingMode){case lx.X:n[0]=1;break;case lx.Y:n[1]=1;break;case lx.Z:n[2]=1;break;case lx.I:Ho(r,[1,0,0],n);break;case lx.J:Ho(r,[0,1,0],n);break;case lx.K:Ho(r,[0,0,1],n)}return n},e.setSlicingMode=r=>{t.slicingMode!==r&&(t.slicingMode=r,e.getCurrentImage()&&n(),e.modified())},e.getClosestIJKAxis=()=>(void 0!==t.closestIJKAxis&&t.closestIJKAxis.ijkMode!==lx.NONE||!e.getCurrentImage()||n(),t.closestIJKAxis),e.getBounds=()=>{const n=e.getCurrentImage();if(!n)return Pa();if(!t.useCustomExtents)return n.getBounds();const r=t.customDisplayExtent.slice(),{ijkMode:o}=e.getClosestIJKAxis();let a=t.slice;switch(o!==t.slicingMode&&(a=e.getSliceAtPosition(t.slice)),o){case lx.I:r[0]=a,r[1]=a;break;case lx.J:r[2]=a,r[3]=a;break;case lx.K:r[4]=a,r[5]=a}return n.extentToBounds(r)},e.getBoundsForSlice=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:t.slice,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;const o=e.getCurrentImage();if(!o)return Pa();const a=o.getSpatialExtent(),{ijkMode:i}=e.getClosestIJKAxis();let s=n;switch(i!==t.slicingMode&&(s=e.getSliceAtPosition(n)),i){case lx.I:a[0]=s-r,a[1]=s+r;break;case lx.J:a[2]=s-r,a[3]=s+r;break;case lx.K:a[4]=s-r,a[5]=s+r}return o.extentToBounds(a)},e.intersectWithLineForPointPicking=(t,n)=>function(e,t,n){const r=ax(e,t,n);if(r){const e=n.getCurrentImage().getExtent(),t=[Math.round(r.absoluteIJK[0]),Math.round(r.absoluteIJK[1]),Math.round(r.absoluteIJK[2])];return t[0]<e[0]||t[0]>e[1]||t[1]<e[2]||t[1]>e[3]||t[2]<e[4]||t[2]>e[5]?null:{t:r.t,ijk:t}}return null}(t,n,e),e.intersectWithLineForCellPicking=(t,n)=>function(e,t,n){const r=ax(e,t,n);if(r){const e=n.getCurrentImage().getExtent(),t=r.absoluteIJK,o=[Math.floor(t[0]),Math.floor(t[1]),Math.floor(t[2])];if(o[0]<e[0]||o[0]>e[1]-1||o[1]<e[2]||o[1]>e[3]-1||o[2]<e[4]||o[2]>(e[5]?e[5]-1:e[5]))return null;const a=[t[0]-o[0],t[1]-o[1],t[2]-o[2]];return{t:r.t,ijk:o,pCoords:a}}return null}(t,n,e),e.getCurrentImage=()=>e.getInputData()}(e,t)}var dx={newInstance:Wt.newInstance(ux,&quot;vtkImageMapper&quot;),extend:ux,...ix,...sx,...Lf};const{vtkErrorMacro:px}=Wt;function fx(e,t,n,r){e.set(function(e,t){let n=0;return e.map(((e,r)=>r===n?(n+=e+1,e):e+t))}(t,n),r)}const gx={outputPointsPrecision:Ms.DEFAULT};function mx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,gx,n),Wt.setGet(e,t,[&quot;outputPointsPrecision&quot;]),Wt.obj(e,t),Wt.algo(e,t,1,1),function(e,t){t.classHierarchy.push(&quot;vtkAppendPolyData&quot;),e.requestData=(n,r)=>{const o=e.getNumberOfInputPorts();if(!o)return void px(&quot;No input specified.&quot;);if(1===o)return void(r[0]=n[0]);const a=r[0]&&n[0]!==r[0]?r[0].initialize():gu.newInstance();let i=0,s=0,l=1,c=1,u=0,d=0,p=0,f=0,g=!0,m=!0,h=!0;for(let e=0;e<o;e++){const t=n[e];if(!t)continue;const r=t.getPoints().getNumberOfPoints();i+=r,u+=t.getVerts().getNumberOfValues(),d+=t.getLines().getNumberOfValues(),p+=t.getStrips().getNumberOfValues(),f+=t.getPolys().getNumberOfValues(),r&&(c&&(c=0,s=t.getPoints().getDataType()),l=t.getPoints().getDataType(),s=s>l?s:l);const o=t.getPointData();o?(g=g&&null!==o.getNormals(),m=m&&null!==o.getTCoords(),h=h&&null!==o.getScalars()):(g=!1,m=!1,h=!1)}t.outputPointsPrecision===Ms.SINGLE?s=cs.FLOAT:t.outputPointsPrecision===Ms.DOUBLE&&(s=cs.DOUBLE);const v=Yl.newInstance({dataType:s});v.setNumberOfPoints(i);const T=v.getData(),y=new Uint32Array(u),b=new Uint32Array(d),x=new Uint32Array(p),C=new Uint32Array(f);let S=null,A=null,I=null;const w=n[o-1];if(g){const e=w.getPointData().getNormals();S=xs.newInstance({numberOfComponents:3,numberOfTuples:i,size:3*i,dataType:e.getDataType(),name:e.getName()})}if(m){const e=w.getPointData().getTCoords();A=xs.newInstance({numberOfComponents:2,numberOfTuples:i,size:2*i,dataType:e.getDataType(),name:e.getName()})}if(h){const e=w.getPointData().getScalars();I=xs.newInstance({numberOfComponents:e.getNumberOfComponents(),numberOfTuples:i,size:i*e.getNumberOfComponents(),dataType:e.getDataType(),name:e.getName()})}i=0,u=0,d=0,p=0,f=0;for(let e=0;e<o;e++){const t=n[e];T.set(t.getPoints().getData(),3*i),fx(y,t.getVerts().getData(),i,u),u+=t.getVerts().getNumberOfValues(),fx(b,t.getLines().getData(),i,d),d+=t.getLines().getNumberOfValues(),fx(x,t.getStrips().getData(),i,p),p+=t.getStrips().getNumberOfValues(),fx(C,t.getPolys().getData(),i,f),f+=t.getPolys().getNumberOfValues();const r=t.getPointData();if(g){const e=r.getNormals();S.getData().set(e.getData(),3*i)}if(m){const e=r.getTCoords();A.getData().set(e.getData(),2*i)}if(h){const e=r.getScalars();I.getData().set(e.getData(),i*I.getNumberOfComponents())}i+=t.getPoints().getNumberOfPoints()}a.setPoints(v),a.getVerts().setData(y),a.getLines().setData(b),a.getStrips().setData(x),a.getPolys().setData(C),S&&a.getPointData().setNormals(S),A&&a.getPointData().setTCoords(A),I&&a.getPointData().setScalars(I),r[0]=a}}(e,t)}var hx={newInstance:Wt.newInstance(mx,&quot;vtkAppendPolyData&quot;),extend:mx};const vx={height:1,radius:.5,resolution:6,center:[0,0,0],direction:[1,0,0],capping:!0,pointType:&quot;Float64Array&quot;};function Tx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,vx,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;height&quot;,&quot;radius&quot;,&quot;resolution&quot;,&quot;capping&quot;]),Wt.setGetArray(e,t,[&quot;center&quot;,&quot;direction&quot;],3),Wt.algo(e,t,0,1),function(e,t){t.classHierarchy.push(&quot;vtkConeSource&quot;),e.requestData=(e,n)=>{const r=2*Math.PI/t.resolution,o=-t.height/2,a=t.resolution+1,i=4*t.resolution+1+t.resolution;let s=0;const l=Wt.newTypedArray(t.pointType,3*a);let c=0;const u=new Uint32Array(i);l[0]=t.height/2,l[1]=0,l[2]=0,t.capping&&(u[c++]=t.resolution);for(let e=0;e<t.resolution;e++)s++,l[3*s+0]=o,l[3*s+1]=t.radius*Math.cos(e*r),l[3*s+2]=t.radius*Math.sin(e*r),t.capping&&(u[t.resolution-c+++1]=s);for(let e=0;e<t.resolution;e++)u[c++]=3,u[c++]=0,u[c++]=e+1,u[c++]=e+2>t.resolution?1:e+2;df().translate(...t.center).rotateFromDirections([1,0,0],t.direction).apply(l);const d=n[0]?.initialize()||gu.newInstance();d.getPoints().setData(l,3),d.getPolys().setData(u,1),n[0]=d}}(e,t)}var yx={newInstance:Wt.newInstance(Tx,&quot;vtkConeSource&quot;),extend:Tx};const bx={height:1,initAngle:0,radius:1,resolution:6,center:[0,0,0],direction:[0,1,0],capping:!0,pointType:&quot;Float64Array&quot;};function xx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,bx,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;height&quot;,&quot;initAngle&quot;,&quot;otherRadius&quot;,&quot;radius&quot;,&quot;resolution&quot;,&quot;capping&quot;]),Wt.setGetArray(e,t,[&quot;center&quot;,&quot;direction&quot;],3),Wt.algo(e,t,0,1),function(e,t){t.classHierarchy.push(&quot;vtkCylinderSource&quot;),e.requestData=(e,n)=>{const r=2*Math.PI/t.resolution;let o=2*t.resolution,a=5*t.resolution;t.capping&&(o=4*t.resolution,a=7*t.resolution+2);const i=Wt.newTypedArray(t.pointType,3*o);let s=0;const l=new Uint32Array(a),c=new Float32Array(3*o),u=xs.newInstance({numberOfComponents:3,values:c,name:&quot;Normals&quot;}),d=new Float32Array(2*o),p=xs.newInstance({numberOfComponents:2,values:d,name:&quot;TCoords&quot;}),f=[0,0,0],g=[0,0,0],m=[0,0,0],h=[0,0,0],v=[0,0],T=[0,0],y=null==t.otherRadius?t.radius:t.otherRadius;for(let e=0;e<t.resolution;e++){f[0]=Math.cos(e*r+t.initAngle),g[0]=f[0],m[0]=t.radius*f[0]+t.center[0],h[0]=m[0],v[0]=Math.abs(2*e/t.resolution-1),T[0]=v[0],m[1]=.5*t.height+t.center[1],h[1]=-.5*t.height+t.center[1],v[1]=0,T[1]=1,f[2]=-Math.sin(e*r+t.initAngle),g[2]=f[2],m[2]=y*f[2]+t.center[2],h[2]=m[2];const n=2*e;for(let e=0;e<3;e++)c[3*n+e]=f[e],c[3*(n+1)+e]=g[e],i[3*n+e]=m[e],i[3*(n+1)+e]=h[e],e<2&&(d[2*n+e]=v[e],d[2*(n+1)+e]=T[e])}for(let e=0;e<t.resolution;e++){l[s++]=4,l[s++]=2*e,l[s++]=2*e+1;const n=(2*e+3)%(2*t.resolution);l[s++]=n,l[s++]=n-1}if(t.capping){for(let e=0;e<t.resolution;e++){m[0]=t.radius*Math.cos(e*r+t.initAngle),h[0]=m[0],v[0]=m[0],T[0]=m[0],m[0]+=t.center[0],h[0]+=t.center[0],f[1]=1,g[1]=-1,m[1]=.5*t.height+t.center[1],h[1]=-.5*t.height+t.center[1],m[2]=-y*Math.sin(e*r+t.initAngle),h[2]=m[2],v[1]=m[2],T[1]=m[2],m[2]+=t.center[2],h[2]+=t.center[2];const n=2*t.resolution+e,o=3*t.resolution+t.resolution-e-1;for(let e=0;e<3;e++)c[3*n+e]=f[e],c[3*o+e]=g[e],i[3*n+e]=m[e],i[3*o+e]=h[e],e<2&&(d[2*n+e]=v[e],d[2*o+e]=T[e])}l[s++]=t.resolution;for(let e=0;e<t.resolution;e++)l[s++]=2*t.resolution+e;l[s++]=t.resolution;for(let e=0;e<t.resolution;e++)l[s++]=3*t.resolution+e}df().translate(...t.center).rotateFromDirections([0,1,0],t.direction).translate(...t.center.map((e=>-1*e))).apply(i);const b=n[0]?.initialize()||gu.newInstance();b.getPoints().setData(i,3),b.getPolys().setData(l,1),b.getPointData().setNormals(u),b.getPointData().setTCoords(p),n[0]=b}}(e,t)}var Cx={newInstance:Wt.newInstance(xx,&quot;vtkCylinderSource&quot;),extend:xx};const Sx={tipResolution:6,tipRadius:.1,tipLength:.35,shaftResolution:6,shaftRadius:.03,invert:!1,direction:[1,0,0],pointType:&quot;Float64Array&quot;};function Ax(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Sx,n),Wt.obj(e,t),Wt.setGet(e,t,[&quot;tipResolution&quot;,&quot;tipRadius&quot;,&quot;tipLength&quot;,&quot;shaftResolution&quot;,&quot;shaftRadius&quot;,&quot;invert&quot;]),Wt.setGetArray(e,t,[&quot;direction&quot;],3),Wt.algo(e,t,0,1),function(e,t){t.classHierarchy.push(&quot;vtkArrowSource&quot;),e.requestData=(e,n)=>{const r=Cx.newInstance({capping:!0});r.setResolution(t.shaftResolution),r.setRadius(t.shaftRadius),r.setHeight(1-t.tipLength),r.setCenter(0,.5*(1-t.tipLength),0);const o=r.getOutputData(),a=o.getPoints().getData(),i=o.getPointData().getNormals().getData();uf().rotateZ(-90).apply(a).apply(i);const s=yx.newInstance();s.setResolution(t.tipResolution),s.setHeight(t.tipLength),s.setRadius(t.tipRadius);const l=s.getOutputData(),c=l.getPoints().getData();df().translate(1-.5*t.tipLength,0,0).apply(c);const u=hx.newInstance();u.setInputData(o),u.addInputData(l);const d=u.getOutputData(),p=d.getPoints().getData();df().translate(.5*t.tipLength-.5,0,0).apply(p),t.invert?(df().rotateFromDirections([1,0,0],t.direction).scale(-1,-1,-1).apply(p),n[0]=d):(df().rotateFromDirections([1,0,0],t.direction).scale(1,1,1).apply(p),n[0]=u.getOutputData())}}(e,t)}var Ix={newInstance:Wt.newInstance(Ax,&quot;vtkArrowSource&quot;),extend:Ax};function wx(e){const t=e.getPoints().getBounds(),n=[.5*-(t[0]+t[1]),.5*-(t[2]+t[3]),.5*-(t[4]+t[5])];uf().translate(...n).apply(e.getPoints().getData())}function Ox(e,t){let n=arguments.length>2&&void 0!==arguments[2]&&arguments[2];const r=e.getPoints().getBounds(),o=[0,0,0];o[t]=n?-r[2*t+1]:-r[2*t],uf().translate(...o).apply(e.getPoints().getData())}function Px(e,t,n,r){const o=e.getPoints().getData().length,a=new Uint8ClampedArray(o);let i=0;for(;i<o;)a[i++]=t,a[i++]=n,a[i++]=r;e.getPointData().setScalars(xs.newInstance({name:&quot;color&quot;,numberOfComponents:3,values:a}))}function Rx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};ss.extend(e,t,function(e){return{config:{recenter:!0,tipResolution:60,tipRadius:.1,tipLength:.2,shaftResolution:60,shaftRadius:.03,invert:!1,...e?.config},xConfig:{color:[255,0,0],invert:!1,...e?.xConfig},yConfig:{color:[255,255,0],invert:!1,...e?.yConfig},zConfig:{color:[0,128,0],invert:!1,...e?.zConfig}}}(n)),Wt.setGet(e,t,[&quot;config&quot;,&quot;xConfig&quot;,&quot;yConfig&quot;,&quot;zConfig&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkAxesActor&quot;);const n=Gl.newInstance();e.setMapper(n),e.update=()=>{let e={...t.config,...t.xConfig};const r=Ix.newInstance({direction:[1,0,0],...e}).getOutputData();t.config.recenter?wx(r):Ox(r,0,e.invert),Px(r,...e.color),e={...t.config,...t.yConfig};const o=Ix.newInstance({direction:[0,1,0],...e}).getOutputData();t.config.recenter?wx(o):Ox(o,1,e.invert),Px(o,...e.color),e={...t.config,...t.zConfig};const a=Ix.newInstance({direction:[0,0,1],...e}).getOutputData();t.config.recenter?wx(a):Ox(a,2,e.invert),Px(a,...e.color);const i=hx.newInstance();i.setInputData(r),i.addInputData(o),i.addInputData(a),n.setInputConnection(i.getOutputPort())},e.update();const r=Wt.debounce(e.update,0);e.setXAxisColor=t=>e.setXConfig({...e.getXConfig(),color:t}),e.setYAxisColor=t=>e.setYConfig({...e.getYConfig(),color:t}),e.setZAxisColor=t=>e.setZConfig({...e.getZConfig(),color:t}),e.getXAxisColor=()=>t.getXConfig().color,e.getYAxisColor=()=>t.getYConfig().color,e.getZAxisColor=()=>t.getZConfig().color,t._onConfigChanged=r,t._onXConfigChanged=r,t._onYConfigChanged=r,t._onZConfigChanged=r}(e,t)}var Mx={newInstance:Wt.newInstance(Rx,&quot;vtkAxesActor&quot;),extend:Rx};const Ex=&quot;resetcamera&quot;,Vx=&quot;orientation&quot;,Dx={MODE_RESET_CAMERA:Ex,MODE_ORIENTATION:Vx,MODE_SAME:&quot;same&quot;};const Lx={mode:Vx,focalPoint:[0,0,0],distance:6.8,active:!0};function Bx(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Lx,n),ht(e,t),Ct(e,t,[&quot;mode&quot;,&quot;active&quot;,&quot;srcRenderer&quot;,&quot;dstRenderer&quot;,&quot;distance&quot;]),It(e,t,[&quot;focalPoint&quot;],3,0),function(e,t){t.classHierarchy.push(&quot;vtkCameraSynchronizer&quot;);const n=new Float64Array(9),r=new Float64Array(3),o=[];function a(){for(;o.length;)o.pop().unsubscribe();if(!t.srcRenderer||!t.dstRenderer)return;const n=t.srcRenderer.getActiveCamera(),r=t.srcRenderer.getRenderWindow().getInteractor();o.push(n.onModified((()=>{r.isAnimating()||e.update()}))),o.push(r.onAnimation(e.update)),o.push(r.onEndAnimation(e.update))}t._onSrcRendererChanged=a,t._onDstRendererChanged=a,e.update=()=>{if(!t.active||!t.srcRenderer||!t.dstRenderer)return;const e=t.srcRenderer.getActiveCamera(),o=t.dstRenderer.getActiveCamera(),a=(i=e.getReferenceByName(&quot;position&quot;),s=e.getReferenceByName(&quot;focalPoint&quot;),l=e.getReferenceByName(&quot;viewUp&quot;),(n[0]!==i[0]||n[1]!==i[1]||n[2]!==i[2]||n[3]!==s[0]||n[4]!==s[1]||n[5]!==s[2]||n[6]!==l[0]||n[7]!==l[1]||n[8]!==l[2])&&(n[0]=i[0],n[1]=i[1],n[2]=i[2],n[3]=s[0],n[4]=s[1],n[5]=s[2],n[6]=l[0],n[7]=l[1],n[8]=l[2],n));var i,s,l;a&&(t.mode===Vx?(r[0]=a[0]-a[3],r[1]=a[1]-a[4],r[2]=a[2]-a[5],Fo(r),o.setPosition(t.focalPoint[0]+t.distance*r[0],t.focalPoint[1]+t.distance*r[1],t.focalPoint[2]+t.distance*r[2]),o.setFocalPoint(t.focalPoint[0],t.focalPoint[1],t.focalPoint[2]),o.setViewUp(a[6],a[7],a[8])):(o.setPosition(a[0],a[1],a[2]),o.setFocalPoint(a[3],a[4],a[5]),o.setViewUp(a[6],a[7],a[8])),t.mode===Ex&&t.dstRenderer.resetCamera())},e.delete=Et((()=>e.setSrcRenderer(null)),e.delete),a()}(e,t)}var Nx={newInstance:Mt(Bx,&quot;vtkCameraSynchronizer&quot;),extend:Bx,SynchronizationMode:Dx};const Fx={},_x={CameraSync:class{constructor(e,t){this.ctx=e,this.behavior=Nx.newInstance(this.getProperties(t)),this.behavior.update()}getProperties(e){let{actorBounds:t,srcRenderer:n,dstRenderer:r}=e;return{distance:3.4*Math.max(t[1]-t[0],t[3]-t[2],t[5]-t[4]),focalPoint:[.5*(t[0]+t[1]),.5*(t[2]+t[3]),.5*(t[4]+t[5])],mode:Nx.SynchronizationMode.MODE_ORIENTATION,srcRenderer:this.ctx.getInstance(n),dstRenderer:this.ctx.getInstance(r)}}update(e){this.behavior.set(this.getProperties(e)),this.behavior.update()}delete(){this.behavior.delete()}}};var kx=function(e,t,n){const r=e.get(&quot;synchronizedViewId&quot;).synchronizedViewId;if(!t.behaviors||!r)return;Fx[r]||(Fx[r]={});const o=Fx[r];if(t.behaviors.autoOrientation){const t=e.getRenderers();if(!o.autoOrientationAxes&&2===t.length){let e=null,n=null;for(let r=0;r<t.length;r++){const o=t[r];o.getInteractive()?e=o:n=o}e&&n&&(o.autoOrientationAxes=Nx.newInstance({srcRenderer:e,dstRenderer:n}))}o.autoOrientationAxes&&2!==t.length&&(o.autoOrientationAxes.delete(),delete o.autoOrientationAxes)}const a=Object.keys(t.behaviors),i=Object.keys(o);for(let e=0;e<a.length;e++){const r=a[e];if(o[r])o[r].update(t.behaviors[r]);else{const e=t.behaviors[r];_x[e.type]?o[r]=new _x[e.type](n,e):console.log(&quot;No mapping for&quot;,e)}}for(let e=0;e<i.length;e++){const n=a[e];t.behaviors[n]||(o[n].delete(),delete o[n])}};const Gx={},Ux=/instance:\\${([^}]+)}/,zx={},Wx=[],Hx={},jx={vtkPoints:Yl,vtkCellArray:Kl,vtkDataArray:xs};function Kx(e){return e.map((e=>Ux.exec(e))).filter((e=>e)).map((e=>e[1]))}function $x(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return e.dependencies&&e.dependencies.forEach((e=>{t.push(e.id),$x(e,t)})),t}function qx(e,t,n,r){if(!t)return Promise.reject(new Error(&quot;No instance provided.&quot;));const o=Gx[e];return o&&o.update?o.update(t,n,r):Promise.reject(new Error(`No updater for ${e}`))}function Xx(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};const n=Gx[e];return n&&n.build?n.build(t):(console.log(&quot;No builder for&quot;,e),null)}function Yx(){Object.keys(Gx).forEach((e=>{delete Gx[e]}))}function Zx(e){if(1===e[1].length)return-1===Wx.indexOf(e[1][0]);let t=!1;for(let n=0;n<e[1].length;n++)t=t||-1===Wx.indexOf(e[1][n]);return t}function Qx(e,t,n){n.start(),e.set(t.properties),t.dependencies&&t.dependencies.forEach((e=>{const{id:t,type:r}=e;if(Hx[r]){const{key:n,value:o}=Hx[r];if(!n||e.properties[n]===o)return void Wx.push((e=>`instance:\\${${e}}`)(t))}let o=n.getInstance(t);o||(o=Xx(r,{managedInstanceId:t}),n.registerInstance(t,o)),qx(r,o,e,n)})),t.calls&&t.calls.filter(Zx).forEach((t=>{var r;e[t[0]].apply(null,(r=n,t[1].map((e=>{const t=Ux.exec(e);return t?r.getInstance(t[1]):e}))))}));const r=[];if(t.arrays){const o=[],a=Object.values(t.arrays).map((t=>(n.start(),n.getArray(t.hash,t.dataType,n).then(function(e,t,n){return r=>{const o=t.registration?t.registration:&quot;addArray&quot;,a=t.location?e.getReferenceByName(t.location):e;let i=null;if(i=t.location?e.getReferenceByName(t.location).getArray(t.name):e[`get${o.substring(3)}`](),i)return i.getData()!==r&&n.push([i.setData,[r,t.numberOfComponents]]),i;const s=t.vtkClass?t.vtkClass:&quot;vtkDataArray&quot;,l=jx[s].newInstance({...t,values:r});return n.push([a[o],[l]]),l}}(e,t,o)).catch((e=>{console.log(&quot;Error fetching array&quot;,JSON.stringify(t),e)})).finally(n.end))));n.start(),r.push(Promise.all(a).then((()=>(o.length&&e.modified(),function(e){for(;e.length;){const[t,n]=e.shift();t(...n)}}(o),!0))).catch((e=>{console.error(&quot;Error in array handling for state&quot;,JSON.stringify(t),e)})).finally(n.end))}return n.end(),Promise.all(r)}function Jx(e,t,n){zx[t.id]||Qx(e,t,n),zx[t.id]=!0}function eC(e,t){const n=[],r=e.getNumberOfArrays();for(let o=0;o<r;o++){const r=e.getArray(o).getName();t.has(r)||n.push(r)}for(let t=0;t<n.length;t++)e.removeArray(n[t])}function tC(e){const t=e.name?`_${e.name}`:&quot;&quot;;return`${e.hash}_${e.dataType}${t}`}function nC(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[];return(t,n,r)=>{r.start();const o={...n.properties};n.arrays||(n.arrays={});for(let t=0;t<e.length;t++){const r=e[t];if(n.properties[r]){const e=n.properties[r];e.registration=`set${st(r)}`;const t=tC(e);n.arrays[t]=e,delete o[r]}}const a=n.properties.fields||[];for(let e=0;e<a.length;e++){const t=a[e],r=tC(t);n.arrays[r]=t}delete o.fields;const i={pointData:new Set,cellData:new Set,fieldData:new Set};a.forEach((e=>{let{location:t,name:n}=e;i[t].add(n)})),eC(t.getPointData(),i.pointData),eC(t.getCellData(),i.cellData);const s={...n};s.properties=o;const l=Qx(t,s,r);return r.end(),l}}const rC=nC([&quot;points&quot;,&quot;polys&quot;,&quot;verts&quot;,&quot;lines&quot;,&quot;strips&quot;]),oC=nC([]);function aC(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:Qx;Xx||qx?Gx[e]={build:t,update:n}:delete Gx[e]}const iC={vtkMapper:[&quot;vtkOpenGLPolyDataMapper&quot;,&quot;vtkCompositePolyDataMapper2&quot;,&quot;vtkDataSetMapper&quot;],vtkProperty:[&quot;vtkOpenGLProperty&quot;],vtkRenderer:[&quot;vtkOpenGLRenderer&quot;],vtkCamera:[&quot;vtkOpenGLCamera&quot;],vtkColorTransferFunction:[&quot;vtkPVDiscretizableColorTransferFunction&quot;],vtkActor:[&quot;vtkOpenGLActor&quot;,&quot;vtkPVLODActor&quot;],vtkLight:[&quot;vtkOpenGLLight&quot;,&quot;vtkPVLight&quot;],vtkTexture:[&quot;vtkOpenGLTexture&quot;],vtkImageMapper:[&quot;vtkOpenGLImageSliceMapper&quot;],vtkVolumeMapper:[&quot;vtkFixedPointVolumeRayCastMapper&quot;]},sC={vtkAxesActor:{build:Mx.newInstance,update:Qx},vtkRenderWindow:{build:hh.newInstance,update:function(e,t,n){t.calls&&t.calls.filter(Zx).filter((e=>&quot;removeRenderer&quot;===e[0])).forEach((e=>{Kx(e[1]).forEach((e=>{n.getInstance(e).getViewProps().forEach((e=>{const t=e.get(&quot;flattenedDepIds&quot;).flattenedDepIds;t&&t.forEach((e=>n.unregisterInstance(e))),n.unregisterInstance(n.getInstanceId(e))}))}))})),e.render(),Qx(e,t,n),kx(e,t,n)}},vtkRenderer:{build:uh.newInstance,update:function(e,t,n){Qx(e,t,n);const r=new Set;t.dependencies&&t.dependencies.forEach((e=>{const t=n.getInstance(e.id);if(t){const n=$x(e);t.set({flattenedDepIds:n},!0),n.forEach((e=>r.add(e)))}}));const o=new Set;t.calls&&t.calls.filter(Zx).filter((e=>&quot;removeViewProp&quot;===e[0])).forEach((e=>{Kx(e[1]).forEach((e=>{const t=n.getInstance(e).get(&quot;flattenedDepIds&quot;).flattenedDepIds;t&&t.forEach((e=>o.add(e))),o.add(e)}))})),[...o].filter((e=>!r.has(e))).forEach((e=>n.unregisterInstance(e)))}},vtkLookupTable:{build:fl.newInstance,update:Qx},vtkCamera:{build:Ym.newInstance,update:Jx},vtkPolyData:{build:gu.newInstance,update:rC},vtkImageData:{build:Xs.newInstance,update:oC},vtkMapper:{build:Gl.newInstance,update:Qx},vtkGlyph3DMapper:{build:Mb.newInstance,update:Qx},vtkProperty:{build:os.newInstance,update:Qx},vtkActor:{build:ss.newInstance,update:Qx},vtkLight:{build:Jm.newInstance,update:Qx},vtkColorTransferFunction:{build:Sb.newInstance,update:function(e,t,n){if(n.start(),t.properties.nodes){const n=t.properties.nodes.map((e=>{let[t,n,r,o,a,i]=e;return{x:t,r:n,g:r,b:o,midpoint:a,sharpness:i}}));e.set({...t.properties,nodes:n},!0)}else e.set(t.properties);n.end()}},vtkTexture:{build:vu.newInstance,update:Qx},vtkVolume:{build:Hb.newInstance,update:Qx},vtkVolumeMapper:{build:Xb.newInstance,update:Qx},vtkVolumeProperty:{build:Ub.newInstance,update:Qx},vtkImageSlice:{build:nx.newInstance,update:Qx},vtkImageMapper:{build:dx.newInstance,update:Qx},vtkImageProperty:{build:Jb.newInstance,update:Qx},vtkPiecewiseFunction:{build:Lb.newInstance,update:function(e,t,n){if(n.start(),t.properties.nodes){const n=t.properties.nodes.map((e=>{let[t,n,r,o]=e;return{x:t,y:n,midpoint:r,sharpness:o}}));e.set({...t.properties,nodes:n},!0),e.sortAndUpdateRange()}else e.set(t.properties);n.end()}},vtkCubeAxesActor:{build:Lu.newInstance,update:Qx},vtkScalarBarActor:{build:dp.newInstance,update:Qx}};function lC(){(!(arguments.length>0&&void 0!==arguments[0])||arguments[0])&&Yx(),Object.keys(sC).forEach((e=>{const t=sC[e];aC(e,t.build,t.update)}))}function cC(){Object.keys(iC).forEach((e=>{iC[e].forEach((t=>{Gx[t]=Gx[e]}))}))}lC(),cC(),Hx.vtkPVLight={};var uC={build:Xx,update:qx,genericUpdater:Qx,oneTimeGenericUpdater:Jx,setTypeMapping:aC,clearTypeMapping:Yx,getSupportedTypes:function(){return Object.keys(Gx)},clearOneTimeUpdaters:function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];if(0===t.length)return void Object.keys(zx).forEach((e=>{delete zx[e]}));let r=t;return 1===r.length&&Array.isArray(r[0])&&(r=r[0]),r.forEach((e=>{delete zx[e]})),r},updateRenderWindow:function(e,t,n){return qx(&quot;vtkRenderWindow&quot;,e,t,n)},excludeInstance:function(e,t,n){Hx[e]={key:t,value:n}},setDefaultMapping:lC,applyDefaultAliases:cC,alwaysUpdateCamera:function(){aC(&quot;vtkCamera&quot;,Ym.newInstance),cC()}};const dC={};function pC(){const e={};let t=null;return{setFetchArrayFunction:function(e){t=e},getArray:function(n,r,o){const a=e[n];return a?(a.mtimes[o.getActiveViewId()]=o.getMTime(),new Promise(((e,t)=>{e(a.array)}))):t?new Promise(((a,i)=>{t(n).then((t=>{let i=t;if(&quot;string&quot;==typeof t&&(i=$g.toArrayBuffer(t)),i instanceof Blob){const t=new FileReader;t.onload=()=>{const i=at(r,t.result),s={[o.getActiveViewId()]:o.getMTime()};e[n]={mtimes:s,array:i},a(i)},t.readAsArrayBuffer(i)}else{const t=at(r,i),s={[o.getActiveViewId()]:o.getMTime()};e[n]={mtimes:s,array:t},a(t)}}),(e=>{console.log(&quot;Error getting data array:&quot;),console.log(e),i(e)}))})):Promise.reject(new Error('No array fetcher found, please use &quot;setArrayFetcher&quot; to provide one'))},emptyCachedArrays:function(){Object.keys(e).forEach((t=>{delete e[t]}))},freeOldArrays:function(t,n){const r=n.getMTime()-t;Object.keys(e).filter((t=>e[t].mtimes[n.getActiveViewId()])).filter((t=>e[t].mtimes[n.getActiveViewId()]<r)).forEach((t=>{delete e[t]}))}}}function fC(){const e={};return{getInstance:function(t){return e[t]},getInstanceId:function(t){let n=null;return Object.keys(e).forEach((r=>{t===e[r]&&(n=r)})),n},registerInstance:function(t,n){e[t]=n,n.set({remoteId:t},!0,!0)},unregisterInstance:function(t){delete e[t]},emptyCachedInstances:function(){Object.keys(e).forEach((t=>{delete e[t]}))}}}function gC(){let e=0;const t={start(){e+=1,t.invokeProgressEvent(e)},end(){e-=1,t.invokeProgressEvent(e),0===e&&t.invokeProgressDone()},resetProgress(){e=0}},n={};return Rt(t,n,&quot;progressEvent&quot;),Rt(t,n,&quot;progressDone&quot;),t}function mC(){const e={};let t=&quot;default&quot;;return{getMTime:function(n){return e[n||t]||1},incrementMTime:function(n){const r=n||t;e[r]||(e[r]=1),e[r]+=1},setActiveViewId:function(e){t=e},getActiveViewId:function(){return t}}}function hC(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:&quot;default&quot;,t=dC[e];return t||(t={...pC(),...fC(),...gC(),...mC()},dC[e]=t),t}function vC(e,t){let n=-1,r=100;const o=e=>e.get(&quot;managedInstanceId&quot;).managedInstanceId,a=()=>Dt(e,o);function i(t){e.set({synchronizedViewId:t},!0,!0)}function s(){return e.get(&quot;synchronizedViewId&quot;).synchronizedViewId}return{synchronize:function(o){s()||i(o.id);const a=o.mtime||0;return s()===o.id&&n<a?new Promise(((i,s)=>{const l=t.onProgressDone((()=>{l.unsubscribe(),e.render(),i(!0)}));n=a,t.setActiveViewId(o.id),t.incrementMTime(),uC.updateRenderWindow(e,o,t),t.freeOldArrays(r,t)})):Promise.resolve(!1)},setSynchronizedViewId:i,getSynchronizedViewId:s,updateGarbageCollectorThreshold:function(e){r=e},getManagedInstanceIds:a,clearOneTimeUpdaters:function(){uC.clearOneTimeUpdaters(a())}}}const TC={synchronizerContextName:&quot;default&quot;,synchronizerContext:null,synchronizedViewId:null};function yC(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,TC,n),hh.extend(e,t),Tt(e,t,[&quot;synchronizerContext&quot;]),function(e,t){t.classHierarchy.push(&quot;vtkSynchronizableRenderWindow&quot;),t.synchronizerContext||(t.synchronizerContext=hC(t.synchronizerContextName));const n=vC(e,t.synchronizerContext);Object.keys(n).forEach((t=>{e[t]?e[t]=Et(e[t],n[t]):e[t]=n[t]}))}(e,t)}var bC={newInstance:Mt(yC,&quot;vtkSynchronizableRenderWindow&quot;),extend:yC,getSynchronizerContext:hC,setSynchronizerContext:function(e,t){dC[e]=t},clearSynchronizerContext:function(e){if(e&&dC[e]&&delete dC[e],!e){const e=Object.keys(dC);for(let t=0;t<e.length;t++)delete dC[e[t]]}},decorate:function(e){const t=vC(e,hC(arguments.length>1&&void 0!==arguments[1]?arguments[1]:&quot;default&quot;));return{...t,...e,delete:Et(e.delete,t.delete)}},createInstanceMap:fC,createArrayHandler:pC,createProgressHandler:gC,createSceneMtimeHandler:mC,vtkObjectManager:uC};const{vtkErrorMacro:xC,vtkDebugMacro:CC}=Wt;let SC=0;function AC(e){const t=document.querySelector(`.webResource[data-url=&quot;${e}&quot;]`);return t?t.innerHTML:null}function IC(e){return&quot;/&quot;===e[0]?e.substr(1):e}const wC={fetchJSON:function(e,t){return new Promise(((e,n)=>{const r=AC(IC(t));null===r?n(new Error(`No such JSON ${t}`)):e(JSON.parse(r))}))},fetchText:function(e,t){return new Promise(((e,n)=>{const r=AC(t);null===r?n(new Error(`No such text ${t}`)):e(r)}))},fetchArray:function(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return new Promise(((o,a)=>{const i=IC([t,n.ref.basepath,r.compression?`${n.ref.id}.gz`:n.ref.id].join(&quot;/&quot;)),s=AC(i);if(null===s)a(new Error(`No such array ${i}`));else{if(&quot;string&quot;===n.dataType){let e=atob(s);r.compression&&(e=Lm(Em(e))),n.values=JSON.parse(e)}else{const e=new Uint8Array($g.toArrayBuffer(s));n.buffer=new ArrayBuffer(e.length),new Uint8Array(n.buffer).set(e),r.compression&&(&quot;string&quot;===n.dataType||&quot;JSON&quot;===n.dataType?n.buffer=Lm(Em(new Uint8Array(n.buffer))):n.buffer=Em(new Uint8Array(n.buffer)).buffer),&quot;JSON&quot;===n.ref.encode?n.values=JSON.parse(n.buffer):(Gm!==n.ref.encode&&Gm&&(CC(`Swap bytes of ${n.name}`),Um(n.buffer,ls[n.dataType])),n.values=Wt.newTypedArray(n.dataType,n.buffer)),n.values.length!==n.size&&xC(`Error in FetchArray: ${n.name} does not have the proper array size. Got ${n.values.length}, instead of ${n.size}`)}delete n.ref,0==--SC&&e?.invokeBusy&&e.invokeBusy(!1),e?.modified&&e.modified(),o(n)}}))},fetchImage:function(e,t){return new Promise(((e,n)=>{const r=function(e){return document.querySelector(`.webResource[data-url=&quot;${e}&quot;]`)}(t);r?e(r):n(new Error(`No such image ${t}`))}))}};Xg(&quot;html&quot;,(e=>wC));const{vtkErrorMacro:OC,vtkDebugMacro:PC}=Wt;function RC(e){return function(e){return&quot;/&quot;===e[0]?e.substr(1):e}(function(e){return new URL(e,&quot;http://any&quot;).pathname}(e))}const MC=function(e){let t=!1,n=0,r=null,o=&quot;&quot;;var a;return(a=e.zipContent,new Promise(((e,t)=>{&quot;string&quot;==typeof a?e(function(e,t){if(t){for(var n=new Zg(e.length),r=0;r<e.length;++r)n[r]=e.charCodeAt(r);return n}if(Vm)return Vm.encode(e);var o=e.length,a=new Zg(e.length+(e.length>>1)),i=0,s=function(e){a[i++]=e};for(r=0;r<o;++r){if(i+5>a.length){var l=new Zg(i+8+(o-r<<1));l.set(a),a=l}var c=e.charCodeAt(r);c<128||t?s(c):c<2048?(s(192|c>>6),s(128|63&c)):c>55295&&c<57344?(s(240|(c=65536+(1047552&c)|1023&e.charCodeAt(++r))>>18),s(128|c>>12&63),s(128|c>>6&63),s(128|63&c)):(s(224|c>>12),s(128|c>>6&63),s(128|63&c))}return bm(a,0,i)}(a)):a instanceof Blob?e(a.arrayBuffer().then((e=>new Uint8Array(e)))):a instanceof ArrayBuffer?e(new Uint8Array(a)):a?.buffer instanceof ArrayBuffer?e(new Uint8Array(a.buffer)):t(new Error(&quot;Invalid datatype to unpack.&quot;))}))).then((n=>{r=_m(n),t=!0;const a=[];Object.keys(r).forEach((e=>{e.endsWith(&quot;index.json&quot;)&&a.push(e)})),a.sort(((e,t)=>e.length-t.length)),o=a[0].replace(/index\\.json$/,&quot;&quot;),e.callback&&e.callback(r)})),{fetchArray(e,a,i){let s=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return new Promise(((l,c)=>{t||OC(&quot;ERROR!!! zip not ready...&quot;);const u=RC([a,i.ref.basepath,s.compression?`${i.ref.id}.gz`:i.ref.id].join(&quot;/&quot;));function d(){delete i.ref,0==--n&&e?.invokeBusy&&e.invokeBusy(!1),e?.modified&&e.modified(),l(i)}1==++n&&e?.invokeBusy&&e.invokeBusy(!0);const p=r[`${o}${u}`];if(&quot;string&quot;!==i.dataType||s.compression){const e=function(e,t,n){return r=>{e.buffer=new ArrayBuffer(r.length),new Uint8Array(e.buffer).set(r),t&&(&quot;string&quot;===e.dataType||&quot;JSON&quot;===e.dataType?e.buffer=Lm(Em(new Uint8Array(e.buffer))):e.buffer=Em(new Uint8Array(e.buffer)).buffer),&quot;JSON&quot;===e.ref.encode?e.values=JSON.parse(e.buffer):(Gm!==e.ref.encode&&Gm&&(PC(`Swap bytes of ${e.name}`),Um(e.buffer,ls[e.dataType])),e.values=Wt.newTypedArray(e.dataType,e.buffer)),e.values.length!==e.size&&OC(`Error in FetchArray: ${e.name} does not have the proper array size. Got ${e.values.length}, instead of ${e.size}`),n()}}(i,s.compression,d);e(p)}else{const e=function(e,t,n){return r=>{e.values=t?JSON.parse(Lm(Em(r))):JSON.parse(r),n()}}(i,s.compression,d);e(Lm(p))}}))},fetchJSON(e,n){let a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};const i=RC(n);t||OC(&quot;ERROR!!! zip not ready...&quot;);const s=r[`${o}${i}`];if(a.compression){if(&quot;gz&quot;===a.compression){const e=Lm(Em(s));return Promise.resolve(JSON.parse(e))}return Promise.reject(new Error(&quot;Invalid compression&quot;))}return Promise.resolve(JSON.parse(Lm(s)))},fetchText(e,n){let a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};const i=RC(n);t||OC(&quot;ERROR!!! zip not ready...&quot;);const s=r[`${o}${i}`];return a.compression?&quot;gz&quot;===a.compression?Promise.resolve(Lm(_m(s))):Promise.reject(new Error(&quot;Invalid compression&quot;)):Promise.resolve(Lm(s))},fetchImage(e,n){const a=RC(n);t||OC(&quot;ERROR!!! zip not ready...&quot;);const i=r[`${o}${a}`];return new Promise(((e,t)=>{const n=new Image;n.onload=()=>e(n),n.onerror=t;const r=Kg(i.buffer);n.src=`data:image/${function(e){const t=e.split(&quot;.&quot;).pop().toLowerCase();return&quot;jpg&quot;===t?&quot;jpeg&quot;:t}(a)};base64,${r}`}))},fetchBinary(e,n){let a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};const i=RC(n);t||OC(&quot;ERROR!!! zip not ready...&quot;);const s=r[`${o}${i}`];return a.compression?&quot;gz&quot;===a.compression?Promise.resolve(Em(s).buffer):Promise.reject(new Error(&quot;Invalid compression&quot;)):Promise.resolve(s.buffer)}}};Xg(&quot;zip&quot;,(e=>MC(e)));var EC=n(911),VC=n.n(EC),DC=n(893),LC=n.n(DC),BC=n(383),NC=n.n(BC),FC=n(884),_C=n.n(FC),kC=n(88),GC=n.n(kC),UC=n(997),zC=n.n(UC),WC=n(96),HC={};HC.styleTagTransform=zC(),HC.setAttributes=_C(),HC.insert=NC().bind(null,&quot;head&quot;),HC.domAPI=LC(),HC.insertStyleElement=GC(),VC()(WC.A,HC);var jC=WC.A&&WC.A.locals?WC.A.locals:void 0;let KC=!0;function $C(e){e.preventDefault(),e.stopPropagation()}function qC(e,t){KC=!1,function(e){for(;e.firstChild;)e.removeChild(e.firstChild)}(e);const r=ub.newInstance({background:[1,1,1],rootContainer:e,containerStyle:{height:&quot;100%&quot;,width:&quot;100%&quot;,position:&quot;absolute&quot;}}).getRenderWindow(),o=bC.getSynchronizerContext(),a=bC.decorate(r);function i(e){o.setFetchArrayFunction((t=>Promise.resolve(e.hashes[t].content))),console.log(Object.keys(e)),a.synchronize(e.scene),a.render()}if(n.g.renderWindow=r,t.fileURL||t.url){const n=document.createElement(&quot;div&quot;);n.setAttribute(&quot;class&quot;,jC.progress),e.appendChild(n);const r=e=>{if(e.lengthComputable){const t=Math.floor(100*e.loaded/e.total);n.innerHTML=`Loading ${t}%`}else n.innerHTML=Wt.formatBytesToProperUnit(e.loaded)};t.fileURL?Km.fetchBinary(t.fileURL,{progressCallback:r}).then((t=>{e.removeChild(n);const r=Yg.get(&quot;zip&quot;,{zipContent:t,callback:e=>{r.fetchJSON(null,&quot;index.json&quot;).then(i)}})})):Km.fetchJSON(t.url,{progressCallback:r}).then((t=>{e.removeChild(n),i(t)}))}else if(t.file){const e=Yg.get(&quot;zip&quot;,{zipContent:t.file,callback:t=>{e.fetchJSON(null,&quot;index.json&quot;).then(i)}})}else if(t.base64Str){const e=$g.toArrayBuffer(t.base64Str),n=Yg.get(&quot;zip&quot;,{zipContent:e,callback:e=>{n.fetchJSON(null,&quot;index.json&quot;).then(i)}})}}function XC(e){KC=!1;const t=document.querySelector(&quot;.content&quot;),n=document.querySelector(&quot;body&quot;),r=e||t||n;r!==e?(r.classList.add(jC.fullScreen),n.style.margin=&quot;0&quot;,n.style.padding=&quot;0&quot;):(n.style.margin=&quot;0&quot;,n.style.padding=&quot;0&quot;);const o=document.createElement(&quot;div&quot;);o.innerHTML=`<div class=&quot;${jC.bigFileDrop}&quot;/><input type=&quot;file&quot; accept=&quot;.zip,.vtksz&quot; style=&quot;display: none;&quot;/>`,r.appendChild(o);const a=o.querySelector(&quot;input&quot;);function i(e){$C(e);const t=e.dataTransfer,n=e.target.files||t.files;if(1===n.length){r.removeChild(o);const e=n[0].name.split(&quot;.&quot;).slice(-1)[0];qC(r,{file:n[0],ext:e})}}a.addEventListener(&quot;change&quot;,i),o.addEventListener(&quot;drop&quot;,i),o.addEventListener(&quot;click&quot;,(e=>a.click())),o.addEventListener(&quot;dragover&quot;,$C)}const YC=Zh();if(YC.url||YC.fileURL){const e=document.querySelector(&quot;.content&quot;),t=document.querySelector(&quot;body&quot;),n=e||t;n&&(n.classList.add(jC.fullScreen),t.style.margin=&quot;0&quot;,t.style.padding=&quot;0&quot;),KC=!1,function(e){if(!window.frameElement)return e(),!0;window.frameElement.getClientRects().length>0?e():function(e,t){new window.parent.IntersectionObserver(((e,n)=>{e.forEach((e=>{e.intersectionRatio>0&&(t(),n.disconnect())}))})).observe(e)}(window.frameElement,e)}((()=>qC(n,YC)))}setTimeout((()=>{KC&&XC()}),100),window.OfflineLocalView={initLocalFileLoader:XC,load:qC}},613:function(e){&quot;use strict&quot;;e.exports=function(e){var t=[];return t.toString=function(){return this.map((function(t){var n=&quot;&quot;,r=void 0!==t[5];return t[4]&&(n+=&quot;@supports (&quot;.concat(t[4],&quot;) {&quot;)),t[2]&&(n+=&quot;@media &quot;.concat(t[2],&quot; {&quot;)),r&&(n+=&quot;@layer&quot;.concat(t[5].length>0?&quot; &quot;.concat(t[5]):&quot;&quot;,&quot; {&quot;)),n+=e(t),r&&(n+=&quot;}&quot;),t[2]&&(n+=&quot;}&quot;),t[4]&&(n+=&quot;}&quot;),n})).join(&quot;&quot;)},t.i=function(e,n,r,o,a){&quot;string&quot;==typeof e&&(e=[[null,e,void 0]]);var i={};if(r)for(var s=0;s<this.length;s++){var l=this[s][0];null!=l&&(i[l]=!0)}for(var c=0;c<e.length;c++){var u=[].concat(e[c]);r&&i[u[0]]||(void 0!==a&&(void 0===u[5]||(u[1]=&quot;@layer&quot;.concat(u[5].length>0?&quot; &quot;.concat(u[5]):&quot;&quot;,&quot; {&quot;).concat(u[1],&quot;}&quot;)),u[5]=a),n&&(u[2]?(u[1]=&quot;@media &quot;.concat(u[2],&quot; {&quot;).concat(u[1],&quot;}&quot;),u[2]=n):u[2]=n),o&&(u[4]?(u[1]=&quot;@supports (&quot;.concat(u[4],&quot;) {&quot;).concat(u[1],&quot;}&quot;),u[4]=o):u[4]=&quot;&quot;.concat(o)),t.push(u))}},t}},336:function(e){&quot;use strict&quot;;e.exports=function(e,t){return t||(t={}),e?(e=String(e.__esModule?e.default:e),/^['&quot;].*['&quot;]$/.test(e)&&(e=e.slice(1,-1)),t.hash&&(e+=t.hash),/[&quot;'() \\t\\n]|(%20)/.test(e)||t.needQuotes?'&quot;'.concat(e.replace(/&quot;/g,'\\\\&quot;').replace(/\\n/g,&quot;\\\\n&quot;),'&quot;'):e):e}},20:function(e){&quot;use strict&quot;;e.exports=function(e){return e[1]}},555:function(e,t,n){&quot;use strict&quot;;var r=n(382),o=&quot;function&quot;==typeof Symbol&&&quot;symbol&quot;==typeof Symbol(&quot;foo&quot;),a=Object.prototype.toString,i=Array.prototype.concat,s=Object.defineProperty,l=s&&function(){var e={};try{for(var t in s(e,&quot;x&quot;,{enumerable:!1,value:e}),e)return!1;return e.x===e}catch(e){return!1}}(),c=function(e,t,n,r){var o;(!(t in e)||&quot;function&quot;==typeof(o=r)&&&quot;[object Function]&quot;===a.call(o)&&r())&&(l?s(e,t,{configurable:!0,enumerable:!1,value:n,writable:!0}):e[t]=n)},u=function(e,t){var n=arguments.length>2?arguments[2]:{},a=r(t);o&&(a=i.call(a,Object.getOwnPropertySymbols(t)));for(var s=0;s<a.length;s+=1)c(e,a[s],t[a[s]],n[a[s]])};u.supportsDescriptors=!!l,e.exports=u},77:function(e,t,n){&quot;use strict&quot;;e.exports=function(){if(&quot;object&quot;==typeof globalThis)return globalThis;var e;try{e=this||new Function(&quot;return this&quot;)()}catch(e){if(&quot;object&quot;==typeof window)return window;if(&quot;object&quot;==typeof self)return self;if(void 0!==n.g)return n.g}return e}()},730:function(e){&quot;use strict&quot;;e.exports=function e(t,n){if(t===n)return!0;if(t&&n&&&quot;object&quot;==typeof t&&&quot;object&quot;==typeof n){if(t.constructor!==n.constructor)return!1;var r,o,a;if(Array.isArray(t)){if((r=t.length)!=n.length)return!1;for(o=r;0!=o--;)if(!e(t[o],n[o]))return!1;return!0}if(t.constructor===RegExp)return t.source===n.source&&t.flags===n.flags;if(t.valueOf!==Object.prototype.valueOf)return t.valueOf()===n.valueOf();if(t.toString!==Object.prototype.toString)return t.toString()===n.toString();if((r=(a=Object.keys(t)).length)!==Object.keys(n).length)return!1;for(o=r;0!=o--;)if(!Object.prototype.hasOwnProperty.call(n,a[o]))return!1;for(o=r;0!=o--;){var i=a[o];if(!e(t[i],n[i]))return!1}return!0}return t!=t&&n!=n}},979:function(e){&quot;use strict&quot;;&quot;undefined&quot;!=typeof self?e.exports=self:&quot;undefined&quot;!=typeof window?e.exports=window:e.exports=Function(&quot;return this&quot;)()},59:function(e,t,n){&quot;use strict&quot;;var r=n(555),o=n(979),a=n(920),i=n(482),s=a(),l=function(){return s};r(l,{getPolyfill:a,implementation:o,shim:i}),e.exports=l},920:function(e,t,n){&quot;use strict&quot;;var r=n(979);e.exports=function(){return&quot;object&quot;==typeof n.g&&n.g&&n.g.Math===Math&&n.g.Array===Array?n.g:r}},482:function(e,t,n){&quot;use strict&quot;;var r=n(555),o=n(920);e.exports=function(){var e=o();if(r.supportsDescriptors){var t=Object.getOwnPropertyDescriptor(e,&quot;globalThis&quot;);t&&(!t.configurable||!t.enumerable&&t.writable&&globalThis===e)||Object.defineProperty(e,&quot;globalThis&quot;,{configurable:!0,enumerable:!1,value:e,writable:!0})}else&quot;object&quot;==typeof globalThis&&globalThis===e||(e.globalThis=e);return e}},982:function(e,t,n){&quot;use strict&quot;;var r;if(!Object.keys){var o=Object.prototype.hasOwnProperty,a=Object.prototype.toString,i=n(642),s=Object.prototype.propertyIsEnumerable,l=!s.call({toString:null},&quot;toString&quot;),c=s.call((function(){}),&quot;prototype&quot;),u=[&quot;toString&quot;,&quot;toLocaleString&quot;,&quot;valueOf&quot;,&quot;hasOwnProperty&quot;,&quot;isPrototypeOf&quot;,&quot;propertyIsEnumerable&quot;,&quot;constructor&quot;],d=function(e){var t=e.constructor;return t&&t.prototype===e},p={$applicationCache:!0,$console:!0,$external:!0,$frame:!0,$frameElement:!0,$frames:!0,$innerHeight:!0,$innerWidth:!0,$onmozfullscreenchange:!0,$onmozfullscreenerror:!0,$outerHeight:!0,$outerWidth:!0,$pageXOffset:!0,$pageYOffset:!0,$parent:!0,$scrollLeft:!0,$scrollTop:!0,$scrollX:!0,$scrollY:!0,$self:!0,$webkitIndexedDB:!0,$webkitStorageInfo:!0,$window:!0},f=function(){if(&quot;undefined&quot;==typeof window)return!1;for(var e in window)try{if(!p[&quot;$&quot;+e]&&o.call(window,e)&&null!==window[e]&&&quot;object&quot;==typeof window[e])try{d(window[e])}catch(e){return!0}}catch(e){return!0}return!1}();r=function(e){var t=null!==e&&&quot;object&quot;==typeof e,n=&quot;[object Function]&quot;===a.call(e),r=i(e),s=t&&&quot;[object String]&quot;===a.call(e),p=[];if(!t&&!n&&!r)throw new TypeError(&quot;Object.keys called on a non-object&quot;);var g=c&&n;if(s&&e.length>0&&!o.call(e,0))for(var m=0;m<e.length;++m)p.push(String(m));if(r&&e.length>0)for(var h=0;h<e.length;++h)p.push(String(h));else for(var v in e)g&&&quot;prototype&quot;===v||!o.call(e,v)||p.push(String(v));if(l)for(var T=function(e){if(&quot;undefined&quot;==typeof window||!f)return d(e);try{return d(e)}catch(e){return!1}}(e),y=0;y<u.length;++y)T&&&quot;constructor&quot;===u[y]||!o.call(e,u[y])||p.push(u[y]);return p}}e.exports=r},382:function(e,t,n){&quot;use strict&quot;;var r=Array.prototype.slice,o=n(642),a=Object.keys,i=a?function(e){return a(e)}:n(982),s=Object.keys;i.shim=function(){if(Object.keys){var e=function(){var e=Object.keys(arguments);return e&&e.length===arguments.length}(1,2);e||(Object.keys=function(e){return o(e)?s(r.call(e)):s(e)})}else Object.keys=i;return Object.keys||i},e.exports=i},642:function(e){&quot;use strict&quot;;var t=Object.prototype.toString;e.exports=function(e){var n=t.call(e),r=&quot;[object Arguments]&quot;===n;return r||(r=&quot;[object Array]&quot;!==n&&null!==e&&&quot;object&quot;==typeof e&&&quot;number&quot;==typeof e.length&&e.length>=0&&&quot;[object Function]&quot;===t.call(e.callee)),r}},318:function(e,t,n){var r=n(767),o=n(698),a=n(744),i=n(402),s=n(576),l=n(886),c=n(262);c.alea=r,c.xor128=o,c.xorwow=a,c.xorshift7=i,c.xor4096=s,c.tychei=l,e.exports=c},767:function(e,t,n){var r;!function(e,o){function a(e){var t,n=this,r=(t=4022871197,function(e){e=String(e);for(var n=0;n<e.length;n++){var r=.02519603282416938*(t+=e.charCodeAt(n));r-=t=r>>>0,t=(r*=t)>>>0,t+=4294967296*(r-=t)}return 2.3283064365386963e-10*(t>>>0)});n.next=function(){var e=2091639*n.s0+2.3283064365386963e-10*n.c;return n.s0=n.s1,n.s1=n.s2,n.s2=e-(n.c=0|e)},n.c=1,n.s0=r(&quot; &quot;),n.s1=r(&quot; &quot;),n.s2=r(&quot; &quot;),n.s0-=r(e),n.s0<0&&(n.s0+=1),n.s1-=r(e),n.s1<0&&(n.s1+=1),n.s2-=r(e),n.s2<0&&(n.s2+=1),r=null}function i(e,t){return t.c=e.c,t.s0=e.s0,t.s1=e.s1,t.s2=e.s2,t}function s(e,t){var n=new a(e),r=t&&t.state,o=n.next;return o.int32=function(){return 4294967296*n.next()|0},o.double=function(){return o()+11102230246251565e-32*(2097152*o()|0)},o.quick=o,r&&(&quot;object&quot;==typeof r&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.alea=s}(0,e=n.nmd(e),n.amdD)},886:function(e,t,n){var r;!function(e,o){function a(e){var t=this,n=&quot;&quot;;t.next=function(){var e=t.b,n=t.c,r=t.d,o=t.a;return e=e<<25^e>>>7^n,n=n-r|0,r=r<<24^r>>>8^o,o=o-e|0,t.b=e=e<<20^e>>>12^n,t.c=n=n-r|0,t.d=r<<16^n>>>16^o,t.a=o-e|0},t.a=0,t.b=0,t.c=-1640531527,t.d=1367130551,e===Math.floor(e)?(t.a=e/4294967296|0,t.b=0|e):n+=e;for(var r=0;r<n.length+20;r++)t.b^=0|n.charCodeAt(r),t.next()}function i(e,t){return t.a=e.a,t.b=e.b,t.c=e.c,t.d=e.d,t}function s(e,t){var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(&quot;object&quot;==typeof r&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.tychei=s}(0,e=n.nmd(e),n.amdD)},698:function(e,t,n){var r;!function(e,o){function a(e){var t=this,n=&quot;&quot;;t.x=0,t.y=0,t.z=0,t.w=0,t.next=function(){var e=t.x^t.x<<11;return t.x=t.y,t.y=t.z,t.z=t.w,t.w^=t.w>>>19^e^e>>>8},e===(0|e)?t.x=e:n+=e;for(var r=0;r<n.length+64;r++)t.x^=0|n.charCodeAt(r),t.next()}function i(e,t){return t.x=e.x,t.y=e.y,t.z=e.z,t.w=e.w,t}function s(e,t){var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(&quot;object&quot;==typeof r&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.xor128=s}(0,e=n.nmd(e),n.amdD)},576:function(e,t,n){var r;!function(e,o){function a(e){var t=this;t.next=function(){var e,n,r=t.w,o=t.X,a=t.i;return t.w=r=r+1640531527|0,n=o[a+34&127],e=o[a=a+1&127],n^=n<<13,e^=e<<17,n^=n>>>15,e^=e>>>12,n=o[a]=n^e,t.i=a,n+(r^r>>>16)|0},function(e,t){var n,r,o,a,i,s=[],l=128;for(t===(0|t)?(r=t,t=null):(t+=&quot;\\0&quot;,r=0,l=Math.max(l,t.length)),o=0,a=-32;a<l;++a)t&&(r^=t.charCodeAt((a+32)%t.length)),0===a&&(i=r),r^=r<<10,r^=r>>>15,r^=r<<4,r^=r>>>13,a>=0&&(i=i+1640531527|0,o=0==(n=s[127&a]^=r+i)?o+1:0);for(o>=128&&(s[127&(t&&t.length||0)]=-1),o=127,a=512;a>0;--a)r=s[o+34&127],n=s[o=o+1&127],r^=r<<13,n^=n<<17,r^=r>>>15,n^=n>>>12,s[o]=r^n;e.w=i,e.X=s,e.i=o}(t,e)}function i(e,t){return t.i=e.i,t.w=e.w,t.X=e.X.slice(),t}function s(e,t){null==e&&(e=+new Date);var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(r.X&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.xor4096=s}(0,e=n.nmd(e),n.amdD)},402:function(e,t,n){var r;!function(e,o){function a(e){var t=this;t.next=function(){var e,n,r=t.x,o=t.i;return e=r[o],n=(e^=e>>>7)^e<<24,n^=(e=r[o+1&7])^e>>>10,n^=(e=r[o+3&7])^e>>>3,n^=(e=r[o+4&7])^e<<7,e=r[o+7&7],n^=(e^=e<<13)^e<<9,r[o]=n,t.i=o+1&7,n},function(e,t){var n,r=[];if(t===(0|t))r[0]=t;else for(t=&quot;&quot;+t,n=0;n<t.length;++n)r[7&n]=r[7&n]<<15^t.charCodeAt(n)+r[n+1&7]<<13;for(;r.length<8;)r.push(0);for(n=0;n<8&&0===r[n];++n);for(8==n?r[7]=-1:r[n],e.x=r,e.i=0,n=256;n>0;--n)e.next()}(t,e)}function i(e,t){return t.x=e.x.slice(),t.i=e.i,t}function s(e,t){null==e&&(e=+new Date);var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(r.x&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.xorshift7=s}(0,e=n.nmd(e),n.amdD)},744:function(e,t,n){var r;!function(e,o){function a(e){var t=this,n=&quot;&quot;;t.next=function(){var e=t.x^t.x>>>2;return t.x=t.y,t.y=t.z,t.z=t.w,t.w=t.v,(t.d=t.d+362437|0)+(t.v=t.v^t.v<<4^e^e<<1)|0},t.x=0,t.y=0,t.z=0,t.w=0,t.v=0,e===(0|e)?t.x=e:n+=e;for(var r=0;r<n.length+64;r++)t.x^=0|n.charCodeAt(r),r==n.length&&(t.d=t.x<<10^t.x>>>4),t.next()}function i(e,t){return t.x=e.x,t.y=e.y,t.z=e.z,t.w=e.w,t.v=e.v,t.d=e.d,t}function s(e,t){var n=new a(e),r=t&&t.state,o=function(){return(n.next()>>>0)/4294967296};return o.double=function(){do{var e=((n.next()>>>11)+(n.next()>>>0)/4294967296)/(1<<21)}while(0===e);return e},o.int32=n.next,o.quick=o,r&&(&quot;object&quot;==typeof r&&i(r,n),o.state=function(){return i(n,{})}),o}o&&o.exports?o.exports=s:n.amdD&&n.amdO?void 0===(r=function(){return s}.call(t,n,t,o))||(o.exports=r):this.xorwow=s}(0,e=n.nmd(e),n.amdD)},262:function(e,t,n){var r;!function(o,a,i){var s,l=256,c=i.pow(l,6),u=i.pow(2,52),d=2*u,p=255;function f(e,t,n){var r=[],p=v(h((t=1==t?{entropy:!0}:t||{}).entropy?[e,T(a)]:null==e?function(){try{var e;return s&&(e=s.randomBytes)?e=e(l):(e=new Uint8Array(l),(o.crypto||o.msCrypto).getRandomValues(e)),T(e)}catch(e){var t=o.navigator,n=t&&t.plugins;return[+new Date,o,n,o.screen,T(a)]}}():e,3),r),f=new g(r),y=function(){for(var e=f.g(6),t=c,n=0;e<u;)e=(e+n)*l,t*=l,n=f.g(1);for(;e>=d;)e/=2,t/=2,n>>>=1;return(e+n)/t};return y.int32=function(){return 0|f.g(4)},y.quick=function(){return f.g(4)/4294967296},y.double=y,v(T(f.S),a),(t.pass||n||function(e,t,n,r){return r&&(r.S&&m(r,f),e.state=function(){return m(f,{})}),n?(i.random=e,t):e})(y,p,&quot;global&quot;in t?t.global:this==i,t.state)}function g(e){var t,n=e.length,r=this,o=0,a=r.i=r.j=0,i=r.S=[];for(n||(e=[n++]);o<l;)i[o]=o++;for(o=0;o<l;o++)i[o]=i[a=p&a+e[o%n]+(t=i[o])],i[a]=t;(r.g=function(e){for(var t,n=0,o=r.i,a=r.j,i=r.S;e--;)t=i[o=p&o+1],n=n*l+i[p&(i[o]=i[a=p&a+t])+(i[a]=t)];return r.i=o,r.j=a,n})(l)}function m(e,t){return t.i=e.i,t.j=e.j,t.S=e.S.slice(),t}function h(e,t){var n,r=[],o=typeof e;if(t&&&quot;object&quot;==o)for(n in e)try{r.push(h(e[n],t-1))}catch(e){}return r.length?r:&quot;string&quot;==o?e:e+&quot;\\0&quot;}function v(e,t){for(var n,r=e+&quot;&quot;,o=0;o<r.length;)t[p&o]=p&(n^=19*t[p&o])+r.charCodeAt(o++);return T(t)}function T(e){return String.fromCharCode.apply(0,e)}if(v(i.random(),a),e.exports){e.exports=f;try{s=n(1)}catch(e){}}else void 0===(r=function(){return f}.call(t,n,t,e))||(e.exports=r)}(&quot;undefined&quot;!=typeof self?self:this,[],Math)},292:function(e){e.exports=function(){&quot;use strict&quot;;var e=[&quot;0&quot;,&quot;1&quot;,&quot;2&quot;,&quot;3&quot;,&quot;4&quot;,&quot;5&quot;,&quot;6&quot;,&quot;7&quot;,&quot;8&quot;,&quot;9&quot;,&quot;a&quot;,&quot;b&quot;,&quot;c&quot;,&quot;d&quot;,&quot;e&quot;,&quot;f&quot;];function t(e,t){var n=e[0],r=e[1],o=e[2],a=e[3];r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&o|~r&a)+t[0]-680876936|0)<<7|n>>>25)+r|0)&r|~n&o)+t[1]-389564586|0)<<12|a>>>20)+n|0)&n|~a&r)+t[2]+606105819|0)<<17|o>>>15)+a|0)&a|~o&n)+t[3]-1044525330|0)<<22|r>>>10)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&o|~r&a)+t[4]-176418897|0)<<7|n>>>25)+r|0)&r|~n&o)+t[5]+1200080426|0)<<12|a>>>20)+n|0)&n|~a&r)+t[6]-1473231341|0)<<17|o>>>15)+a|0)&a|~o&n)+t[7]-45705983|0)<<22|r>>>10)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&o|~r&a)+t[8]+1770035416|0)<<7|n>>>25)+r|0)&r|~n&o)+t[9]-1958414417|0)<<12|a>>>20)+n|0)&n|~a&r)+t[10]-42063|0)<<17|o>>>15)+a|0)&a|~o&n)+t[11]-1990404162|0)<<22|r>>>10)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&o|~r&a)+t[12]+1804603682|0)<<7|n>>>25)+r|0)&r|~n&o)+t[13]-40341101|0)<<12|a>>>20)+n|0)&n|~a&r)+t[14]-1502002290|0)<<17|o>>>15)+a|0)&a|~o&n)+t[15]+1236535329|0)<<22|r>>>10)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&a|o&~a)+t[1]-165796510|0)<<5|n>>>27)+r|0)&o|r&~o)+t[6]-1069501632|0)<<9|a>>>23)+n|0)&r|n&~r)+t[11]+643717713|0)<<14|o>>>18)+a|0)&n|a&~n)+t[0]-373897302|0)<<20|r>>>12)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&a|o&~a)+t[5]-701558691|0)<<5|n>>>27)+r|0)&o|r&~o)+t[10]+38016083|0)<<9|a>>>23)+n|0)&r|n&~r)+t[15]-660478335|0)<<14|o>>>18)+a|0)&n|a&~n)+t[4]-405537848|0)<<20|r>>>12)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&a|o&~a)+t[9]+568446438|0)<<5|n>>>27)+r|0)&o|r&~o)+t[14]-1019803690|0)<<9|a>>>23)+n|0)&r|n&~r)+t[3]-187363961|0)<<14|o>>>18)+a|0)&n|a&~n)+t[8]+1163531501|0)<<20|r>>>12)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r&a|o&~a)+t[13]-1444681467|0)<<5|n>>>27)+r|0)&o|r&~o)+t[2]-51403784|0)<<9|a>>>23)+n|0)&r|n&~r)+t[7]+1735328473|0)<<14|o>>>18)+a|0)&n|a&~n)+t[12]-1926607734|0)<<20|r>>>12)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r^o^a)+t[5]-378558|0)<<4|n>>>28)+r|0)^r^o)+t[8]-2022574463|0)<<11|a>>>21)+n|0)^n^r)+t[11]+1839030562|0)<<16|o>>>16)+a|0)^a^n)+t[14]-35309556|0)<<23|r>>>9)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r^o^a)+t[1]-1530992060|0)<<4|n>>>28)+r|0)^r^o)+t[4]+1272893353|0)<<11|a>>>21)+n|0)^n^r)+t[7]-155497632|0)<<16|o>>>16)+a|0)^a^n)+t[10]-1094730640|0)<<23|r>>>9)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r^o^a)+t[13]+681279174|0)<<4|n>>>28)+r|0)^r^o)+t[0]-358537222|0)<<11|a>>>21)+n|0)^n^r)+t[3]-722521979|0)<<16|o>>>16)+a|0)^a^n)+t[6]+76029189|0)<<23|r>>>9)+o|0,r=((r+=((o=((o+=((a=((a+=((n=((n+=(r^o^a)+t[9]-640364487|0)<<4|n>>>28)+r|0)^r^o)+t[12]-421815835|0)<<11|a>>>21)+n|0)^n^r)+t[15]+530742520|0)<<16|o>>>16)+a|0)^a^n)+t[2]-995338651|0)<<23|r>>>9)+o|0,r=((r+=((a=((a+=(r^((n=((n+=(o^(r|~a))+t[0]-198630844|0)<<6|n>>>26)+r|0)|~o))+t[7]+1126891415|0)<<10|a>>>22)+n|0)^((o=((o+=(n^(a|~r))+t[14]-1416354905|0)<<15|o>>>17)+a|0)|~n))+t[5]-57434055|0)<<21|r>>>11)+o|0,r=((r+=((a=((a+=(r^((n=((n+=(o^(r|~a))+t[12]+1700485571|0)<<6|n>>>26)+r|0)|~o))+t[3]-1894986606|0)<<10|a>>>22)+n|0)^((o=((o+=(n^(a|~r))+t[10]-1051523|0)<<15|o>>>17)+a|0)|~n))+t[1]-2054922799|0)<<21|r>>>11)+o|0,r=((r+=((a=((a+=(r^((n=((n+=(o^(r|~a))+t[8]+1873313359|0)<<6|n>>>26)+r|0)|~o))+t[15]-30611744|0)<<10|a>>>22)+n|0)^((o=((o+=(n^(a|~r))+t[6]-1560198380|0)<<15|o>>>17)+a|0)|~n))+t[13]+1309151649|0)<<21|r>>>11)+o|0,r=((r+=((a=((a+=(r^((n=((n+=(o^(r|~a))+t[4]-145523070|0)<<6|n>>>26)+r|0)|~o))+t[11]-1120210379|0)<<10|a>>>22)+n|0)^((o=((o+=(n^(a|~r))+t[2]+718787259|0)<<15|o>>>17)+a|0)|~n))+t[9]-343485551|0)<<21|r>>>11)+o|0,e[0]=n+e[0]|0,e[1]=r+e[1]|0,e[2]=o+e[2]|0,e[3]=a+e[3]|0}function n(e){var t,n=[];for(t=0;t<64;t+=4)n[t>>2]=e.charCodeAt(t)+(e.charCodeAt(t+1)<<8)+(e.charCodeAt(t+2)<<16)+(e.charCodeAt(t+3)<<24);return n}function r(e){var t,n=[];for(t=0;t<64;t+=4)n[t>>2]=e[t]+(e[t+1]<<8)+(e[t+2]<<16)+(e[t+3]<<24);return n}function o(e){var r,o,a,i,s,l,c=e.length,u=[1732584193,-271733879,-1732584194,271733878];for(r=64;r<=c;r+=64)t(u,n(e.substring(r-64,r)));for(o=(e=e.substring(r-64)).length,a=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],r=0;r<o;r+=1)a[r>>2]|=e.charCodeAt(r)<<(r%4<<3);if(a[r>>2]|=128<<(r%4<<3),r>55)for(t(u,a),r=0;r<16;r+=1)a[r]=0;return i=(i=8*c).toString(16).match(/(.*?)(.{0,8})$/),s=parseInt(i[2],16),l=parseInt(i[1],16)||0,a[14]=s,a[15]=l,t(u,a),u}function a(t){var n,r=&quot;&quot;;for(n=0;n<4;n+=1)r+=e[t>>8*n+4&15]+e[t>>8*n&15];return r}function i(e){var t;for(t=0;t<e.length;t+=1)e[t]=a(e[t]);return e.join(&quot;&quot;)}function s(e){return/[\\u0080-\\uFFFF]/.test(e)&&(e=unescape(encodeURIComponent(e))),e}function l(e){var t,n=[],r=e.length;for(t=0;t<r-1;t+=2)n.push(parseInt(e.substr(t,2),16));return String.fromCharCode.apply(String,n)}function c(){this.reset()}return i(o(&quot;hello&quot;)),&quot;undefined&quot;==typeof ArrayBuffer||ArrayBuffer.prototype.slice||function(){function e(e,t){return(e=0|e||0)<0?Math.max(e+t,0):Math.min(e,t)}ArrayBuffer.prototype.slice=function(t,n){var r,o,a,i,s=this.byteLength,l=e(t,s),c=s;return undefined!==n&&(c=e(n,s)),l>c?new ArrayBuffer(0):(r=c-l,o=new ArrayBuffer(r),a=new Uint8Array(o),i=new Uint8Array(this,l,r),a.set(i),o)}}(),c.prototype.append=function(e){return this.appendBinary(s(e)),this},c.prototype.appendBinary=function(e){this._buff+=e,this._length+=e.length;var r,o=this._buff.length;for(r=64;r<=o;r+=64)t(this._hash,n(this._buff.substring(r-64,r)));return this._buff=this._buff.substring(r-64),this},c.prototype.end=function(e){var t,n,r=this._buff,o=r.length,a=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;t<o;t+=1)a[t>>2]|=r.charCodeAt(t)<<(t%4<<3);return this._finish(a,o),n=i(this._hash),e&&(n=l(n)),this.reset(),n},c.prototype.reset=function(){return this._buff=&quot;&quot;,this._length=0,this._hash=[1732584193,-271733879,-1732584194,271733878],this},c.prototype.getState=function(){return{buff:this._buff,length:this._length,hash:this._hash.slice()}},c.prototype.setState=function(e){return this._buff=e.buff,this._length=e.length,this._hash=e.hash,this},c.prototype.destroy=function(){delete this._hash,delete this._buff,delete this._length},c.prototype._finish=function(e,n){var r,o,a,i=n;if(e[i>>2]|=128<<(i%4<<3),i>55)for(t(this._hash,e),i=0;i<16;i+=1)e[i]=0;r=(r=8*this._length).toString(16).match(/(.*?)(.{0,8})$/),o=parseInt(r[2],16),a=parseInt(r[1],16)||0,e[14]=o,e[15]=a,t(this._hash,e)},c.hash=function(e,t){return c.hashBinary(s(e),t)},c.hashBinary=function(e,t){var n=i(o(e));return t?l(n):n},c.ArrayBuffer=function(){this.reset()},c.ArrayBuffer.prototype.append=function(e){var n,o,a,i,s,l=(o=this._buff.buffer,a=e,i=!0,(s=new Uint8Array(o.byteLength+a.byteLength)).set(new Uint8Array(o)),s.set(new Uint8Array(a),o.byteLength),i?s:s.buffer),c=l.length;for(this._length+=e.byteLength,n=64;n<=c;n+=64)t(this._hash,r(l.subarray(n-64,n)));return this._buff=n-64<c?new Uint8Array(l.buffer.slice(n-64)):new Uint8Array(0),this},c.ArrayBuffer.prototype.end=function(e){var t,n,r=this._buff,o=r.length,a=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;t<o;t+=1)a[t>>2]|=r[t]<<(t%4<<3);return this._finish(a,o),n=i(this._hash),e&&(n=l(n)),this.reset(),n},c.ArrayBuffer.prototype.reset=function(){return this._buff=new Uint8Array(0),this._length=0,this._hash=[1732584193,-271733879,-1732584194,271733878],this},c.ArrayBuffer.prototype.getState=function(){var e,t=c.prototype.getState.call(this);return t.buff=(e=t.buff,String.fromCharCode.apply(null,new Uint8Array(e))),t},c.ArrayBuffer.prototype.setState=function(e){return e.buff=function(e,t){var n,r=e.length,o=new ArrayBuffer(r),a=new Uint8Array(o);for(n=0;n<r;n+=1)a[n]=e.charCodeAt(n);return t?a:o}(e.buff,!0),c.prototype.setState.call(this,e)},c.ArrayBuffer.prototype.destroy=c.prototype.destroy,c.ArrayBuffer.prototype._finish=c.prototype._finish,c.ArrayBuffer.hash=function(e,n){var o=i(function(e){var n,o,a,i,s,l,c=e.length,u=[1732584193,-271733879,-1732584194,271733878];for(n=64;n<=c;n+=64)t(u,r(e.subarray(n-64,n)));for(o=(e=n-64<c?e.subarray(n-64):new Uint8Array(0)).length,a=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],n=0;n<o;n+=1)a[n>>2]|=e[n]<<(n%4<<3);if(a[n>>2]|=128<<(n%4<<3),n>55)for(t(u,a),n=0;n<16;n+=1)a[n]=0;return i=(i=8*c).toString(16).match(/(.*?)(.{0,8})$/),s=parseInt(i[2],16),l=parseInt(i[1],16)||0,a[14]=s,a[15]=l,t(u,a),u}(new Uint8Array(e)));return n?l(o):o},c}()},96:function(e,t,n){&quot;use strict&quot;;var r=n(20),o=n.n(r),a=n(613),i=n.n(a),s=n(336),l=n.n(s),c=new URL(n(183),n.b),u=i()(o()),d=l()(c);u.push([e.id,&quot;.viewer-module-fullScreen_bbk9Y {\\n  position: absolute;\\n  width: 100vw;\\n  height: 100vh;\\n  top: 0;\\n  left: 0;\\n  overflow: hidden;\\n  background: black;\\n  margin: 0;\\n  padding: 0;\\n  z-index: -1;\\n  display: flex;\\n  align-items: center;\\n  justify-content: center;\\n}\\n\\n.viewer-module-fullParentSize_ETopO {\\n  position: absolute;\\n  width: 100%;\\n  height: 100%;\\n  top: 0;\\n  left: 0;\\n  overflow: hidden;\\n}\\n\\n.viewer-module-bigFileDrop_aqCgh {\\n  position: absolute;\\n  left: 50%;\\n  top: 50%;\\n  transform: translate(-50%, -50%);\\n  background-color: white;\\n  background-image: url(&quot;+d+&quot;);\\n  background-repeat: no-repeat;\\n  background-position: center;\\n  background-size: contain;\\n  border-radius: 10px;\\n  width: 50px;\\n  padding: calc(50vh - 2em) calc(50vw - 25px - 2em);\\n  cursor: pointer;\\n}\\n\\n.viewer-module-progress_cYjQJ {\\n  flex: none;\\n  font-size: 50px;\\n  color: black;\\n  z-index: 1;\\n  background: rgba(128,128,128,.5);\\n  padding: 20px;\\n  border-radius: 10px;\\n  -webkit-user-select: none;\\n     -moz-user-select: none;\\n          user-select: none;\\n}\\n\\nbody {\\n  margin: 0;\\n}\\n\\nhtml { \\n  overflow: hidden; \\n}\\n&quot;,&quot;&quot;]),u.locals={fullScreen:&quot;viewer-module-fullScreen_bbk9Y&quot;,fullParentSize:&quot;viewer-module-fullParentSize_ETopO&quot;,bigFileDrop:&quot;viewer-module-bigFileDrop_aqCgh&quot;,progress:&quot;viewer-module-progress_cYjQJ&quot;},t.A=u},50:function(e,t,n){var r=n(853),o=n(77);void 0===o.OfflineLocalView&&(o.OfflineLocalView=r),e.exports=r},911:function(e){&quot;use strict&quot;;var t=[];function n(e){for(var n=-1,r=0;r<t.length;r++)if(t[r].identifier===e){n=r;break}return n}function r(e,r){for(var a={},i=[],s=0;s<e.length;s++){var l=e[s],c=r.base?l[0]+r.base:l[0],u=a[c]||0,d=&quot;&quot;.concat(c,&quot; &quot;).concat(u);a[c]=u+1;var p=n(d),f={css:l[1],media:l[2],sourceMap:l[3],supports:l[4],layer:l[5]};if(-1!==p)t[p].references++,t[p].updater(f);else{var g=o(f,r);r.byIndex=s,t.splice(s,0,{identifier:d,updater:g,references:1})}i.push(d)}return i}function o(e,t){var n=t.domAPI(t);return n.update(e),function(t){if(t){if(t.css===e.css&&t.media===e.media&&t.sourceMap===e.sourceMap&&t.supports===e.supports&&t.layer===e.layer)return;n.update(e=t)}else n.remove()}}e.exports=function(e,o){var a=r(e=e||[],o=o||{});return function(e){e=e||[];for(var i=0;i<a.length;i++){var s=n(a[i]);t[s].references--}for(var l=r(e,o),c=0;c<a.length;c++){var u=n(a[c]);0===t[u].references&&(t[u].updater(),t.splice(u,1))}a=l}}},383:function(e){&quot;use strict&quot;;var t={};e.exports=function(e,n){var r=function(e){if(void 0===t[e]){var n=document.querySelector(e);if(window.HTMLIFrameElement&&n instanceof window.HTMLIFrameElement)try{n=n.contentDocument.head}catch(e){n=null}t[e]=n}return t[e]}(e);if(!r)throw new Error(&quot;Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.&quot;);r.appendChild(n)}},88:function(e){&quot;use strict&quot;;e.exports=function(e){var t=document.createElement(&quot;style&quot;);return e.setAttributes(t,e.attributes),e.insert(t,e.options),t}},884:function(e,t,n){&quot;use strict&quot;;e.exports=function(e){var t=n.nc;t&&e.setAttribute(&quot;nonce&quot;,t)}},893:function(e){&quot;use strict&quot;;e.exports=function(e){var t=e.insertStyleElement(e);return{update:function(n){!function(e,t,n){var r=&quot;&quot;;n.supports&&(r+=&quot;@supports (&quot;.concat(n.supports,&quot;) {&quot;)),n.media&&(r+=&quot;@media &quot;.concat(n.media,&quot; {&quot;));var o=void 0!==n.layer;o&&(r+=&quot;@layer&quot;.concat(n.layer.length>0?&quot; &quot;.concat(n.layer):&quot;&quot;,&quot; {&quot;)),r+=n.css,o&&(r+=&quot;}&quot;),n.media&&(r+=&quot;}&quot;),n.supports&&(r+=&quot;}&quot;);var a=n.sourceMap;a&&&quot;undefined&quot;!=typeof btoa&&(r+=&quot;\\n/*# sourceMappingURL=data:application/json;base64,&quot;.concat(btoa(unescape(encodeURIComponent(JSON.stringify(a)))),&quot; */&quot;)),t.styleTagTransform(r,e,t.options)}(t,e,n)},remove:function(){!function(e){if(null===e.parentNode)return!1;e.parentNode.removeChild(e)}(t)}}}},997:function(e){&quot;use strict&quot;;e.exports=function(e,t){if(t.styleSheet)t.styleSheet.cssText=e;else{for(;t.firstChild;)t.removeChild(t.firstChild);t.appendChild(document.createTextNode(e))}}},183:function(e,t,n){&quot;use strict&quot;;e.exports=n.p+&quot;138e7b1469f64156810a.jpg&quot;},1:function(){}},t={};function n(r){var o=t[r];if(void 0!==o)return o.exports;var a=t[r]={id:r,loaded:!1,exports:{}};return e[r].call(a.exports,a,a.exports,n),a.loaded=!0,a.exports}n.m=e,n.amdD=function(){throw new Error(&quot;define cannot be used indirect&quot;)},n.amdO={},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,{a:t}),t},n.d=function(e,t){for(var r in t)n.o(t,r)&&!n.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},n.g=function(){if(&quot;object&quot;==typeof globalThis)return globalThis;try{return this||new Function(&quot;return this&quot;)()}catch(e){if(&quot;object&quot;==typeof window)return window}}(),n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.r=function(e){&quot;undefined&quot;!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:&quot;Module&quot;}),Object.defineProperty(e,&quot;__esModule&quot;,{value:!0})},n.nmd=function(e){return e.paths=[],e.children||(e.children=[]),e},n.p=&quot;&quot;,n.b=document.baseURI||self.location.href,n.nc=void 0,n(50)}();\n</script>\n<script>\nvar container = document.querySelector('.content');\nvar base64Str = &quot;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&quot;;\n\nOfflineLocalView.load(container, { base64Str });\n</script>\n</body>\n</html>\n\" class=\"pyvista\" style=\"width: 100%; height: 600px; border: 1px solid rgb(221,221,221);\"></iframe>"
      }
     },
     "95c48461a41a4668ab6f75b2593e4a55": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "2.0.0",
       "_model_name": "HTMLStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "2.0.0",
       "_view_name": "StyleView",
       "background": null,
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}