bocklund · May 3, 2025 23:15 · bocklund · May 2, 2025 · bocklund · May 3, 2025
diff --git a/2025-04-30-3D-ternary.ipynb b/2025-04-30-3D-ternary.ipynb
 {
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from pycalphad import Database, Workspace, variables as v\n",
    "from pycalphad.mapping import TernaryStrategy, plot_ternary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dbf = Database(\"/Users/brandonbocklund/src/calphad/calphad-databases/tdbs/working/Cr-Fe-Ni.tdb\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "components = [\"CR\", \"FE\", \"NI\", \"VA\"]\n",
    "phases = list(dbf.phases.keys())\n",
    "conditions = {v.P: 101325, v.T: 1000, v.N: 1, v.X(\"CR\"): (0, 1, 0.01), v.X(\"NI\"): (0, 1, 0.01)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pycalphad.mapping.primitives import _get_phase_specific_variable\n",
    "\n",
    "from pycalphad.mapping import StepStrategy\n",
    "from pycalphad.mapping.strategy import MapStrategy\n",
    "from pycalphad.mapping.primitives import MIN_COMPOSITION\n",
    "from copy import deepcopy\n",
    "\n",
    "def add_axis_bounds_single_phase_zpf_lines(strategy: TernaryStrategy):\n",
    "        \"\"\"Take a strategy and step along the edges (like in starting point generation)\n",
    "        and add all the _single phase_ segments to a new attribute of the strategy, `single_phase_lines` (modifies the input strategy).\n",
    "        \"\"\"\n",
    "        strategy.single_phase_lines = []\n",
    "        map_kwargs = strategy._constant_kwargs()\n",
    "        # Iterate through axis variables, and set conditions to fix axis variable at min only\n",
    "        for av in strategy.axis_vars:\n",
    "            conds = deepcopy(strategy.conditions)\n",
    "            conds[av] = np.amin(strategy.axis_lims[av])\n",
    "\n",
    "            # Adjust composition conditions to be slightly above 0 for numerical stability\n",
    "            if isinstance(av, v.X):\n",
    "                if conds[av] == 0:\n",
    "                    conds[av] = MIN_COMPOSITION\n",
    "\n",
    "            # Step map\n",
    "            step = StepStrategy(strategy.dbf, strategy.components, strategy.phases, conds, **map_kwargs)\n",
    "            step.initialize()\n",
    "            step.do_map()\n",
    "\n",
    "            for zpf_line in step.zpf_lines:\n",
    "                if len(zpf_line.stable_phases) == 1:\n",
    "                    strategy.single_phase_lines.append(zpf_line)\n",
    "\n",
    "        # Additional step where we switch axis conditions to the unlisted variable\n",
    "        conds = deepcopy(strategy.conditions)\n",
    "        conds[strategy.all_vars[-1]] = MIN_COMPOSITION\n",
    "        del conds[strategy.axis_vars[0]]\n",
    "\n",
    "        # Step map\n",
    "        step = StepStrategy(strategy.dbf, strategy.components, strategy.phases, conds, **map_kwargs)\n",
    "        step.initialize()\n",
    "        step.do_map()\n",
    "\n",
    "        for zpf_line in step.zpf_lines:\n",
    "            if len(zpf_line.stable_phases) == 1:\n",
    "                strategy.single_phase_lines.append(zpf_line)\n",
    "\n",
    "def get_single_phase_data(strategy: MapStrategy, x, y):\n",
    "    \"\"\"Relies on having the strategy.single_phase_lines attribute defined, i.e. from add_axis_bounds_single_phase_zpf_lines\"\"\"\n",
    "    zpf_data = []\n",
    "    for zpf_line in strategy.single_phase_lines:\n",
    "        phases = zpf_line.stable_phases_with_multiplicity\n",
    "        phase_data = {}\n",
    "        for p in phases:\n",
    "            x_data = zpf_line.get_var_list(_get_phase_specific_variable(p, x))\n",
    "            y_data = zpf_line.get_var_list(_get_phase_specific_variable(p, y))\n",
    "            phase_data[p] = {\n",
    "                'x': x_data,\n",
    "                'y': y_data,\n",
    "                }\n",
    "        zpf_data.append(phase_data)\n",
    "    return zpf_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatures = np.arange(300, 2200, 100)\n",
    "temperatures = np.arange(300, 2200, 50)\n",
    "ternary_strategies = []\n",
    "\n",
    "for T in temperatures:\n",
    "    conditions[v.T] = T\n",
    "    strat = TernaryStrategy(dbf, components, phases, conditions)\n",
    "    strat.initialize()\n",
    "    strat.do_map()\n",
    "    add_axis_bounds_single_phase_zpf_lines(strat)  # adds single_phase_lines to strat\n",
    "    ternary_strategies.append(strat)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "from typing import Any\n",
    "from numpy.typing import ArrayLike\n",
    "\n",
    "def distance(xy_point: ArrayLike, other: ArrayLike):\n",
    "    return np.sqrt(np.sum(np.square(xy_point - other)))\n",
    "\n",
    "from functools import total_ordering\n",
    "\n",
    "@total_ordering\n",
    "class DistanceWrapper():\n",
    "    \"\"\"Wrap objects with a 'distance', but have them compare based on the distance\"\"\"\n",
    "    obj: Any\n",
    "    d: float\n",
    "\n",
    "    def __init__(self, obj: Any, d: float, **kwargs):\n",
    "        self.obj = obj\n",
    "        self.d = d\n",
    "        # accept arbitrary other input\n",
    "        for k, v in kwargs.items():\n",
    "            setattr(self, k, v)\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        return self.d == other.d\n",
    "\n",
    "    def __lt__(self, other):\n",
    "        return self.d < other.d\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class PolyData3D():\n",
    "    \"\"\"\n",
    "    PolyData3D is a data structure that has the boundary curve xy data, phases, and\n",
    "    ability to and compute the mass centroid of the shape. We use the latter two pieces\n",
    "    of information to identify similar phase regions across temperatures, with the phase\n",
    "    label being primary and centroids disambiguating any ties.\n",
    "    \"\"\"\n",
    "    _xyz_data: ArrayLike  # Nx3 array of vertices making up the boundary of the polygon\n",
    "    phases: set[str]\n",
    "\n",
    "    @classmethod\n",
    "    def from_tieline_data(cls, tieline_data: dict[str, dict[str, ArrayLike]], temperature: float):\n",
    "        # Tie-line data is a single line from strat.get_tieline_data(x, y)\n",
    "        phases = set()\n",
    "        xs = []\n",
    "        ys = []\n",
    "        for i, (phase_name, xy_dict) in enumerate(tieline_data.items()):\n",
    "            # assumes tieline_data phases are phase names _with multiplicity_\n",
    "            phases.add(phase_name)\n",
    "            # reverse every other phase so that ends connect to ends\n",
    "            if i % 2 == 0:\n",
    "                xs.extend(reversed(xy_dict[\"x\"]))\n",
    "                ys.extend(reversed(xy_dict[\"y\"]))\n",
    "            else:\n",
    "                xs.extend(xy_dict[\"x\"])\n",
    "                ys.extend(xy_dict[\"y\"])\n",
    "\n",
    "\n",
    "        # here we assume that we need to close the polygon ourselves, so we add a matching endpoint as the startpoing\n",
    "        # for matplotlib.patches.Polygon, we _don't_ need to close the polygon ourselves\n",
    "        xs.append(xs[0])\n",
    "        ys.append(ys[0])\n",
    "\n",
    "        assert len(xs) == len(ys)\n",
    "        N = len(xs)\n",
    "        xyz_data = np.empty((N, 3))\n",
    "        xyz_data[:, 0] = xs\n",
    "        xyz_data[:, 1] = ys\n",
    "        xyz_data[:, 2] = temperature\n",
    "\n",
    "        return cls(xyz_data, phases)\n",
    "\n",
    "    @classmethod\n",
    "    def from_invariant_data(cls, invariant_data: dict[str, list[str] | ArrayLike], temperature: float):\n",
    "        # Tie-line data is a single line from strat.get_invariant_data(x, y)\n",
    "        phases = set(invariant_data[\"phases\"])\n",
    "        xs = invariant_data[\"x\"]\n",
    "        ys = invariant_data[\"y\"]\n",
    "\n",
    "        # here we assume that we need to close the polygon ourselves, so we add a matching endpoint as the startpoing\n",
    "        # for matplotlib.patches.Polygon, we _don't_ need to close the polygon ourselves\n",
    "        xs.append(xs[0])\n",
    "        ys.append(ys[0])\n",
    "\n",
    "        assert len(xs) == len(ys)\n",
    "        N = len(xs)\n",
    "        xyz_data = np.empty((N, 3))\n",
    "        xyz_data[:, 0] = xs\n",
    "        xyz_data[:, 1] = ys\n",
    "        xyz_data[:, 2] = temperature\n",
    "\n",
    "        return cls(xyz_data, phases)\n",
    "\n",
    "    def get_phases_label(self, separator=\"+\"):\n",
    "        return separator.join(sorted(self.phases))\n",
    "\n",
    "    @property\n",
    "    def num_vertices(self):\n",
    "        return self._xyz_data.shape[0]\n",
    "\n",
    "    @property\n",
    "    def x(self):\n",
    "        return self._xyz_data[:,0]\n",
    "\n",
    "    @property\n",
    "    def y(self):\n",
    "        return self._xyz_data[:,1]\n",
    "\n",
    "    @property\n",
    "    def z(self):\n",
    "        return self._xyz_data[:,2]\n",
    "\n",
    "    @property\n",
    "    def xy(self):\n",
    "        return self._xyz_data[:,0:2]\n",
    "\n",
    "    @property\n",
    "    def xyz(self):\n",
    "        return self._xyz_data\n",
    "\n",
    "    @property\n",
    "    def area_2d(self):\n",
    "        # this function assumes that the vertices are closed (i.e. index 0 == index n)\n",
    "        # shoelace formula, https://en.wikipedia.org/wiki/Centroid#Of_a_polygon\n",
    "        # the sign of the area indicates whether points are wound clockwise or counterclockwise\n",
    "        return np.sum(self.x[:-1] * self.y[1:] - self.x[1:] * self.y[:-1]) / 2\n",
    "\n",
    "    @property\n",
    "    def centroid_2d(self):\n",
    "        # this is the mass centroid\n",
    "        # this function assumes that the vertices are closed (i.e. index 0 == index n)\n",
    "        # see https://en.wikipedia.org/wiki/Centroid#Of_a_polygon\n",
    "        # this is actually quite an interesting topic for the general case:\n",
    "        # see https://www.spatialanalysisonline.com/HTML/centroids_and_centers.htm\n",
    "        # and https://paulbourke.net/geometry/polygonmesh/\n",
    "        A = self.area_2d\n",
    "        x = self.x\n",
    "        y = self.y\n",
    "        Cx = np.sum((x[:-1] + x[1:]) * (x[:-1] * y[1:] - x[1:] * y[:-1])) / (6 * A)\n",
    "        Cy = np.sum((y[:-1] + y[1:]) * (x[:-1] * y[1:] - x[1:] * y[:-1])) / (6 * A)\n",
    "        return np.array([Cx, Cy])\n",
    "\n",
    "    def distance(self, other: \"PolyData3D\") -> float | None:\n",
    "        \"\"\"Considers phase labels and centroid distance.\n",
    "\n",
    "        Non-matching phases yield None\n",
    "        \"\"\"\n",
    "        if self.phases == other.phases:\n",
    "            return distance(self.centroid_2d, other.centroid_2d)\n",
    "        else:\n",
    "            return None\n",
    "\n",
    "    def distances(self, others: list[\"PolyData3D\"]) -> list[\"PolyData3D\"]:\n",
    "        # get DistanceWrappres for all others that have real (non-None) distances\n",
    "        wrapped_distances = filter(lambda dw: dw.d is not None, (DistanceWrapper(other, self.distance(other), index=i) for i, other in enumerate(others)))\n",
    "        return [(distance_wrapper.index, distance_wrapper.obj) for distance_wrapper in sorted(wrapped_distances)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# but first we get sidetracked into one phase region making\n",
    "\n",
    "import re\n",
    "import itertools\n",
    "\n",
    "\n",
    "def line_matches(xy_this_line, xy_other_line, distance_tol=1e-2):\n",
    "    this_start = xy_this_line[0, :]\n",
    "    this_end = xy_this_line[-1, :]\n",
    "    other_start = xy_other_line[0, :]\n",
    "    other_end = xy_other_line[-1, :]\n",
    "\n",
    "    if (distance(this_start, other_start) < distance_tol) and (distance(this_end, other_end) < distance_tol):\n",
    "        # line segments have matching endpoints, assume that they describe the same thing\n",
    "        return True\n",
    "    elif (distance(this_start, other_end) < distance_tol) and (distance(this_end, other_start) < distance_tol):\n",
    "        # line segments have matching endpoints, assume that they describe the same thing\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "\n",
    "def get_opf_segments(tieline_data, distance_tol=1e-2):\n",
    "    # extract individual one-phase segments from tie-lines and correct for phase name multiplicity\n",
    "    opf_segments: list[tuple[str, ArrayLike]] = []\n",
    "    for tieline in tieline_data:\n",
    "        for phase_name, xy_dict in tieline.items():\n",
    "            # each line can have a multiplicity label which is meaningless for a single phase region\n",
    "            # assume that multiplicity label starts with a #, it is the only #:\n",
    "            phase_name = re.match(\"([^#]+)\", phase_name).group(0)\n",
    "            xs = xy_dict[\"x\"]\n",
    "            ys = xy_dict[\"y\"]\n",
    "            assert len(xs) == len(ys)\n",
    "            xy = np.empty((len(xs), 2))\n",
    "            xy[:,0] = xs\n",
    "            xy[:,1] = ys\n",
    "            # mapping can sometimes double count lines, ensure that we don't double add them here\n",
    "            # if we double count, it can cause issues when joining segments later\n",
    "            found_match = False\n",
    "            for other_phase, other_xy in opf_segments:\n",
    "                if other_phase == phase_name:\n",
    "                    if line_matches(xy, other_xy, distance_tol=distance_tol):\n",
    "                        found_match = True\n",
    "            if not found_match:\n",
    "                opf_segments.append((phase_name, xy))\n",
    "    return opf_segments\n",
    "\n",
    "def merge_opf_segments(opf_segments: list[tuple[str, ArrayLike]]) -> list[tuple[str, ArrayLike]]:\n",
    "    # Merge opf segments by matching their starts or ends\n",
    "    # Assumes the phase names have no multiplicity\n",
    "    joined_opf_lines: list[tuple[str, ArrayLike]] = opf_segments\n",
    "    found_new_joins = True\n",
    "    DISTANCE_TOL = 1e-2  # if the Euclidean distance is below this tolerance, join the lines\n",
    "    while found_new_joins:\n",
    "        # If we find a new join this iteration, there might be one next iteration too,\n",
    "        # so we need to keep looping until we stop finding joins\n",
    "        joined_indices = set()\n",
    "        found_new_joins = False\n",
    "        new_joined_opf_lines: list[tuple[str, ArrayLike]] = []\n",
    "        num_opf_segments = len(joined_opf_lines)\n",
    "        # here we do a breadth-first kind of search, where as soon as one new join is found,\n",
    "        # we go to the next loop. this allow for the least amount of bookkeeping as to\n",
    "        # whether we join starts and ends and which new starts/ends are available for joining\n",
    "        for i in range(num_opf_segments):\n",
    "            phase_i, xy_i = joined_opf_lines[i]\n",
    "            if found_new_joins:\n",
    "                # breadth-first\n",
    "                if i not in joined_indices:\n",
    "                    # make sure we keep the indices we didn't join\n",
    "                    new_joined_opf_lines.append((phase_i, xy_i))\n",
    "                continue\n",
    "            for j in range(i+1, num_opf_segments):\n",
    "                if found_new_joins:\n",
    "                    # breadth-first\n",
    "                    break\n",
    "                phase_j, xy_j = joined_opf_lines[j]\n",
    "                if phase_i != phase_j:\n",
    "                    # Different phases can't be on the same OPF line\n",
    "                    continue\n",
    "                i_start = xy_i[ 0,:]\n",
    "                i_end   = xy_i[-1,:]\n",
    "                j_start = xy_j[ 0,:]\n",
    "                j_end   = xy_j[-1,:]\n",
    "                if distance(i_start, j_start) < DISTANCE_TOL:\n",
    "                    # join as (i_end, i_start) (j_start, j_end)\n",
    "                    new_xy = np.concat([xy_i[::-1,:], xy_j[:,:]], axis=0)\n",
    "                    new_joined_opf_lines.append((phase_i, new_xy))\n",
    "                    joined_indices.update({i, j})\n",
    "                    found_new_joins = True\n",
    "                elif distance(i_start, j_end) < DISTANCE_TOL:\n",
    "                    # join as (i_end, i_start) (j_end, j_start)\n",
    "                    new_xy = np.concat([xy_i[::-1,:], xy_j[::-1,:]], axis=0)\n",
    "                    new_joined_opf_lines.append((phase_i, new_xy))\n",
    "                    joined_indices.update({i, j})\n",
    "                    found_new_joins = True\n",
    "                elif distance(i_end, j_start) < DISTANCE_TOL:\n",
    "                    # join as (i_start, i_end) (j_start, j_end)\n",
    "                    new_xy = np.concat([xy_i[:,:], xy_j[:,:]], axis=0)\n",
    "                    new_joined_opf_lines.append((phase_i, new_xy))\n",
    "                    joined_indices.update({i, j})\n",
    "                    found_new_joins = True\n",
    "                elif distance(i_end, j_end) < DISTANCE_TOL:\n",
    "                    # join as (i_start, i_end) (j_end, j_start)\n",
    "                    new_xy = np.concat([xy_i[:,:], xy_j[::-1,:]], axis=0)\n",
    "                    new_joined_opf_lines.append((phase_i, new_xy))\n",
    "                    joined_indices.update({i, j})\n",
    "                    found_new_joins = True\n",
    "            if not found_new_joins:\n",
    "                # no matches, so append this i\n",
    "                new_joined_opf_lines.append((phase_i, xy_i))\n",
    "        joined_opf_lines = new_joined_opf_lines\n",
    "    return joined_opf_lines\n",
    "\n",
    "def distance_point_to_vertices(p: ArrayLike, v1: ArrayLike, v2: ArrayLike):\n",
    "    x0, y0 = p[:]\n",
    "    x1, y1 = v1[:]\n",
    "    x2, y2 = v2[:]\n",
    "    # distance of point (x0, y0) to the line passing through (x1, y1) and (x2, y2)\n",
    "    # https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line#Line_defined_by_two_points\n",
    "    return np.abs((y2-y1)*x0 - (x2-x1)*y0 + x2*y1 - y2*x1) / np.sqrt((y2 - y1)**2 + (x2 - x1)**2)\n",
    "\n",
    "\n",
    "def find_nearest_axis_for_point(point, axes_vertices: ArrayLike, start_tol=1e-2, maxiters=10):\n",
    "    axes_as_vertex_index_pairs = list(itertools.combinations(range(axes_vertices.shape[0]), 2))\n",
    "    tol = start_tol\n",
    "    nearest_axis_indices = set()\n",
    "    # try binary search for nearest axis\n",
    "    for iter in range(maxiters):\n",
    "        cur_nearest_axis_indices = set()\n",
    "        for axis_index, (ax_i, ax_j) in enumerate(axes_as_vertex_index_pairs):\n",
    "            ax_v1 = axes_vertices[ax_i, :]\n",
    "            ax_v2 = axes_vertices[ax_j, :]\n",
    "            if distance_point_to_vertices(point, ax_v1, ax_v2) < tol:\n",
    "                cur_nearest_axis_indices.add(axis_index)\n",
    "        if len(cur_nearest_axis_indices) == 1:\n",
    "            return cur_nearest_axis_indices\n",
    "        elif len(cur_nearest_axis_indices) == 0:\n",
    "            tol *= 1.5\n",
    "        else:\n",
    "            # set our best nearest_axis_indices to our current set, so we can at least return something\n",
    "            nearest_axis_indices = cur_nearest_axis_indices\n",
    "            tol /= 2.0\n",
    "    return nearest_axis_indices\n",
    "\n",
    "\n",
    "def find_shared_axis_and_vertex(phase_name: str, start_point: ArrayLike, end_point: ArrayLike, axes_vertices: ArrayLike, distance_tol=1e-2):\n",
    "    \"\"\"\n",
    "    start_point : shape (2,) array\n",
    "    end_point : shape (2,) array\n",
    "    axes_vertices : Nx2 array like for N vertices\n",
    "    \"\"\"\n",
    "    axes_as_vertex_index_pairs = list(itertools.combinations(range(axes_vertices.shape[0]), 2))\n",
    "    axes_indices_start_is_close_to = find_nearest_axis_for_point(start_point, axes_vertices, distance_tol)\n",
    "    axes_indices_end_is_close_to = find_nearest_axis_for_point(end_point, axes_vertices, distance_tol)\n",
    "\n",
    "    # for this segment, we now know which axes the start and end is close to\n",
    "    close_axes_union = tuple(axes_indices_start_is_close_to.union(axes_indices_end_is_close_to))\n",
    "    close_axes_intersection = tuple(axes_indices_start_is_close_to.intersection(axes_indices_end_is_close_to))\n",
    "    # for compositions near corners, we might be close to two axes and our union size\n",
    "    # ends up being 2 (or 3 if the segment is corner-to-corner), so we just check for a\n",
    "    # single intersection\n",
    "    if len(close_axes_intersection) == 1: #  and len(close_axes_union) == 1:\n",
    "        # segment starts and ends at one shared axis, consider this closed (PolyData3D will properly \"close\" by appending the start point)\n",
    "        shared_axis_index = close_axes_intersection[0]\n",
    "        return shared_axis_index, None\n",
    "    elif len(close_axes_intersection) == 0 and len(close_axes_union) == 2:\n",
    "        # two different axes are touched by this line\n",
    "        # we need to figure out which vertex is shared and add that to the line\n",
    "        axis_1_vertex_indices = set(axes_as_vertex_index_pairs[close_axes_union[0]])\n",
    "        axis_2_vertex_indices = set(axes_as_vertex_index_pairs[close_axes_union[1]])\n",
    "        shared_vertex_index = tuple(axis_1_vertex_indices.intersection(axis_2_vertex_indices))\n",
    "        assert len(shared_vertex_index) == 1, f\"shared_vertex_index {shared_vertex_index}\"\n",
    "        shared_vertex_index = shared_vertex_index[0]\n",
    "        return None, shared_vertex_index\n",
    "    else:\n",
    "        print(f\"Not sure what to do for phase {phase_name}. Got start {start_point} and end {end_point} for segment and the ends are close to the following axes: {axes_indices_start_is_close_to} and {axes_indices_end_is_close_to}\")\n",
    "        return None, None\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_3d_poly_data(strat: TernaryStrategy, x, y, include_single_phase=True, include_tielines=True, include_invariants=True):\n",
    "    poly_data = []\n",
    "    temperature = float(strat.conditions[v.T])\n",
    "\n",
    "    if include_single_phase:\n",
    "        opf_segments = get_opf_segments(strat.get_tieline_data(x, y))\n",
    "        if hasattr(strat, \"single_phase_lines\"):\n",
    "            # we added this for the lines at the edges of the diagram\n",
    "            opf_segments.extend(get_opf_segments(get_single_phase_data(strat, x, y)))\n",
    "        opf_segments = merge_opf_segments(opf_segments)\n",
    "        for phase_name, xy in opf_segments:\n",
    "            xyz = np.concat([xy, np.full((xy.shape[0], 1), temperature)], axis=1)\n",
    "            pd = PolyData3D(xyz, {phase_name})\n",
    "            poly_data.append(pd)\n",
    "\n",
    "    if include_tielines:\n",
    "        for line in strat.get_tieline_data(x, y):\n",
    "            pd = PolyData3D.from_tieline_data(line, temperature)\n",
    "            poly_data.append(pd)\n",
    "\n",
    "    if include_invariants:\n",
    "        for invariant in strat.get_invariant_data(x, y):\n",
    "            pd = PolyData3D.from_invariant_data(invariant, temperature)\n",
    "            poly_data.append(pd)\n",
    "\n",
    "    # TODO: duplicate detection based on phase label and centroid?\n",
    "    # see https://en.wikipedia.org/wiki/Centroid#Of_a_polygon\n",
    "    # this is actually quite an interesting topic for the general case: https://www.spatialanalysisonline.com/HTML/centroids_and_centers.htm\n",
    "    return poly_data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "strat = ternary_strategies[14]\n",
    "poly_data = get_3d_poly_data(strat, v.X(\"NI\"), v.X(\"CR\"), include_single_phase=True)\n",
    "\n",
    "# Plot\n",
    "from pycalphad.plot.utils import phase_legend\n",
    "handles, colorlist = phase_legend(sorted(set(map(PolyData3D.get_phases_label, poly_data))))\n",
    "\n",
    "plot_ternary(strat)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import patches\n",
    "fig, ax = plt.subplots(subplot_kw=dict(projection=\"triangular\"))\n",
    "for pd in poly_data:\n",
    "    polygon = patches.Polygon(pd.xy, closed=True, edgecolor=colorlist[pd.get_phases_label()], facecolor=colorlist[pd.get_phases_label()])\n",
    "    ax.add_patch(polygon)\n",
    "    ax.scatter(pd.centroid_2d[0], pd.centroid_2d[1], c='k', s=2, label='centroids')\n",
    "    ax.legend(handles=handles, loc=\"center left\", bbox_to_anchor=(1, 0.5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/hb/yhrcbqxx4kx8ywp_8nvb50pm0000gn/T/ipykernel_52563/1626011258.py:139: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  Cx = np.sum((x[:-1] + x[1:]) * (x[:-1] * y[1:] - x[1:] * y[:-1])) / (6 * A)\n",
      "/var/folders/hb/yhrcbqxx4kx8ywp_8nvb50pm0000gn/T/ipykernel_52563/1626011258.py:140: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  Cy = np.sum((y[:-1] + y[1:]) * (x[:-1] * y[1:] - x[1:] * y[:-1])) / (6 * A)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo0AAAGzCAYAAABKNS0NAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACkE0lEQVR4nOzdd1xV9f/A8de5bJkiCjjRcJTmyIFWlv7UcFuZooYolntj4p6pOEr9lpqlIJrmKGdalpGWpuUkrZzlSAMVFRCQde/5/UHcRNYFLlzG+/l43Mf36zmfc877EuN9P+P9UVRVVRFCCCGEECIHGlMHIIQQQgghij9JGoUQQgghRK4kaRRCCCGEELmSpFEIIYQQQuRKkkYhhBBCCJErSRqFEEIIIUSuJGkUQgghhBC5kqRRCCGEEELkSpJGIYQQQgiRK0kahRBCCCFEriRpFKWeoigGvQ4dOlRkMW3bto2WLVvi5OREhQoVePnll9m3b1+mdjqdjsWLF1OzZk2sra1p2LAhmzdvzvKe58+fp2PHjtjZ2eHs7Ez//v25e/euQfEoisKoUaMyHV+wYAGKojBo0CB0Ol3e3qQQQohSxdzUAQhR2D799NMM/96wYQMHDhzIdPzpp58ukng+/PBDxowZQ5cuXVi4cCGJiYmEhobStWtXtm/fzuuvv65vO23aNBYuXMjgwYNp3rw5u3fvpl+/fiiKQp8+ffTtbt68yUsvvYSjoyMLFiwgLi6O9957j3PnznH8+HEsLS3zHOfChQuZNm0aAwYMYO3atWg08hlTCCHKNFWIMmbkyJGqKb/1a9eurTZv3lzV6XT6YzExMaqdnZ3avXt3/bGbN2+qFhYW6siRI/XHdDqd2rp1a7Vq1apqamqq/vjw4cNVGxsb9fr16/pjBw4cUAH1448/zjUmIMNzFi9erAKqn5+fqtVq8/1ehRBClB7SdSBEEYuNjaVSpUooiqI/5uDggJ2dHTY2Nvpju3fvJiUlhREjRuiPKYrC8OHDuXnzJseOHdMf3759O127dqV69er6Y+3bt6dOnTps27YtT/EtXbqUwMBAfH19WbdunfQwCiGEAGR4WgiDxMTEkJKSkms7a2tr7OzscmzTpk0bvvjiCz788EO6detGYmIiH374ITExMYwdO1bf7syZM9ja2mYaNm/RooX+/IsvvsitW7e4c+cOzZo1y/SsFi1a8NVXXxnyFgH43//+x4QJE+jXrx+hoaGSMAohhNCTpFEIA/To0YMffvgh13YDBgwgNDQ0xzYffPABUVFRjBkzhjFjxgDg4uJCWFgYrVq10reLiIjA1dU1Q48kgLu7OwD//POPvt3jx59se//+fZKSkrCyssoxrr1793L9+nX69u3Lhg0bMDMzy/nNCiGEKFMkaRTCAO+//z4PHjzItV3lypVzbVOuXDnq1q1L1apV6dq1Kw8fPmTZsmW8/vrrHD58GE9PTwAePXqUZaJnbW2tP//4/+bWNrek8fbt2wDUrFlTEkYhhBCZSNIohAGaNm1qtHv16tULc3NzvvzyS/2xHj16ULt2baZNm8bWrVsBsLGxISkpKdP1iYmJ+vOP/68hbXMyYMAA/vnnHxYsWICLiwvjx4/P4zsTQghRmknSKIQB7t+/T3Jycq7tbGxscHR0zPb8X3/9xf79+/nkk08yHHd2dubFF1/kp59+0h9zd3fn4MGDqKqaYYg6fTg6vVczfVg6/fjjIiIicHZ2zrWXEcDc3Jxt27bRsWNHJkyYgJOTE/7+/rleJ4QQomyQWe5CGOD111/H3d0919fjC1mykj4ErNVqM51LSUkhNTVV/+/GjRuTkJDA+fPnM7T75Zdf9OcBqlSpQsWKFTl58mSmex4/flzfzhDW1tbs2bOHJk2aMHjwYHbu3GnwtUIIIUo36WkUwgDGmtPo6emJRqNh69atDB06VN+DePPmTQ4fPsyLL76ob9ujRw/Gjx/PqlWrWLFiBQCqqrJ69WqqVKnC888/r2/bs2dP1q9fz99//021atUACAsL49KlS3keZnZwcGD//v20bt2avn37sm/fPtq1a5enewghhCh9JGkUwgDGmtNYsWJFBg0axNq1a2nXrh2vv/46Dx8+ZNWqVTx69IgpU6bo21atWpVx48axZMkSUlJSaN68Obt27eLw4cNs2rQpw2KVqVOn8vnnn9O2bVvGjh1LXFwcS5Ys4dlnn83XEHPFihU5cOAAL7zwAq+++iphYWH6Uj9CCCHKJkkahShiH330EY0aNSI4OFifJDZv3pwNGzbw0ksvZWi7cOFCypcvz8cff0xoaCi1a9dm48aN9OvXL0O7atWq8cMPPxAQEMDkyZOxtLSkS5cuvP/++wbNZ8xKtWrV+Pbbb2ndujWdOnXixx9/pH79+vl700IIIUo8RVVV1dRBCCGEEEKI4k0WwgghhBBCiFxJ0iiEEEIIIXIlSaMQQgghhMiVJI1CCCGEECJXkjQKIYQQQohcSdIohBBCCCFyJUmjEEIIIYTIlSSNQgghhBAiV5I0CiGEEEKIXEnSKIQQQgghciVJoxBCCCGEyJUkjUIIIYQQIleSNAohhBBCiFxJ0iiEEEIIIXIlSaMQQgghhMiVJI1CCCGEECJXkjQKIYQQQohcSdIohBBCCCFyJUmjEEIIIYTIlSSNQgghhBAiV5I0CiGEEEKIXEnSKIQQQgghciVJoxBCCCGEyJUkjUIIIYQQIleSNAohhBBCiFxJ0iiEEEIIIXIlSaMQQgghhMiVJI1CCCGEECJXkjQKIYQQQohcSdIohBBCCCFyJUmjEEIIIYTIlSSNQgghhBAiV5I0CiGEEEKIXEnSKIQQQgghciVJoxBCCCGEyJUkjUIIIYQQIleSNAohhBBCiFxJ0iiEEEIIIXIlSaMQQgghhMiVJI1CCCGEECJXkjQKIYQQQohcSdIohBBCCCFyJUmjEEIIIYTIlSSNQgghhBAiV5I0CiGEEEKIXEnSKIQQQgghciVJoxBCCCGEyJUkjUIIIYQQIleSNAohhBBCiFxJ0iiEEEIIIXIlSaMQQgghhMiVJI1CPObHH3+kW7duVK5cGUVR2LVrV67XHDp0iOeeew4rKys8PT0JDQ0t9DiFEEKIoiZJoxCPiY+Pp1GjRqxcudKg9levXqVLly60bduW8PBwxo0bx9tvv80333xTyJEKIYQQRUtRVVU1dRBCFEeKorBz505effXVbNtMmjSJffv28dtvv+mP9enTh+joaPbv318EUQohhBBFQ3oahSiAY8eO0b59+wzHvL29OXbsmIkiEkIIIQqHJI1CFEBkZCSurq4Zjrm6uhIbG8ujR4+yvCYpKYnY2Fj96++//2b06NFotdqiCFkIIYTIF0kahShiQUFBODo66l/Vq1dnxYoV0jsphBCiWJOkUYgCcHNz4/bt2xmO3b59GwcHB2xsbLK8ZsqUKcTExBATE8PVq1cpZ1eON9pDwLhh6HS6oghbCCGEyDNJGoUogFatWhEWFpbh2IEDB2jVqlW211hZWeHg4ICDgwNBCxfRskEiq6ZDxK2LbNiwobBDFkIIIfJFkkYhHhMXF0d4eDjh4eFAWkmd8PBwbty4AaT1Evr5+enbDxs2jL/++ovAwEAuXLjAqlWr2LZtG+PHj8/1Wb/99hvrQtawaKyOctYwb2QqUyeP5+HDh4Xy3oQQQoiCkKRRiMecPHmSJk2a0KRJEwACAgJo0qQJM2fOBCAiIkKfQALUrFmTffv2ceDAARo1asT777/P2rVr8fb2zvE5qqoydPgwhvTU8nTNtGM924OH+0MWzJ9XOG9OCCGEKACp0yiECezevRs/vzf47YtUnB3+Ox5+AToMM+e33y9Sq1Yt0wUohBBCPEGSRiGKWFJSErU8axHY7x/efj3z+ZELNMRqOrFj596iD04IIYTIhgxPC1HEli5dhr3lHfx7ZH1+5lAdYd/t5/vvvy/awIQQQogcSE+jEEUoMjKSmrU8+OK9ZNo0zf5H73+bYMv3T3E6/ALm5uZFGKEQQgiRNelpFKIITZg4kVdapuSYMAIM7w2PHl7j448/LqLIhBBCiJxJT6MQReTkyZO88EJLTm7WUqtK7u2/OgzDF9hy+c+/KV++fOEHKIQQQuRAehqFKAKqqjJ42BDG9jMsYQTo9CI0rpPI7NkzCjc4IYQQwgDS0yhEEdi8eTNjRvvx+xep2Ga9u2CWzl+F1gPNOHX6LM8880zhBSiEEELkQpJGIQpZfHw8HrVqsGD4Pfp1yvv1E5cqXLnfmm++PYSiKMYPUAghhDCADE8LUcgWLAiimks0fTvm7/qpb6ucPvkT+/btM25gQgghRB5IT6MQhej69evUqVub/StTadEg/z9qn3wBH+2swm9//IWlpaURIxRCCCEMIz2NQhSisePH8fr/FSxhBBj0KlgQyQcf/M84gQkhhBB5JD2NQhSSw4cP88orbTn7uZbKFQt+v4Mn4M2pVly6fB1XV9eC31AIIYTIA+lpFKIQaLVaBg8dwqSBxkkYAdo2h5ebpjJt6iTj3FAIIYTIA0kahSgEwcHBxD24wui+xr3vgtFaPvtsI6dPnzbujYUQQohcyPC0EEYWExNDdY9qrJoUx6ttjf/jNfsjhWOXn+PwkRNSgkcIIUSRkZ5GIYxs1uzZNKgZT482hfN5bIKfypVL4Xz++eeFcn8hhBAiK9LTKIQRXbp0iQbPPsOhYC2Nahfeczbtg/nrXDh/8TrlypUrvAcJIYQQ/5KeRiGMaMSokfh1LdyEEaBvJ6jo8IAlSxYV7oOEEEKIf0lPoxBGsn//fnr16sZvX6Ti4lT4z/vlHHQbY8GFi39SrVq1wn+gEEKIMk2SRiGMICUlBc86tRn12nVG+BTdc9+erQHHV9m8ZXvRPVQIIUSZJMPTQhjBhx+uwFx3k8E9i/a5c0fo+PLL3fz0009F+2AhhBBljiSNotRYuXIlHh4eWFtb4+XlxfHjx7Ntm5KSwty5c3nqqaewtramUaNG7N+/P1/PjYqKYuasaSwZp8PCPL/R50/lShDgq2Xs6MHodLqifbgQQogyRZJGUSps3bqVgIAAZs2axenTp2nUqBHe3t7cuXMny/bTp0/n448/5sMPP+SPP/5g2LBhvPbaa5w5cybPz548ZQovNEzC+3nTzPQY0w/uRl5i3bp1Jnm+EEKIskHmNIpSwcvLi+bNm7NixQoAdDod1apVY/To0UyePDlT+8qVKzNt2jRGjhypP9azZ09sbGzYuHGjwc89e/YszZs/x8+faqlTo+DvI792fg/vLHPg0pW/cXBwMF0gQgghSi3paRQlXnJyMqdOnaJ9+/b6YxqNhvbt23Ps2LEsr0lKSsLa2jrDMRsbG44cOWLwc1VVZcjwoQzrZdqEEeDVtlC7Wjzz3p1r2kCEEEKUWpI0ihIvKioKrVaLq6trhuOurq5ERkZmeY23tzdLly7l8uXL6HQ6Dhw4wI4dO4iIiMj2OUlJScTGxupfmzZt4uLvJ5k8yKhvJ18UBRaP0/Lhh8u5cuWKqcMRQghRCknSKMqk//3vf9SuXZt69ephaWnJqFGj8Pf3R6PJ/kciKCgIR0dH/at///60fDYVB9siDDwHDetA304qEwJGmToUIYQQpZAkjaLEc3FxwczMjNu3b2c4fvv2bdzc3LK8pmLFiuzatYv4+HiuX7/OhQsXsLOzo1atWtk+Z8qUKcTExBATE8O06dOpV8uMDe8a9a0U2MyhOn449B0HDhwwdShCCCFKGUkaRYlnaWlJ06ZNCQsL0x/T6XSEhYXRqlWrHK+1tramSpUqpKamsn37dnr06JFtWysrKxwcHIiLi+P99xezbKKOcjZGextGUbE8TBmkZdyYIaSmppo6HCGEEKWIJI2iVAgICGDNmjWsX7+e8+fPM3z4cOLj4/H39wfAz8+PKVOm6Nv/8ssv7Nixg7/++ovDhw/TsWNHdDodgYGBuT5r/IQJdHo+hdZNimfhgSFvQOqjm3z00UemDkUIIUQpUsSliIUoHD4+Pty9e5eZM2cSGRlJ48aN2b9/v35xzI0bNzLMV0xMTGT69On89ddf2NnZ0blzZz799FOcnJxyfM4vv/zC7p2fc3pL8UwYASwtIGhsKm/PnEy/fv2oUKGCqUMSQghRCkidRiEMpNPpaNykEZ2b/caMIaaOJnevB5hRu8lgVqyQHkchhBAFJ8PTQhho48aN3Lv8B+NdrXNvXAwEjdESvHYNv/32m6lDEUIIUQpIT6MQBoiLi6NG5SoscdfRa1AqmjaJpg7JIJOXK/xx+3m+CzuMoiimDkcIIUQJJj2NQhhg3rz5eGgf0bOCJYqL1tThGGzyWypnw39mz549pg5FCCFECSc9jULk4urVq9SrXYdvn7Glib05mknRKK4lJ3EM3gkfbHPn9/NXsbKyMnU4QgghSijpaRQiF6NHjaGLpSVN7M1BUaFCyUkYAQZ2BxvzOyxfvszUoQghhCjBpKdRiBwcOnSITu06cOJpB6o7KuCow2zWA1OHlWc/ngKfSZZcunw9211yhBBCiJxIT6MQ2dBqtbw96G3eNrNNSxgBKpWsXsZ0LzWFdi1SmTJ5oqlDEUIIUUJJ0ihENj755BPir99keBVrVBXQgFJCk0aA+aN0bN26mRMnTpg6FCGEECWQDE8LkYXo6GiqV67G5Ec2DG+hw8wcUFSU7gloXi4Z5XayMmc1HLnQmJ+OnpYSPEIIIfJEehqFyML06dPxTNTRubxFWsIIoCooFUtuTyPABD+49udvbNmyxdShCCGEKGGkp1GIJ1y4cIGG9RuwRufK/9VLxaG8lvROOc3kByiVdKYNsIC2fA2z1zhz4dINbG1tTR2OEEKIEkJ6GoV4wrDBw+iis6W2hXmGhDGt3E7JThgBentD5QoxLFoUZOpQhBBClCCSNArxmK+++opTR3/iLRwp75Ka8aSjimJmmriMSaOBxeO0vP/eIq5fv27qcIQQQpQQkjQK8a/k5GSGDRrMIJ0DDmio4JYCj68VqZSa7bUlTbP68GpbHRPfGWvqUIQQQpQQkjQK8a8PP/gA5c49emCPja0OaxvdfzmjWckut5OVOcN1fP3VXg4fPmzqUIQQQpQAshBGCODOnTvUruHB7EQHmmJDlZqJuLilZJjPqPRIQPNSyS23k5X31sPuo3U5cep3zMxKwdi7EEKIQiM9jUIA0yZPplGKGU2xQVFUnCs+ljBCqSi3k5VRfeBB1J8EBwebOhQhhBDFnCSNoswLDw9n44ZPGa51BMChfOp/tRkf51L6kkZrK1gwOpXpU98hJibG1OEIIYQoxiRpFGWaqqqMHjKU13V2VMECAOdKKWSatKGo4Fzyy+1kpdvL8LRHAnPnzDJ1KEIIIYoxSRpFmbZ9+3bOnwmnv+oAgLmFLmNtxnROpaPcTlYUJa0Ez6pVK7h06ZKpwxFCCFFMSdIoyqxHjx4RMGIkg1PtKffvj0Km2ozpXEtPuZ2sNKgNvl1VAsaPNHUoQgghiqmsZm4JUaRWrlzJkiVLiIyMpFGjRnz44Ye0aNEi2/bLly/no48+4saNG7i4uPDGG28QFBSEtbV1np773pIl2N5/iDeV/j2iZq7NCGnldkrhIpgnTR+so3Gvg+zfv5+OHTuaOhxRxqiqSmpqKlpt6f9ZE6I4sbCwMLh6hpTcESa1detW/Pz8WL16NV5eXixfvpzPP/+cixcvUqlSpUztP/vsMwYNGkRISAjPP/88ly5dYuDAgfTp04elS5ca/NybN29St9ZTLElxpgFpyaaNrZa6jRKyaK2ivB6P5sWk/L7NEmPVVgjZV52zv13BwsLC1OGIMiI5OZmIiAgSErL6+RNCFCZFUahatSp2dna5t5WkUZiSl5cXzZs3Z8WKFQDodDqqVavG6NGjmTx5cqb2o0aN4vz584SFhemPTZgwgV9++YUjR44Y/Nx+vXoTtWM/03UV9Mcy1WZ8jGZoLErdlDy8s5IpJRVa9Tdn6JjFjBs33tThiDJAp9Nx+fJlzMzMqFixIpaWlihZ/RAKIYxOVVXu3r1LQkICtWvXzrXHUYanhckkJydz6tQppkyZoj+m0Who3749x44dy/Ka559/no0bN3L8+HFatGjBX3/9xVdffUX//v0Nfu6xY8fYtXMnG3Ru+mNZ1mZ8XCkst5MVC3NYODaVgbOm4evbHxcXF1OHJEq55ORk/YfFcuXKmTocIcqcihUrcu3aNVJSUiRpFMVXVFQUWq0WV1fXDMddXV25cOFCltf069ePqKgoXnzxRf0cqGHDhjF16tQs2yclJZGU9N+wsk6nY+Tbg+mrs6fSY9/+2dZmBNCoUL50ltvJSvuW0OrZZGZMn8JHq9eYOhxRRmg0si5TCFPIS8++/JSKEuXQoUMsWLCAVatWcfr0aXbs2MG+fft49913s2wfFBSEo6Oj/lW+fHkun79AH9U+Q7ssazOmK69DKWM/KQvGaAkNXcfZs2dNHYoQQohiooz9KRTFiYuLC2ZmZty+fTvD8du3b+Pm5pblNTNmzKB///68/fbbPPvss7z22mssWLCAoKAgdLrMvYFTpkwhJiaGmJgYbt68SUUHR8ap5bF67Fs/29qM6VzLxtD042pXh6Fv6Bg7Zigy7VkIIQTI8LQwIUtLS5o2bUpYWBivvvoqkDZ8HBYWxqhRo7K8JiEhIdMwVvocjKySGysrK6ysrACYP28eleNTaI9ThjbZ1maEMlNuJyuB/iqNep1g586dvP7666YOR5RBN+7GEvXwUZE8y8XehuoVHYrkWUKUVJI0CpMKCAhgwIABNGvWjBYtWrB8+XLi4+Px9/cHwM/PjypVqhAUFARAt27dWLp0KU2aNMHLy4srV64wY8YMunXrluME3r/++osPli3jQ21FlAyFGLOpzZhOq5aZRTBPcrSD2cO0vBMwgs6dO+e5DqYQBXHjbix1x6wlMaVofv6sLcy4+MHbeUocBw4cyPr16/X/dnZ2pnnz5ixevJiGDRsCaR9m16xZQ3BwML///jvm5uZ4enri6+vLkCFD9It/YmNjWbRoEdu3b+fatWs4OTnRoEEDRowYwWuvvWbwvLPNmzfj6+vLsGHDWLlyZYZzhw4dYtmyZRw/fpzY2Fhq167NxIkTefPNNw1+z6Jsk+FpYVI+Pj689957zJw5k8aNGxMeHs7+/fv1i2Nu3LhBRESEvv306dOZMGEC06dP55lnnuGtt97C29ubjz/+OMfnBIweTQddOepgleG4ja0OaxtdtjkjKCgVy84imCf17woO1lEsXfq+qUMRZUzUw0dFljACJKZo89Wr2bFjRyIiIoiIiCAsLAxzc3O6du2qP9+/f3/GjRtHjx49OHjwIOHh4cyYMYPdu3fz7bffAhAdHc3zzz/Phg0bmDJlCqdPn+bHH3/Ex8eHwMBAYmJiDI4nODiYwMBANm/eTGJiYoZzR48epWHDhmzfvp2zZ8/i7++Pn58fe/fuzfP7FmWT1GkUpV5YWBivendko9ad8mTsjcypNmM6zfQHKM5lN3H8KRx6TrDk4qWrVK5c2dThiFImMTGRq1evUrNmzQy92af/uk3TwA1FGsupxX48V8s194b/GjhwINHR0ezatUt/7MiRI7Ru3Zo7d+5w8OBBfHx82LVrFz169MhwraqqxMbG4ujoyIgRI9iwYQOXLl3K9DMWFxeHtbU15ua5DwxevXqV+vXrExERgbe3N2PGjKFfv345XtOlSxdcXV0JCQkx+H2L0iW7n8GsSE+jKNVSU1MZM2Qoflr7TAljrrUZAcxUcCq7CSPAC43B+3ktkydNMHUoQhRrcXFxbNy4EU9PTypUqMCmTZuoW7dupoQR0sqcODo6otPp2LJlC2+++WaWH8rs7OwMShgB1q1bR5cuXXB0dMTX15fg4OBcr4mJicHZ2dmg+wshSaMo1T7++GPibtzidTLPU8qxNmO6MlhuJyvzRmrZvv1zfvnlF1OHIkSxsnfvXuzs7LCzs8Pe3p49e/awdetWNBoNly9fpm7dujleHxUVxYMHD6hXr16B4tDpdISGhuLr6wtAnz59OHLkCFevXs32mm3btnHixAn9HHIhciN/DkWpdf/+fWZMmsyIVAcsspi1mGNtRkhbHFMGy+1kpZobjOmnZczoIVmWNhKirGrbti3h4eGEh4dz/PhxvL296dSpE9evXzeoXJWxZogdOHCA+Ph4OnfuDKSVNOvQoUO2w84HDx7E39+fNWvWUL9+faPEIEo/SRpFqTVr+gzqJEJLbDKdy7U2I4Cm7Jbbycp4X7h14w82btxo6lCEKDZsbW3x9PTE09OT5s2bs3btWuLj41mzZg116tTJdnerdBUrVsTJySnXdrkJDg7m/v372NjYYG5ujrm5OV999RXr16/P9EHvhx9+oFu3bixbtgw/P78CPVeULZI0ilLpjz/+YM0nHzNC6/BEiZ00OdZmTKdVQZJGPVsbeHdkKlMmjSMuLs7U4QhRLCmKgkaj4dGjR/Tr149Lly6xe/fuTO1UVSUmJgaNRkOfPn3YtGkT//zzT6Z2cXFxpKbm/Pvq3r177N69my1btuh7PcPDwzlz5gwPHjzQr9KGtLI7Xbp0YdGiRQwZMqTgb1iUKZI0ilJHVVXGDBtGd9UODyyzapFzbUY9BaWM1mjMTq8OUMM1lqAF800dihDFQlJSEpGRkURGRnL+/HlGjx5NXFwc3bp1o3fv3vj4+NC3b18WLFjAyZMnuX79Onv37qV9+/YcPHgQgPnz51OtWjW8vLzYsGEDf/zxB5cvXyYkJIQmTZrk+iHt008/pUKFCvTu3ZsGDRroX40aNaJz5876BTEHDx6kS5cujBkzhp49e+rjvn//fqF/nUTpIMW9Ramzd+9eTh79mU26rLciTK/NaJAyXKMxK4oCi8Zp8R7+Hm8PHkLNmjVNHZIopVzsbbC2MCvS4t4u9pmnsuRm//79uLu7A2Bvb0+9evX4/PPPadOmDQCfffYZn3zyCSEhIcyfPx9zc3Nq166Nn58f3t7eQFpR8J9//pmFCxcyb948rl+/Tvny5Xn22WdZsmQJjo6OOcYQEhKSbQHwnj170r9/f6Kioli/fj0JCQkEBQXpN0wAePnllzl06FCe37soe6ROoyhVkpOTebpmLV795xE9slgxDYbVZgTAXEWz8L6sns7C8HkaEiy78MX2PaYORZRwOdWIk20EhSh8eanTKD2NolT53/LlaO7cpyuVsjxvUG3GdM5Sbic7s4fraNz7Kw4dOqTvURHC2KpXdJBETohiRP4kilLj9u3bvDtzFiNTHTDLZsKiQbUZ4d9yOwYslimjXCtA4EAtY0cPRquVeZ9CFKbDhw/ra0Fm9RKiqEhPoyg1pgQG8lyqBc9lUWInXXptxlx7GjWU6T2nDTHCB9btvsonn3zC8OHDTR2OEKVWs2bNCA8PN3UYQkjSKEqH06dPs3nTJkK1WS9+AQNrM6bTqiArp3NkZQkLxmgZNT2Qvn374uTkZOqQhCiVbGxs8PT0NHUYQsjwtCj5VFVl9JChvKGzxx2LbNsZVJtRT8rtGKJLa3jW8xFzZs80dShCCCEKmSSNosTbtm0bl349y5tqThPmDa3N+Bgp7J0rRYGFY7WsXr2qwDtaCCGEKN4kaRQlWkJCAhNGjmZIqgPlcvh2Tq/NaHDOaK6Cg1SjMkT9p2BAd5Xx40aYOhQhhBCFSJJGUaItXrgQx+h4OmCbY7v0BTAGq6AzbO6jAGDa2zqO//wjX331lalDEUIIUUgkaRQl1t9//83ioIWM1jqiyaEPMU+1GUHK7eSDsyNMfVvL+LFDSU5ONnU4QgghCoGsnhYl1sRx43lJZ8MzWOXYzuDajOk0oMh8xjx7+zUI3hnBihUfEhAwwdThiFJAl3QDNTWqSJ6lmLugsapeJM8SoqSSnkZRIh05coQvd+9msC733SLyPDStRfaczgdzc1g8TsvcOdO5c+eOqcMRJZwu6QaPfq1L4m9Ni+T16Ne66JJu5CnGgQMHoiiK/lWhQgU6duzI2bNn9W1UVeWTTz7By8sLOzs7nJycaNasGcuXLychIUHfLjY2lmnTplGvXj2sra1xc3Ojffv27Nixg7zs9rt582bMzMwYOXJkpnOHDh2iR48euLu7Y2trS+PGjdm0aVOe3vOTPDw8MnwNFEWhatWqGdqcOXOGXr164erqirW1NbVr12bw4MFcunQpQ7vt27fTpk0bHB0dsbOzo2HDhsydO5f79+8bHM+jR49wdnbGxcWFpKSkTOc/+eQT2rRpg4ODA4qiEB0dna/3XVZJ0ihKHJ1Ox+jBQ+intadiLp3learN+Bgpt5M/bVtA68YpTJ822dShiBJOTY0CNbEIH5iYr17Njh07EhERQUREBGFhYZibm9O1a1f9+f79+zNu3Dh69OjBwYMHCQ8PZ8aMGezevZtvv/0WgOjoaJ5//nk2bNjAlClTOH36ND/++CM+Pj4EBgYSExNjcDzBwcEEBgayefNmEhMzfv2OHj1Kw4YN2b59O2fPnsXf3x8/Pz/27t2b7f0GDhzI7Nmzc3zm3Llz9V+DiIgIzpw5oz+3d+9eWrZsSVJSEps2beL8+fNs3LgRR0dHZsyYoW83bdo0fHx8aN68OV9//TW//fYb77//Pr/++iuffvqpwe9/+/bt1K9fn3r16rFr165M5xMSEujYsSNTp041+J7iP4qal48wQhQDwcHBzBg2kvWprljl8rmnonsylT2S8pw0aubcR7GXH438+PNvaNnfjKPHTtK4cWNThyOKucTERK5evUrNmjWxtrbWH9fGnybxt6ZFGot1g1OY2T5ncPuBAwcSHR2dITk5cuQIrVu35s6dOxw8eBAfHx927dpFjx49MlyrqiqxsbE4OjoyYsQINmzYwKVLl6hcuXKGdnFxcVhbW2Nunvscm6tXr1K/fn0iIiLw9vZmzJgx9OvXL8drunTpgqurKyEhIdm+Rw8Pj2wTRw8PD8aNG8e4ceMynUtISKBGjRq8+OKL7Ny5M9P56OhonJycOH78OF5eXixfvpyxY8dm284Qbdu2pU+fPqiqyo4dO/SJ+ZMOHTpE27ZtefDgQZnfmCC7n8GsSE+jyJeVK1fi4eGBtbU1Xl5eHD9+PNu2bdq0yTR8oSgKXbp0yfNzY2NjmTw+gOGpDrkmjPmqzQhgoYKdJIz59VQ1GPaGjjGjh+RpWE2Iki4uLo6NGzfi6elJhQoV2LRpE3Xr1s2UMAIoioKjoyM6nY4tW7bw5ptvZkoYAezs7AxKGAHWrVtHly5dcHR0xNfXl+Dg4FyviYmJwdnZ2aD759U333xDVFQUgYGBWZ5PT9Y2bdqEnZ0dI0ZkXbbL0KTuzz//5NixY/Tu3ZvevXtz+PBhrl+/np/QRTYkaRR5tnXrVgICApg1axanT5+mUaNGeHt7ZzuPbceOHRmGLn777TfMzMzo1atXnp/97ty5VEvQ8hLlcm2b59qM6Vyk3E5BTfRXuXj+DNu3bzd1KEIUqr1792JnZ4ednR329vbs2bOHrVu3otFouHz5MnXr1s3x+qioKB48eEC9evUKFIdOpyM0NBRfX18A+vTpw5EjR7h69Wq212zbto0TJ07g7+9foGdPmjRJ/zWws7Pjgw8+AODy5csAub63y5cvU6tWLSwsst/RyxAhISF06tSJ8uXL4+zsjLe3N+vWrSvQPUVGkjSKPFu6dCmDBw/G39+fZ555htWrV1OuXLlshzecnZ1xc3PTvw4cOEC5cuXynDRevnyZFf/7H6O0jigGpIJ5XgADUm7HSBxsYc7wVN4JGMGjR49MHY4QhaZt27aEh4cTHh7O8ePH8fb2plOnTly/ft2gnnZj9cYfOHCA+Ph4OnfuDICLiwsdOnTI9vfywYMH8ff3Z82aNdSvX19/PL3XL/21adMmFixYkOHY4cOHM9xr4sSJ+q9BeHg4fn5+eXpvxvgaaLVa1q9fr0+aAXx9fQkNDUWnk4WNxiIld0SeJCcnc+rUKaZMmaI/ptFoaN++PceOHTPoHsHBwfTp0wdb25wLcj8pYNRovHW2eGKZa9s812bUXyjldozlzc7wyfb7vPfeEmbMkL2pRelka2uLp6en/t9r167F0dGRNWvWUKdOnVy316xYsSJOTk4F3oYzODiY+/fvY2Njoz+m0+k4e/Ysc+bMQaP5r4/ohx9+oFu3bixbtkyf4KXr3r07Xl5e+n9PmjSJKlWqMGbMGP2xKlWqZLjGxcUlw9cgXZ06dQC4cOECrVq1yjb2OnXqcOTIEVJSUvLd2/jNN99w69YtfHx8MhzXarWEhYXRoUOHfN1XZCQ9jSJPoqKi0Gq1uLq6Zjju6upKZGRkrtcfP36c3377jbfffjvHdklJScTGxupfO3fu5Iew7xlkQIkdyEdtxnQ6QFZOG4VGA0vGa1m0cB43b940dThCFAlFUdBoNDx69Ih+/fpx6dIldu/enamdqqrExMSg0Wjo06cPmzZt4p9//snULi4ujtTUnEc/7t27x+7du9myZUuGHr8zZ87w4MGDDItBDh06RJcuXVi0aBFDhgzJdC97e3s8PT31L3t7e5ydnTMcezwxzckrr7yCi4sLixcvzvJ8ermbfv36ERcXx6pVq3Jsl5P0zojH3394eDh9+vQxaG6nMIwkjaJIBQcH8+yzz9KiRYsc2wUFBeHo6Kh/vf766zytNcMJM4Oek6+h6X8pUqPRaFo2hC6ttUwKHG/qUIQoFElJSURGRhIZGcn58+cZPXo0cXFxdOvWjd69e+Pj40Pfvn1ZsGABJ0+e5Pr16+zdu5f27dtz8OBBAObPn0+1atXw8vJiw4YN/PHHH1y+fJmQkBCaNGlCXFxcjjF8+umnVKhQgd69e9OgQQP9q1GjRnTu3FmfNB08eJAuXbowZswYevbsqY87L3UQ88LW1pa1a9eyb98+unfvznfffce1a9c4efIkgYGBDBs2DAAvLy8CAwOZMGECgYGBHDt2jOvXrxMWFkavXr1Yv359js+5e/cuX375JQMGDMjw/hs0aICfnx+7du3Sv8fIyEjCw8O5cuUKAOfOnSM8PLzQvgaljSSNIk9cXFwwMzPj9u3bGY7fvn0bNze3HK+Nj49ny5YtvPXWW7k+Z8qUKcTExBATE8OiRYuobmbNHCoZFGN+azPqSU+jUc0doWPXrp0GT18QAtJ2aEHJufyHcR9onfbMPNq/fz/u7u64u7vj5eXFiRMn+Pzzz/VVIz777DOWLl3Krl27ePnll2nYsCGzZ8+mR48eeHt7A2nzvn/++Wd8fX2ZN28eTZo0oXXr1mzevJklS5bg6OiYYwwhISG89tprKFn80uvZsyd79uwhKiqK9evXk5CQQFBQkD5md3d3Xn/99Ty/b0P16NGDo0ePYmFhQb9+/ahXrx59+/YlJiaGefPm6dstWrSIzz77jF9++QVvb2/q169PQEAADRs2ZMCAATk+Y8OGDdja2tKuXbtM59q1a4eNjQ0bN24EYPXq1TRp0oTBgwcD8NJLL9GkSRP27NljxHddekmdRpFnXl5etGjRgg8//BBImzdTvXp1Ro0axeTJ2Rd1Dg0NZdiwYdy6dYsKFSoY9Kx79+7xVLXqTHtkh5cBK6Yh/7UZAbBU0QTdl9XTRhYUrPDN6Wf45fjZDHOrhMipRpxsIyhE4ctLnUZZCCPyLCAggAEDBtCsWTNatGjB8uXLiY+P15dt8PPzo0qVKgQFBWW4Ljg4mFdffdXghBFgxrRpPJOsMThhzHdtxnRSbqdQjH1TZcOXF1i/fn2By3uIskNjVR0kkROi2JCkUeSZj48Pd+/eZebMmURGRtK4cWP279+vXxxz48aNTL1JFy9e5MiRI9lW58/KuXPnCFm7lmBtzsPej0uvzZgvUm6n0JSzhnmjtEyaPJ433ngDe3t7U4ckRIlx+PBhOnXqlO353OY8lgb169fPtlD3xx9/zJtvvlnEEZVNMjwtiiVVVfm/F17E9ec/GKE6GXxdlZqJuLjlo9QOgAaU9gloOkpdwcKgquA9wozWHQJYuCjr1ZSi7MnL0FhZ9ejRI27dupXt+azK3ZQ2169fJyUlJctzrq6u8kG0AGR4WpR4u3fv5tcTJ9moGt7LmO/ajOmk3E6hUhRYMk5LuyFLGTxkKE899ZSpQxKiRLCxsSkTiWFOatSoYeoQBLJ6WhRDSUlJjB8+krdS7bHLw7dovmszPkbK7RSuRnWhT0eVdyaMyb2xEEKIYkWSRlHsLFu6FIuoB3TGLk/XFaQ2o570NBa6GUN0fB/2DWFhYaYORQghRB5I0iiKlYiICObNnsPoVEfM8rAEusC1GQGsVRRbmeJb2FwrwGR/LePGDMl1pwshhBDFhySNoliZ/M47eGktaUTeJsSXdzFC8iG9jEVmWG9IjLvOxx9/bOpQhBBCGEiSRlFsnDhxgs+3bmOoNufdDzIrYG1GSPtJcJWksahYWkDQGC0zZwTK9l1CCFFCyOppUSyoqsroIUPppbPDLY/flgWqzfhfBCjS01ikOr4Az9VNYvbs6XzwwSpThyOKIV3kTdSYe0XyLMWxAhq3qkXyLCFKKulpFMXC5s2bufrbH/RTHfJ8rVEWwOgUqChJY1FSFFg4VsuaTz7hjz/+MHU4opjRRd4krq8X8YPaFckrrq8XusibeYpx4MCBKIqif1WoUIGOHTty9uxZfRtVVfnkk0/w8vLCzs4OJycnmjVrxvLly0lISNC3i42NZdq0adSrVw9ra2vc3Nxo3749O3bsIC/llDdv3oyZmRkjR47MdO7QoUP06NEDd3d3bG1tady4MZs2bcrTe36Sh4dHhq+BoihUrZox+T5z5gy9evXC1dUVa2trateuzeDBg7l06VKGdtu3b6dNmzY4OjpiZ2dHw4YNmTt3bp5GIx49eoSzszMuLi4kJSVlOv/JJ5/Qpk0bHBwcUBSF6OjofL3vdFqtloULF1KvXj1sbGxwdnbGy8uLtWvX6tsMHDiQV199NcN1kZGRjB07Fk9PT6ytrXF1deWFF17go48+yvB9kf713bJlS6Zn169fH0VRCA0NzXQuKCgIMzMzlixZUqD39yRJGoXJxcfH887oMQxJtccmj9+SBa7N+Pi9JGkscvVqwqBXdYwdMyxPfxhF6afG3IPkzH/0C01yUr56NTt27EhERAQRERGEhYVhbm5O165d9ef79+/PuHHj6NGjBwcPHiQ8PJwZM2awe/du/Q5Z0dHRPP/882zYsIEpU6Zw+vRpfvzxR3x8fAgMDCQmJsbgeIKDgwkMDGTz5s0kJiZmOHf06FEaNmzI9u3bOXv2LP7+/vj5+bF3795s7zdw4EBmz56d4zPnzp2r/xpERERw5swZ/bm9e/fSsmVLkpKS2LRpE+fPn2fjxo04OjoyY8YMfbtp06bh4+ND8+bN+frrr/ntt994//33+fXXX/n0008Nfv/bt2+nfv361KtXj127dmU6n5CQQMeOHZk6dapB97t27RpKDn9g5syZw7Jly3j33Xf5448/OHjwIEOGDMkxGf3rr79o0qQJ3377LQsWLODMmTMcO3aMwMBA9u7dy3fffZehfbVq1Vi3bl2GYz///DORkZHY2tpm+YyQkBACAwMJCQkx6H0aSoanhckFLViAS8wj2lMxz9caozajnovUaDSFKW+pNO59lL1799KtWzdThyNEnlhZWeHmlrYJgZubG5MnT6Z169bcvXuXgwcPsmnTJnbt2kWPHj3013h4eNC9e3diY2MBmDp1KteuXePSpUtUrlxZ365OnTr07dvX4J1yrl69ytGjR9m+fTsHDx5kx44d9OvXT3/+yURp7NixfPvtt+zYsSNDoptX9vb2+q/B4xISEvD396dz587s3LlTf7xmzZp4eXnpE6vjx4+zYMECli9fztixY/XtPDw86NChQ556A4ODg/H19UVVVYKDg/Hx8clwfty4cUBar6sx7NmzhxEjRtCrVy/9sUaNGuV4zYgRIzA3N+fkyZMZkr5atWrRo0ePTB+g33zzTZYtW8bff/9NtWrVgLSk8M0332TDhg2Z7v/DDz/w6NEj5s6dy4YNGzh69CjPP/98Qd6mnvQ0CpO6fv067y9ewkitI0o+VrIYZWgawEZFsZGeLlMo7wDTB2sJGDcsy+EkIUqKuLg4Nm7ciKenJxUqVGDTpk3UrVs3Q8KYTlEUHB0d0el0bNmyhTfffDNDwpjOzs4Oc3PDPhmvW7eOLl264OjoiK+vL8HBwbleExMTg7Ozs0H3z6tvvvmGqKgoAgMDszzv5OQEwKZNm7Czs2PEiBE5tsvNn3/+ybFjx+jduze9e/fm8OHD2e5XbSxubm58//333L1716D29+7d49tvv2XkyJHZ9hI+2bPp6uqKt7c369evB9KS8a1btzJo0KAsrw8ODqZv375YWFjQt29fg74PDCVJozCpd8aOo61qw9NY5flao9RmTCeLYEzKvwdYaW7zwQf/M3UoQuTJ3r17sbOzw87ODnt7e/bs2cPWrVvRaDRcvnyZunXr5nh9VFQUDx48oF69egWKQ6fTERoaiq+vLwB9+vThyJEjXL16Ndtrtm3bxokTJ/D39y/QsydNmqT/GtjZ2fHBBx8AcPnyZYBc39vly5epVasWFhYWBYojJCSETp06Ub58eZydnfH29s40rGtsS5cu5e7du7i5udGwYUOGDRvG119/nW37K1euoKpqpu8LFxcX/ddv0qRJma4bNGgQoaGhqKrKF198wVNPPUXjxo0ztYuNjeWLL77Qfx/4+vqybds24uLiCvZG/yVJozCZH3/8ka/27mWwNuvFL6mo/E0KqWTdA2iU2owAGlBcpci0KZmbw6JxWt6dO5Pbt2+bOhwhDNa2bVvCw8MJDw/n+PHjeHt706lTJ65fv27QPF1jzeU9cOAA8fHxdO7cGUhLQjp06JDtnLaDBw/i7+/PmjVrqF+/vv54eq9f+mvTpk0sWLAgw7HDhw9nuNfEiRP1X4Pw8HD8/Pzy9N6M8TXQarWsX79enyxBWsIUGhqKTpe3qUf169fXv9f0r83j779Tp076ts888wy//fYbP//8M4MGDeLOnTt069aNt99+O0/PPH78OOHh4dSvXz/LEZcuXboQFxfHjz/+SEhISLa9jJs3b+app57SD5E3btyYGjVqsHXr1jzFkx2Z0yhMQqvVMmrwEPpr7amQxbdhKiojiOAiydTFklW4Y55h+NoItRkfuxey57TJtWkGbZulMnVKIMEh600djhAGsbW1xdPTU//vtWvX4ujoyJo1a6hTpw4XLlzI8fqKFSvi5OSUa7vcBAcHc//+fWxsbPTHdDodZ8+eZc6cOWg0//UR/fDDD3Tr1o1ly5bpE7x03bt3x8vLS//vSZMmUaVKFcaM+W+/+CpVqmS4xsXFJcPXIF2dOnUAuHDhAq1atco29jp16nDkyBFSUlLy3dv4zTffcOvWrUxzGLVaLWFhYXTo0MHge3311VekpKQAcOvWLdq0aUN4eLj+/ONfYwCNRkPz5s1p3rw548aNY+PGjfTv359p06ZRs2bNDG09PT1RFIWLFy9mOF6rVq0s753O3Nyc/v37M2vWLH755ZcMc0QfFxwczO+//55hSoNOpyMkJIS33nrLsC9ADqSnUZhEcHAwD/66zhtk3csYQSoXSQbgIslEkLEnML02o1FyRp0iw9PFxPzRWjZv3sSpU6dMHYoQ+aIoChqNhkePHtGvXz8uXbrE7t27M7VTVZWYmBg0Gg19+vRh06ZN/PPPP5naxcXF5brd5r1799i9ezdbtmzJ0ON35swZHjx4oF+lDWkLQLp06cKiRYsYMmRIpnvZ29vj6empf9nb2+Ps7JzhWHaJzZNeeeUVXFxcWLx4cZbn0xe49OvXj7i4OFatyrpeqyELYYKDg+nTp0+G9x8eHk6fPn3yPKevRo0a+vdao0YNgAzv/8mk+UnPPPMMkFYZ5EkVKlSgQ4cOrFixIsvzORk0aBA//PADPXr0oHz58pnOnzt3jpMnT3Lo0KEMX4NDhw5x7NixAn8wAelpFCYQExPD1AkTGZ9qj2U2aZ875tTFUt/T6P7Et2r6AhijzGdEyu0UFzWrwEgfHWNGD+HITydzLHUhRHGQlJREZGQkAA8ePGDFihXExcXRrVs3Xn75ZXbu3Enfvn2ZPn06r7zyChUrVuTcuXMsW7aM0aNH8+qrrzJ//nwOHTqEl5cX8+fPp1mzZlhYWHD48GGCgoI4ceJEjotBPv30UypUqEDv3r0z/cx07tyZ4OBgOnbsyMGDB+natStjx46lZ8+e+rgtLS0LZTGMra0ta9eupVevXnTv3p0xY8bg6elJVFQU27Zt48aNG2zZsgUvLy8CAwOZMGECt27d4rXXXqNy5cpcuXKF1atX8+KLL2ZYVf2ku3fv8uWXX7Jnzx4aNGiQ4Zyfnx+vvfYa9+/fx9nZmcjISCIjI7ly5QqQlmjZ29tTvXr1fH0N3njjDV544QWef/553NzcuHr1KlOmTKFOnTrZzuVctWoVL7zwAs2aNWP27Nk0bNgQjUbDiRMnuHDhAk2bNs3yuqeffpqoqCjKlSuX5fng4GBatGjBSy+9lOlc8+bNCQ4OLnDdRulpFEVuzqxZeDzS8iJZf+MDmKOwCnc2UiXT0LQxazPqSU9jsTHBT+WvK2fZtm2bqUMRJqQ4VgDLvC+QyzdLq7Rn5tH+/ftxd3fH3d0dLy+vtO1QP/+cNm3aoCgKn332GUuXLmXXrl28/PLLNGzYkNmzZ9OjRw+8vb0BcHZ25ueff8bX15d58+bRpEkTWrduzebNm1myZAmOjjlvrRoSEsJrr72W5Yesnj17smfPHqKioli/fj0JCQkEBQXpY3Z3d+f111/P8/s2VI8ePTh69CgWFhb069ePevXq0bdvX2JiYpg3b56+3aJFi/jss8/45Zdf8Pb2pn79+gQEBNCwYUMGDBiQ4zM2bNiAra0t7dq1y3SuXbt22NjYsHHjRgBWr15NkyZNGDx4MAAvvfQSTZo0Yc+ePfl6f97e3nz55Zd069aNOnXqMGDAAOrVq8e3336b7ar3p556ijNnztC+fXumTJlCo0aNaNasGR9++CHvvPMO7777brbPq1ChQpY9vcnJyWzcuJGePXtmeV3Pnj3ZsGGDftg9vxRVKuqKInTx4kUa1W/Aam0lamGZr3s4OqdQs15i7g0NVU6H2bwHxrufKLDPvoJ3gytw4dKNbD9Vi9IhMTGRq1evUrNmzUz1CGUbQSEKX04/g0+S4WlRpMaPHEVn1TbfCSMYf2haFsEUP306wifbo1m8eCGzZ881dTjCRDRuVUESOSGKDRmeFkXm66+/5qdDP+Cvy/v+0umMWpsRpNxOMaXRwOLxWpYsXsiNGzdMHY4QJnX48OEMJV+efJUFj5fBefJV0P2zheGkp1EUiZSUFMYOG85ArT2OmOX7PkarzainynzGYqpFA+j+spbAiePYsnWHqcMRwmSaNWuWoeRLWfR4GZwnubq6FnE0ZZf0NJYxK1euxMPDA2tra7y8vDh+/HiO7aOjoxk5ciTu7u5YWVlRp04dvvrqq7w/d8UKUv+5TQ/s8xs6xq3N+C+dgiLD08XW3BE69n65hyNHjpg6FCFMxsbGJkPJlydfZcHjZXCefNnbF+TvisgLSRrLkK1btxIQEMCsWbM4ffo0jRo1wtvbmzt37mTZPjk5mQ4dOnDt2jW++OILLl68yJo1a3KtUfWku3fvMmvaNEamOj5RoDtvjFqb8XHS01hsVa4EE/y0jB09OM+7OgghhDAuSRrLkKVLlzJ48GD8/f155plnWL16NeXKlct2m6mQkBDu37/Prl27eOGFF/Dw8ODll1/Wb09kqOlTptIw2YzmGFYQNjvpC2CMTpLGYm10X7h350q236dCCCGKhiSNZURycjKnTp2iffv2+mMajYb27dtz7NixLK/Zs2cPrVq1YuTIkbi6utKgQQMWLFiAVmt4kvXrr7+yITSU4dqc64zlplBqMwLY6lCKsBScyDsba5g/KpVpUyYQGxtr6nCEEKLMkqSxjIiKikKr1WaaMOzq6qrfFeBJf/31F1988QVarZavvvqKGTNm8P7772coyPq4pKQkYmNj9a+YmBhGDR7Cqzo7qpK//UTTOZRPxawwlm1Vkl7GkqBHW6hTPZ53584xdShCCFFmSdIosqXT6ahUqRKffPIJTZs2xcfHh2nTprF69eos2wcFBeHo6Kh/OTk5cerkKfzU/JfYSefsWghD0xpQJGksERQFFo/TsmLF/7h8+bKpwxFCiDJJSu6UES4uLpiZmXH79u0Mx2/fvo2bm1uW17i7u2NhYYGZ2X8lcp5++mkiIyNJTk7G0jJjge4pU6YQEBAApFWYb9rgWXzuarEt4GcTcwsdDk5GrM2YTpVyOyVJwzrQr7PKhIBR7PnyG1OHI4pA4o1bpEQVzW5NFi7lsa6et0V+QpQ10tNYRlhaWtK0aVPCwsL0x3Q6HWFhYbRq1SrLa1544QWuXLmSYdXqpUuXcHd3z5QwAlhZWeHg4ICDgwNrPvkE2/sP6UrBC88avzbjv1Qpt1PSzBii48cfwvj2229NHYooZIk3bnGibjvONO1WJK8TdduReONWnmIcOHAgiqLoXxUqVKBjx46cPXtW30ZVVT755BO8vLyws7PDycmJZs2asXz5chISEvTtYmNjmTZtGvXq1cPa2ho3Nzfat2/Pjh07yMtuv5s3b8bMzIyRI0dmOnfo0CF69OiBu7s7tra2NG7cuMCFsX/99Ve6d+9OpUqVsLa2xsPDAx8fH31VjmvXrqEoSqY6k9u3b+f//u//KF++PDY2NtStW5dBgwZx5swZfZvQ0FAUReHpp5/O9NzPP/8cRVHw8PDIdO7Ro0c4Ozvj4uJCUlJSgd6fyEiSxjIkICCANWvWsH79es6fP8/w4cOJj4/H398fAD8/P6ZMmaJvP3z4cO7fv8/YsWO5dOkS+/btY8GCBVn+MnrcrVu3WDD3XUZrHdEUuEBOIdRmfJz0NJYoFcvD1Le0jB87NNtCv6J0SIl6gJpYdH/w1cSkfPVqduzYkYiICCIiIggLC8Pc3JyuXbvqz/fv359x48bRo0cPDh48SHh4ODNmzGD37t36Dz/R0dE8//zzbNiwgSlTpnD69Gl+/PFHfHx8CAwMJCYmxuB4goODCQwMZPPmzSQmJmY4d/ToURo2bMj27ds5e/Ys/v7++Pn5sXfv3mzvN3DgQGbPnp3lubt379KuXTucnZ355ptvOH/+POvWraNy5crEx8dne89Jkybh4+ND48aN2bNnDxcvXuSzzz6jVq1aGf4GAdja2nLnzp1MCzaDg4OpXr16lvffvn079evXp169euzatSvbOETeyfB0GeLj48Pdu3eZOXMmkZGRNG7cmP379+sXx9y4cQON5r/PEdWqVeObb75h/PjxNGzYkCpVqjB27FgmTZqU43MmTZhAK50Vz5LzxueGSK/NWGgkaSxxhrwBwTv/5qOPVjFmzFhThyPKOCsrK/0UHzc3NyZPnkzr1q25e/cuBw8eZNOmTezatYsePXror/Hw8KB79+76agBTp07l2rVrXLp0icqVK+vb1alTh759+2Jtbdjv0qtXr3L06FG2b9/OwYMH2bFjB/369dOfnzp1aob2Y8eO5dtvv2XHjh0ZEl1D/fTTT8TExLB27VrMzdPSiZo1a9K2bdtsr/n5559ZvHgx//vf/xgzZoz+ePXq1WnatGmmXlVzc3P69etHSEiIflTs5s2bHDp0iPHjx7N58+ZMzwgODsbX1xdVVQkODsbHxyfP701kTXoay5hRo0Zx/fp1kpKS+OWXX/Dy8tKfO3ToEKGhoRnat2rVip9//pnExET+/PNPpk6dmmGO45N++eUXtn+xnaEFLLGTrtBqMwLY61Ayj7KLYs7CHBaO1TJ71hTu3btn6nCE0IuLi2Pjxo14enpSoUIFNm3aRN26dTMkjOkURcHR0RGdTseWLVt48803MySM6ezs7PQJWW7WrVtHly5dcHR0xNfXl+Dg4FyviYmJwdnZ2aD7P8nNzY3U1FR27txp8BD65s2bsbOzY8SIEVmeV7KYvD5o0CC2bdumH84PDQ2lY8eOWW4f+Oeff3Ls2DF69+5N7969OXz4MNevX8/DuxI5kaRRGI1Op2P0kCH01dnjaoRO7EKrzZiuovQyllSvPA8t6iczc+Y0U4ciyri9e/diZ2eHnZ0d9vb27Nmzh61bt6LRaLh8+TJ169bN8fqoqCgePHhAvXr1ChSHTqcjNDQUX19fAPr06cORI0e4evVqttds27aNEydO6Kco5VXLli2ZOnUq/fr1w8XFhU6dOrFkyZJMCy4fd+nSJWrVqpUhEV66dKn+a2hnZ5dpOL5JkybUqlWLL774AlVVCQ0NZdCgQVnePyQkhE6dOlG+fHmcnZ3x9vZm3bp1+Xp/IjNJGoXRbNy4kRt/XKSPapx9QAutNiNIuZ1SIGiMlpDgtZw7d87UoYgyrG3btoSHhxMeHs7x48fx9vamU6dOXL9+3aDet7wscsnJgQMHiI+Pp3PnzkBaxYwOHTpku5PSwYMH8ff3Z82aNdSvX19/fNOmTRkSuE2bNrFgwYIMxw4fPqxvP3/+fCIjI1m9ejX169dn9erV1KtXL08/l4MGDSI8PJyPP/6Y+Pj4LL8mgwYNYt26dfzwww8Z3ufjtFot69ev1yfOAL6+voSGhso2pEYicxqFUcTFxRE4dhzDUh2wNtJnkfTajIXS06iq0tNYwtWpAYNf1zF2zFDCvv8py2EtIQqbra0tnp6e+n+vXbsWR0dH1qxZQ506dbhw4UKO11esWBEnJ6dc2+UmODiY+/fvY2Pz33atOp2Os2fPMmfOnAzz1X/44Qe6devGsmXL8PPzy3Cf7t27Z5i2NGnSJKpUqZJh/mGVKhlLE1WoUIFevXrRq1cvFixYQJMmTXjvvfdYv359pjhr167NkSNHSElJwcIibdMHJycnnJycuHnzZrbv78033yQwMJDZs2fTv3//LIfsv/nmG27dupVpDqNWqyUsLIwOHTpke39hGOlpFEYxf948XB8m0ZZyRrlfodVmTKcqKJI0lniTBqmc+/U4u3fvNnUoQgBpc/I0Gg2PHj2iX79+XLp0KcvvT1VViYmJQaPR0KdPHzZt2sQ///yTqV1cXBypqTmXHbt37x67d+9my5Yt+l7P8PBwzpw5w4MHDzKUqDp06BBdunRh0aJFDBkyJNO97O3t8fT01L/s7e1xdnbOcOzxxPRJlpaWPPXUU9munu7bty9xcXGsWrUqx/f0JGdnZ7p3784PP/yQ7dB0cHAwffr0yfA1CA8Pp0+fPgbN7xS5k55GUWBXr15l+fvv84G2IoqRauMUWm3Gx7nIcEVJ52QPM4dqmTB+OJ06dcLKSjYSF0UrKSlJvxXrgwcPWLFiBXFxcXTr1o2XX36ZnTt30rdvX6ZPn84rr7xCxYoVOXfuHMuWLWP06NG8+uqrzJ8/n0OHDuHl5cX8+fNp1qwZFhYWHD58mKCgIE6cOIGTk1O2MXz66adUqFCB3r17Z+px79y5M8HBwXTs2JGDBw/StWtXxo4dS8+ePfVxW1pa5msxzN69e9myZQt9+vShTp06qKrKl19+yVdffZXtPMJWrVoxYcIEJkyYwPXr13n99depVq0aERERBAcH65PurISGhrJq1SoqVKiQ6dzdu3f58ssv2bNnDw0aNMhwzs/Pj9dee4379+/ne9GPSCM9jaLAJowZSztdOepirD/YhVyb8d9nUEF6GkuDAd3A1vIuy5YtNXUowogsXMqjWBfdhwDF2goLl/J5vm7//v24u7vj7u6Ol5cXJ06c4PPPP6dNmzYoisJnn33G0qVL2bVrFy+//DINGzZk9uzZ9OjRA29vbyCtF+3nn3/G19eXefPm0aRJE1q3bs3mzZtZsmQJjo45V6MICQnhtddey3KKRs+ePdmzZw9RUVGsX7+ehIQEgoKC9DG7u7vz+uuv5/l9AzzzzDOUK1eOCRMm0LhxY1q2bMm2bdtYu3Yt/fv3z/a69957j88++4wzZ87QtWtXateuTa9evdDpdBw7dgwHh6y3nrWxsckyYQTYsGEDtra2tGvXLtO5du3aYWNjw8aNG/P1PsV/FNVYs3BFmXTw4EG6d/DmU60bzmRfiicvbGy11G2UkHvDgnDQYTa7aLYnE4Xv8GnoNdGSS5ev4e7ubupwRB4kJiZy9epVatasmakeoWwjKEThy+ln8EkyPC3yLTU1ldFDhtJfa2+0hBH+q81YqOsaZOV0qdL6OejQUsuUyRMJXS+9CaWFdfUqksgJUYzI8LTItzVr1hBz7W96YpwSO1AEtRlByu2UUvNGatm2bQsnTpwwdShCGNXhw4czlLx58iVEUZGeRpEvDx48YNrEQCamOmBhxMmHhVqbMZ2qyvaBpVCNyjC6r5Yxo4dw9NhpKcEjSo1mzZoRHh5u6jCEkKRR5M/smTOpnajyPNmXXsiPQq3NmE7K7ZRaE/xgo89vbN68OcOeu0KUZDY2NhlqQQphKjI8LfLs/PnzfPzRakZqHY1WYgeKoDbj46SnsVSytYF3R6QS+M7obOvECSGEyB9JGkWeqKrK2OHD6ara4YGlUe9dJLUZARQVKkiNxtKqtzdUdYlhYdACU4cihBCliiSNIk+++uorjh85ykCd8Ra/pCmK2oz/clBRZGJGqaUosHi8lvffX8z169dNHY4QQpQakjQKgyUnJzNu2HD8tfY4GLHEDoCNrQ5rG12R5IxSbqf0a/oMvN5Ox8R3xpo6FCGEKDUkaRQG+/CDD9BFRtHNiCV20qXXZix0ZlJup6yYM1zH11/t5ccffzR1KEIIUSrIIJ0wyJ07d5gzfQZzUh0xN3J/YJHUZkynU0FWTpcJbi4wcaCWsaMHc/L0H5iZGbd3XBS+ZN0NtGpUkTzLTHHBUlO9SJ4lREklPY3CIFMnTaJJqgVNjVxiB4qoNmM6VUGRldNlxkgfiLn/F2vXrjV1KCKPknU3uJRQlyuPmhbJ61JCXZJ1N/IU48CBA1EUJdPrypUrAERGRjJ69Ghq1aqFlZUV1apVo1u3boSFhWW4z5kzZ+jVqxeurq5YW1tTu3ZtBg8ezKVLl/IUj7e3N2ZmZlkWuP/xxx/p1q0blStXRlEUdu3alad7CwGSNAoDnDlzhk2fbmS4NutN5AsqvTZjkZGexjLD2grmj0plxrSJxMTEmDockQdaNQqVxCJ7nkpivno1O3bsSERERIZXzZo1uXbtGk2bNuX7779nyZIlnDt3jv3799O2bVtGjhypv37v3r20bNmSpKQkNm3axPnz59m4cSOOjo7MmDHD4Dhu3LjB0aNHGTVqFCEhIZnOx8fH06hRI1auXJnn9yhEOhmeFjlSVZUxQ4bSU2dHZSyMfn9j1WZMVVWuJerwsNZgntPNFBWcpdxOWdLtZfj4iwTmzpnF+0uXmzocUcpYWVnh5uaW6fiIESNQFIXjx49ja2urP16/fn0GDRoEQEJCAv7+/nTu3JmdO3fq29SsWRMvLy+io6MNjmPdunV07dqV4cOH07JlS5YuXYqNzX8jQ506daJTp075eIdC/Ed6GkWOvvjiC86H/4qvavxeRhVIrlHw+6aqKu3PxtD0TDTtz8aQmlO3pZOKIlPbyhRFgUXjtKxatYKLFy+aOhxRBty/f5/9+/czcuTIDAljOicnJwC++eYboqKiCAwMzPI+6e1yo6oq69atw9fXl3r16uHp6ckXX3yR3/CFyJYkjSXAypUr8fDwwNraGi8vL44fP55t29DQ0Ezza6ytrfP13EePHjFm+EiGpDpgbWaBzswMVaNJeykKeR1RVhUFrbU1yeXLE129Bruf68Rtl0poC/hteC1Rx5n4tCHnM/FariXm0JNYqYgKiItipYEn9O+qEjB+ZO6NhciDvXv3Ymdnp3/16tWLK1euoKoq9erVy/Hay5cvA+TaLjffffcdCQkJeHt7A+Dr60twcHCB7ilEVmR4upjbunUrAQEBrF69Gi8vL5YvX463tzcXL16kUqVKWV7j4OCQoUdFyefY78LFi7FwcKamzwCuWFhCesJoZoZqZobO3Bz135fO0pJUMw2xsQ8oV7kaqq0tWmtrdNbWaG2s0dqUQ2tjDYrCo2uR3ProS1Jj4nhatUFRCjah0cNaQxNbM87Ea2lia4aHdTZJqJTbKdOmD9HRuNchvv76axmmE0bTtm1bPvroI/2/bW1tuXHDsAU1qpEmc4eEhODj44O5edqf9L59+zJx4kT+/PNPnnrqKaM8QwiQpLHYW7p0KYMHD8bf3x+A1atXs2/fPkJCQpg8eXKW1yiKkuUcm7y4efMmixYuot//NnK95cu5ttelphLq15GI38Nxr9+YgRv2ozHP+O2lqioPvjvNnS9++PcilVjFBrM891lmZK4ofNfQMfc5jToVXGQ+Y1lVwRGmvKUlYNww2re/goWF8efoirLH1tYWT0/PDMesrKxQFIULFy7keG2dOnUAuHDhAq1atcrX8+/fv8/OnTtJSUnJkLxqtVpCQkKYP39+vu4rRFZkeLoYS05O5tSpU7Rv315/TKPR0L59e44dO5btdXFxcdSoUYNq1arRo0cPfv/99zw/e+L48bRONqf/qMk0mDKdCkd/Bm32vXQPbl4j4vdwACJ+D+fBzWsZzmvjHnFr5W7ubDuUlrzp0hLFWNU4JXzMFQVPG7OcF8GoCoqsnC7TBvcEUm6xcuUKU4ciSjFnZ2e8vb1ZuXIl8fHxmc6nL3B55ZVXcHFxYfHixVnex5CFMJs2baJq1ar8+uuvhIeH61/vv/8+oaGhaHP4vS1EXknSWIxFRUWh1WpxdXXNcNzV1ZXIyMgsr6lbty4hISHs3r2bjRs3otPpeP7557l582a2z0lKSiI2Nlb/OnDgALt37mKozhGzlBTcvzlA0+GjaNP2FeotWITT6TOgy9hjV76qB+71GwPgXr8J5at66M8lXLrJX7PXE/fb1UzPji2Euo85khqNZZqFOSwcq2X2rKncvXvX1OGIUmzlypVotVpatGjB9u3buXz5MufPn+eDDz7Q9yra2tqydu1a9u3bR/fu3fnuu++4du0aJ0+eJDAwkGHDhuX6nODgYN544w0aNGiQ4fXWW28RFRXF/v37gbTOhPSEEuDq1auEh4cbPJQuBMjwdKnTqlWrDMMczz//PE8//TQff/wx7777bpbXBAUFMWfOnAzHmmBNpX+/PZR/P6laxsRQ9YsdVN/6OcmOjtxp15a7L7fmfovmUK4cAzfs58HNa5Sv6oHG3BxVqyNq38/c2/czoJBVMcYiTRoVFcrL8HRZ174lvNAohRnTp7D6Yyn6LQpHrVq1OH36NPPnz2fChAlERERQsWJFmjZtmmEYuUePHhw9epSgoCD69etHbGws1apV4//+7/+YN29ejs84deoUv/76K2vWrMl0ztHRkXbt2hEcHEyXLl04efIkbdu21Z8PCAgAYMCAAYSGhhrnTYtST1GNNRNXGF1ycjLlypXjiy++4NVXX9UfHzBgANHR0ezevdug+/Tq1Qtzc3M2b96c5fmkpCSSkpIA2LhxI3PHBBCsrYQ9Odem0ZmZodFq0ZmbEd2oEfdatuBB82bE1H+GpNhH/LNmH4lXs+4RTWeGljVmRfSH21mH2fQHRfMsUaxduQEt+5vx8y+naNSokanDKdMSExO5evUqNWvWzFDpIX1HmKIq8K1gTZ1yF2UrQVHmZPczmBXpaSzGLC0tadq0KWFhYfqkUafTERYWxqhRowy6h1ar5dy5c3Tu3DnbNlZWVlhZWfHw4UPmTJ3GCK1DrgkjgObfHkhNqpbyp89Q/kw4ysrVxLg4csjTi0TFJff4MCMBS8qRbND7KRBXKbcj0nhWh6Fv6Bg7ZigHDx3Ld4UBUXgsNdWpU+6i7D0tRDEiSWMxFxAQwIABA2jWrBktWrRg+fLlxMfH61dT+/n5UaVKFYKCggCYO3cuLVu2xNPTk+joaJYsWcL169d5++23c33WvHffpXJcCm1wzHOciqr+O/ys8nS1B7yo7GCwbjCQ+x/jh9gUftJohiyCERkE+qs07n2KnTt38vrrr5s6HJGFtCSubCdyw4YNY+PGjVme8/X1ZfXq1UUckSjLJGks5nx8fLh79y4zZ84kMjKSxo0bs3//fv3imBs3bqDR/Lee6cGDBwwePJjIyEjKly9P06ZNOXr0KM8880yOz/nzzz/5YNkyVmgrohiQ6GXHzlFLJZtHPFStMSRhBIhRbXBVCnlfYK0qe06LDBztYPawVCaMH07nzp3zXQRfiMI0d+5c3nnnnSzPOTgYf6cuIXIicxoFAD06dUb99ijv6MoX4C4qdRomUM5Oxz+UZ7q2t0FXDVUO0FxzFU0B6zXmRjM0FqVuSqE+Q5QsWi28/JYZb/jOZtq06aYOp0zKy3wqIYTx5eVnUEruCL777ju+P/Adb+sK9qnVobyWcnZpq5Nj8lB/8SHlUAvQu2kw6WkUTzAzg8XjtAQtmMutW7dMHY4QQhRrkjSWcampqYwZMhQ/rR1OBix+yZ6Ke40kVECHQoxazuAr08ruFHKHt0YFp7JXbic1FS7fSPtfkbXnG0PHF3RMnjTB1KEIIUSxJkljGffxxx8T//c/vE7BehkdK6RiU06HQlrS+BDDh5lisEFT2LMknHUoZey7PTUV/m8wNOmd9r+SOGZv3kgtO3Z8wS+//GLqUIQQotgqY39GxePu37/P9MBJjEx1wKJAw8MqlWsk6/sKFVQe5qFo90PVhkKveFKp7A1NX/0HTp9P+/+nz6f9W2StmhuM7adlzOgh6HRlr0daCCEMIUljGTZz+nTqJSm0xPCh5KyUr5iKlbVOn3ZqVDVPPY2FviuMGShlMGmsWRmeezrt/z/3dNq/RfbG94dbN37n008/NXUoQghRLEnJnTLq999/Z+0nn7BG65p745woKu7V0+YypieNigIPdcUoadSqZXLPaXNz+H5NWg9jzcpp/xbZK2cN80ZpmTJpHD179sTOzs7UIZV5dyOjeRgdXyTPsneypaKbU5E8S4iSSv6MlEGqqjJ22HB6qHbUwLJA93KumIKFZea1z3kZni78/aeVMlvY29wcapft2sh58kZ7+OSLhyyYP48FQQtNHU6ZdjcymjG9l5GSXDSTcS0szflg2/g8JY4DBw5k/fr1mY5fvnwZT09PIiMjmT9/Pvv27ePWrVtUqlSJxo0bM27cONq1a6dvf+bMGRYsWMCPP/5ITEwM1apVo02bNkycOJE6deoYHI+3tzffffcdP//8M82bN89w7scff2TJkiWcOnWKiIgIdu7cmWF72vzYuXMnixYt4vz58+h0OqpXr06HDh1Yvnw5AKGhoYwbN47o6Gj9NcnJyfzvf/9j8+bNXLx4EXNzczw8POjWrRsjRoygcuW0IZH0r+3QoUMzFTAfOXIkq1atynLf7GPHjvHiiy/SsWNH9u3bV6D3JzKT4ekyaO/evZw69gt+BSyxoygq7tWTs6zhnZfh6WQsSFYLsnLbAC4yT03kTlFg8Xgty5e/z9WrV00dTpn2MDq+yBJGgJTk1Hz1anbs2JGIiIgMr5o1a3Lt2jWaNm3K999/z5IlSzh37hz79++nbdu2jBw5Un/93r17admyJUlJSWzatInz58+zceNGHB0dmTFjhsFx3Lhxg6NHjzJq1ChCQkIynY+Pj6dRo0asXLnS4Ht6eHhw6NChLM+FhYXh4+NDz549OX78OKdOnWL+/PmkpGRfCzcpKYkOHTqwYMECBg4cyI8//si5c+f44IMPiIqK4sMPP8zQvlq1amzZsoVHjx7pjyUmJvLZZ59RvXrWn4aDg4MZPXo0P/74I//8IxO5jU16GsuYpKQkxg0bzltae4P2l85JBdcUzC2yrrCYl55GgDjFGmcKaRjKTAVHSRqFYZrUg14ddLwzYQzbd3xp6nBEMWdlZYWbm1um4yNGjEBRFI4fP46tra3+eP369Rk0aBAACQkJ+Pv707lzZ3bu3KlvU7NmTby8vDL00OVm3bp1dO3aleHDh9OyZUuWLl2Kjc1/v4c7depEp06d8vEOs/bll1/ywgsvMHHiRP2xOnXq5Nh7uWzZMo4cOcLJkydp0qSJ/nj16tV5+eWXeXKvkeeee44///yTHTt28OabbwKwY8cOqlevTs2aNTPdPy4ujq1bt3Ly5EkiIyMJDQ1l6tSpBXyn4nHS01jG/G/5cjR37tOFgs3XUjQqbtWy7mXUqQoJWOXpfjEFXIyTozJYbkcUzKxhOg58+zUHDx40dSiiBLp//z779+9n5MiRGRLGdE5OTgB88803REVFERgYmOV90tvlRlVV1q1bh6+vL/Xq1cPT05Mvvvgiv+EbxM3Njd9//53ffvvN4Gs2b95Mhw4dMiSMj1OyKKMxaNAg1q1bp/93SEgI/v7+WV6/bds26tWrR926dfH19SUkJCRTIioKRv6UliGRkZG8O2sWo1IdMCvgDiwubimYmWfdy5igWOZ5h5dotVzhlPdWANeyOZ9R5J9rBZjkr2XcmCGkSoFLkYO9e/diZ2enf/Xq1YsrV66gqir16tXL8drLly8D5NouN9999x0JCQl4e3sD4OvrS3BwcIHumZvRo0fTvHlznn32WTw8POjTpw8hISEkJSVle82lS5eoW7duhmOvvfaa/mv3/PPPZ7rG19eXI0eOcP36da5fv85PP/2Er69vlvcPDg7Wn+vYsSMxMTH88MMPBXiX4kmSNJYhUyYG0izVkiYFXHii0ai4Vk3KtrZiXB7mM6aLUcuhK4xvRw1ldhGMKJjhvSE+5hqffPKJqUMRxVjbtm0JDw/Xvz744AODe7eM1QsWEhKCj48P5v+WSOjbty8//fQTf/75Z57uM2zYsAwJ8I0bN+jUqVOGY+lsbW3Zt28fV65cYfr06djZ2TFhwgRatGhBQkKCwc9ctWoV4eHhDBo0KMvrKlasSJcuXQgNDWXdunV06dIFFxeXTO0uXrzI8ePH6du3LwDm5ub4+PgUevJc1sicxjLi1KlTbNn8GaHazHNv8qpi5WTMcpgOmZctBNPldQ6kwcpouR1RcFaWsGB0KiOmB9K3b1/Kly9v6pBEMWRra4unp2eGY1ZWViiKwoULF3K8Nn1l9IULF2jVqlW+nn///n127txJSkoKH330kf64VqslJCSE+fPnG3yvuXPn8s477+j/3aZNGxYtWoSXl1e21zz11FM89dRTvP3220ybNo06deqwdevWLIeQa9euzcWLFzMcc3d3B8DZ2TnbZwwaNIhRo0YBZLuQJzg4mNTUVP3qa0hLyq2srFixYgWOjo7Z3l8YTnoaywBVVRk9ZCi9dPa4Y1Gge5mZqVSqkpxtL2PavtN5TwBjsEGhMBarlN1yO6LgOreGRnUSmTN7pqlDESWIs7Mz3t7erFy5kvj4zAv80he4vPLKK7i4uLB48eIs72PIQphNmzZRtWpVfv311ww9nu+//z6hoaFotYb//qtUqRKenp76l7m5OVWqVMlwLCceHh6UK1cuy/cMaT2gBw4c4MyZMwbHBGlDzcnJyaSkpOiH4B+XmprKhg0beP/99zN8DX799VcqV67M5s2b8/Q8kT3paSwDtm7dypWzvzFTLWAhb9J6GTU5fNRQUfLVa/gQm8L7BCPldkQ+KQosHKvlJf+PGDpsBE8//bSpQxIlxMqVK3nhhRdo0aIFc+fOpWHDhqSmpnLgwAE++ugjzp8/j62tLWvXrqVXr150796dMWPG4OnpSVRUFNu2bePGjRts2bIlx+cEBwfzxhtv0KBBgwzHq1WrxpQpU9i/fz9dunQhLi6OK1eu6M9fvXqV8PBwnJ2dsy1fk5PZs2eTkJBA586dqVGjBtHR0XzwwQekpKTQoUOHLK8ZP348+/bto127dsyaNYvWrVtTvnx5Ll26xNdff41ZNkNYZmZmnD9/Xv//n7R3714ePHjAW2+9lalHsWfPngQHBzNs2LA8v0eRmfQ0lnIJCQlMGDmaIan2lCvgf24zc12OvYzp8lKjMV1+eicNYi7ldkTBPFMLBvZQGTd2uKzEFAarVasWp0+fpm3btkyYMIEGDRrQoUMHwsLCMgwj9+jRg6NHj2JhYUG/fv2oV68effv2JSYmhnnz5uX4jFOnTvHrr7/Ss2fPTOccHR1p166dfk5fepmb9JXLAQEBNGnShJkz89eL/vLLL/PXX3/h5+dHvXr16NSpE5GRkXz77beZFruks7a2JiwsjEmTJrFu3TpefPFFnn76acaNG8cLL7zArl27sn2eg4MDDg5Z1xYODg6mffv2WQ5B9+zZk5MnT3L27Nl8vU+RkaLKb8FSbdaMGWwPWsoKbUU0BVwxXblGIhUrp+SYNKoqfKq+yCG1fp7u7cYDFphtK1B8WaqkxWxytPHvK8qU+zHQuLcZGzbtpkuXLqYOp1RJTEzk6tWr1KxZE2vr/z5wloQdYYQoDbL7GcyKDE+XYjdu3GDJwkUs07oUOGE0t9Dh4p5zwgjp+07nb3ja6BTAVcqliIJzdoRpg7WMHzuUDh3+wtKyYNtvitxVdHPig23jZe9pIYoRSRpLsYnjxvOSzoan81hoOyuuVXMflk6Xn+HpeKzQqgpmihE7vjWgVJShaWEcb70Ka3dE8uGHHzBhwju5thcFV9HNqcwncsOGDWPjxo1ZnvP19c20L7MQhUmSxlLq8OHD7N2zh091BS+xY2Glw8Ut917GdHH56jVUiFescCAxH9dmQ6uCrJwWRmJunrYv9ZtTp9O/vx+VKlUydUiiDHiyDM7jspvjJ0RhkaSxFNJqtYwePIQ3tfa4GOE/sVvV7Cv8ZyU/PY1p15UzbtIo5XaEkbVtDi89l8q0qZNYs3Zd7hcIUUCVKlWSDyii2JDV04Vo5cqVeHh4YG1tjZeXF8ePHzfoui1btqAoSo4bv+dk3bp13P3zKr2wz9f1j7O01uFcKdXgXkZVhbh8Doc/yEdR8FxJYW9hZAtGa9m06dM815oTQoiSTpLGQrJ161YCAgKYNWsWp0+fplGjRnh7e3Pnzp0cr7t27RrvvPMOrVu3ztdzY2NjmRIwgeGpDlgZ4T+vW7W89TI+UixR8/ncGLUc2gIu2MnAQgV7KQ4gjKtWVRjeS8eY0UOkBI8QokyRpLGQLF26lMGDB+Pv788zzzzD6tWrKVeuHCEhIdleo9VqefPNN5kzZw61atXK13PnzplD9QQtrSl4r521jZbyLob3MkL+9p1OF4sNqjGTxgq6PMUuhKEmDlS5fDGcL774wtShCCFEkZGksRAkJydz6tQp2rdvrz+m0Who3749x44dy/a6uXPnUqlSJd566618Pffy5cus/N8HjNI6ohgh+XKrnpzna/Kz73S6WGxQMFLPjZTbEYXI3hbmDEvlnYARPHr0yNThCCFEkZCksRBERUWh1Wpxdc24bZ+rqyuRkZFZXnPkyBGCg4NZs2aNwc9JSkoiNjZW/xo9dBgd1HI8RcFryNnYanGqkLdeRh0QXYB6i7HYYGbEpFEWwYjC1K8zuNg/YMmSrPcNFkKI0kZWTxcDDx8+pH///qxZswYXFxeDrwsKCmLOnDkZjvUxwuIXAPfqyagqeUoaVTQ8LMB2gLHG3EpQh+w5LQqVRgNLArR0Hzsff/9BVKtWzdQhlTrRyVoSUotm3mg5cwUny6z3PhZCpJGksRC4uLhgZmbG7du3Mxy/ffs2bm6Z6yb++eefXLt2jW7duumP6XRpCY+5uTkXL17kqaeeynTdlClTCAgIICUlhZZNnuP//o6lF5n33syrcnZaHMrnb2g3v+V2IK2n0Zikp1EUNq9noUtrLZMCA/hs8+emDqdUiU7WsvxiNEWUM2KuwLi6TnlKHO/evcvMmTPZt28ft2/fpnz58jRq1IiZM2fywgsv4OHhwbhx4xg3bpz+mjNnzrBw4UJ+/PFH7t+/j5ubG88++yxDhw6la9euKIrCtWvXqFmzJhqNhhs3blClShX99REREVSrVg2tVsvVq1fx8PDIEJO3tzffffcdP//8M82bNy/ol0WIDGR4uhBYWlrStGlTwsLC9Md0Oh1hYWG0atUqU/t69epx7tw5wsPD9a/u3bvTtm1bwsPDs+3BsLKywsHBgU0bN5IScQcfHLE0wlxG9xpJ5GdRqIKuQNsBGjtplHI7oii8O1LHnj07OXr0qKlDKVUSUtUiSxgBUlXy3KvZs2dPzpw5w/r167l06RJ79uyhTZs23Lt3L8v2u3fvpmXLlsTFxbF+/XrOnz/P/v37ee2115g+fToxMTEZ2lepUoUNGzZkOLZ+/foMSeTjbty4wdGjRxk1alSOiy6FyC/paSwkAQEBDBgwgGbNmtGiRQuWL19OfHw8/v7+APj5+VGlShWCgoKwtramQYMGGa53cnICyHT8SVFRUcycMpXpqY6YGyFhtHNIxd4xf8mWhoL1NBZk5XUmlirYSTkUUfiqVILxvlrGjh7MLyfOodHIZ/GyIDo6msOHD3Po0CFefvllAGrUqEGLFi2ybB8fH89bb71Fly5d2LFjR4ZzTz/9NG+99VamEk4DBgxg3bp1TJkyRX9s3bp1DBgwgHfffTfTM9atW0fXrl0ZPnw4LVu2ZOnSpdjYGPnDuCjT5LdbIfHx8eG9995j5syZNG7cmPDwcPbv369fHHPjxg0iIiIK/JwZ06ZRP1lDC6P00qm410jOVy9juoLMadRiRoIRFvEAUm5HFKmx/eD2PxcJDQ01dSiiiNjZ2WFnZ8euXbtISsq9nu23337LvXv3CAwMzLaN8sQvre7du/PgwQOOHDkCpC2YfPDgQYapTOlUVWXdunX4+vpSr149PD09pSSUMDpJGgvRqFGjuH79OklJSfzyyy94eXnpzx06dCjHPzChoaHs2rUrx/ufO3eOdcHBjNAWfB4jgL2TFlt7bYGSrYL0NIKRehul3I4oYjbWMH+0lqmTxxMbG2vqcEQRMDc3JzQ0lPXr1+Pk5MQLL7zA1KlTOXv2bJbtL126BEDdunX1x06cOKFPPu3s7Ni7d2+GaywsLPD19dUPNYeEhODr64uFhUWm+3/33XckJCTg7e0NgK+vL8HBwUZ5r0Kkk6SxhFJVlTFDh/Gqzp5qZP4Fko875nsu4+MKMqcRINoYWwlKuR1hAq/9HzxVNZ758zIPG4rSqWfPnvzzzz/s2bOHjh07cujQIZ577jmDe5wbNmyon8ceHx9PamrmD7uDBg3i888/JzIyks8//5xBgwZlea+QkBB8fHwwN0+bdda3b19++ukn/vzzz3y/PyGeJEljCbV7925+PXESP9XBKPdzKJ9KOduCD+kWtKfwgVoOXUHnZuoASRpFEVMUWDJOy4cfLpc/1GWItbU1HTp0YMaMGRw9epSBAwcya9asTO1q164NwMWLF/XHrKys8PT0xNPTM9v7P/vss9SrV4++ffvy9NNPZznP/f79++zcuZNVq1Zhbm6Oubk5VapUITU1VRbECKOSpLEESkxMZPzwEbydao+dUf4TqlSukVzgstqPsEBXwHgeUs4oWwkqUqNRmECjuuDjrWNCwChThyJM5JlnniE+Pj7T8VdeeQVnZ2cWLVqU53sOGjSIQ4cOZdvLuGnTJqpWrcqvv/6aoQrH+++/T2hoKFqtfIgWxiGrp0ugZUuXYhkVTScqGeV+ThVSsS5X8CTLGPMR08ruGGHVs/Q0ChOZOVRH494H+O677zJsJSpKl3v37tGrVy8GDRpEw4YNsbe35+TJkyxevJgePXpkam9nZ8fatWvx8fGhS5cujBkzhtq1axMXF8f+/fsBMDPLukbk4MGD6dWrl76qxpOCg4N54403MvVCVqtWjSlTprB//366dOlSsDcsBNLTWOL8888/zJ8zl1GpjpgZoUdOv2LaCHeKpeDzEWOxQVPQiZVWKoqtlNsRplHJGaYM0jJuzJAs56iJ0sHOzg4vLy+WLVvGSy+9RIMGDZgxYwaDBw9mxYoVWV7z2muvcfToUcqVK4efnx9169bl//7v//j+++/ZsmULXbt2zfI6c3NzXFxc9PMVH3fq1Cl+/fVXevbsmemco6Mj7dq1kwUxwmgU9cnCUKJY8+vXj1vb9jJLW8Eo9ytfMYUatRMLfB8VOK16sFLnXaD7NOYaY8y+KVgwVbSYTYgu2D2EKIDkFPDyNWfMO8sYNUqGqnOSmJjI1atXqVmzJtbW/41WlIQdYYQoDbL7GcyKDE+XICdOnOCLbZ8Tqs28FWF+KIqKe/UkVChwn6WugPtOpyvwrjBSbkcUA5YWEDQmlSEzJ9GvXz+cnZ1NHVKJ42Rpxri6TrL3tBDFiCSNJYSqqowaPJjeOjvcjPSfzblSChaWxlh2ktbTWNAajWCMpFFFke0DRTHg/Tw0rZfErFnT+fDDVaYOp0RysjTDyUj1/oUQBSdzGkuITZs2ce33C/Q1UokdRVFxq5Zc8C7Gf2kKuO90ugInjTpFFsGIYkFRIGiMlrVrPuH33383dThCCFFgkjSWAHFxcUwcM5ahqfbYGOk/WQW3FMwtjNPLCOn7Thc8aUzGgmS1YENEUm5HFBf1asJbr+kYN3Z4pn2FhRCipJGksQQIWrCAirGJtMPWKPfTaFTcqiYbfW/mh6oRtgAE4pQC3kd6GkUxMnmQyplTR/nyyy9NHYoQQhSIJI3F3LVr11i25D1GaR1RcugXTEXlb1JINaB4jot7Mmbmxu/1MEZPIxSwdI+1ilJOenRE8VHeAWYM0TJh/HCSkpJMHU6xpdPJCIEQppCXURBZCFPMjRg8hJdSraiHVbZtUlEZQQQXSaYulqzCHfNsEkyNmYprFeP3MoJxFsJA2laCNZR8TreUXkZRDPn3gLU77/C//y0nMHCSqcMpViwtLdFoNPzzzz9UrFgRS0tLlML4BSWEyERVVe7evYuiKFhYWOTaXpLGYuyHH37g4Hff8RlVcmwXQSoXSQbgIslEkEo1sv6PX9E9GU0hVZUwVtIYq9qgUzSYkceeBw0orpI0iuLHzAwWjUulz6RZ+PkNwM3NOGWzSgONRkPNmjWJiIjgn3/+MXU4QpQ5iqJQtWrVbHckepwkjcWUVqtlyICB+OFIhVz+M7ljTl0s9T2N7tm0NzNXqVRIvYyJqjlajJON5n94WgUptyOKqZebwv81T2XqlEBC1m0wdTjFiqWlJdWrVyc1NVX2SRaiiFlYWBiUMIIkjcXW2rVrib8VQS9y75EwR2EV7kSQijvm2Q5NV6qcjKaQZrHGF3TxymNisEHJay8jSLkdUezNH62leb/PGDlqLE2bNjV1OMVK+vCYIUNkQgjTkIUwxVB0dDTT3glkRKojlgbO7DNHoRoW2SaM5hY6KlYunF5GMEJ9xcc8LEBhISnsLYozj8ow0kfLmNFDpASPEKLEkaSxGJozaxY1H2l5wYiJWGENS0PabjDRagFWPD8hpiDbEVaUFZiieHtnAPx15Ve2bt1q6lCEECJPJGksZi5evMhHK1cxMpcSO3lhYanDxS2l0JJGHRpijbDvdLp8l+6x0aFYS++NKN7sysG7I7RMnDCKhIQEU4cjhBAGk6SxmBk3YgRdVFtqYbwNV12rJhVawpjOWCunoQBD3dLLKEoIH29wd45m0aIgU4cihBAGk6SxGPn66685+sNhBuqMs780gKWVjgquqYWaNCqoRivsDRCPFVo1jwFrQHFNNVoMQhQmjQYWj9Py3pKF3Lhxw9ThCCGEQSRpfMLKlSvx8PDA2toaLy8vjh8/nm3bHTt20KxZM5ycnLC1taVx48Z8+umn+XpuSkoKY4cOw19rj6ORStdAWi9jYdOgGrWnERTileyLmWdNlZ5GUaI0bwA92ugInDjO1KEIIYRBJGl8zNatWwkICGDWrFmcPn2aRo0a4e3tzZ07d7Js7+zszLRp0zh27Bhnz57F398ff39/vvnmmzw/e8WHH5IacZfu2Bf0behZWetwrlS4vYzpHhpxTiPAw7zWatQpUqNRlDhzhuvY++UeDh8+bOpQhBAiV4oqdR/0vLy8aN68OStWrADS9kKtVq0ao0ePZvLkyQbd47nnnqNLly68++67Bj/37t27eFavwaxEB5oZcZi3Rp1HOFUomqRxtvZ1blDRaPeboNlHfeVmnq7RBESjVJXEUZQsS0Jhz7G6nDj1u8EFdoUQwhSkp/FfycnJnDp1ivbt2+uPaTQa2rdvz7Fjx3K9XlVVwsLCuHjxIi+99FKenj1t8mQappgZNWG0LqctsoQRDFvxrFN1PHx0D52a+zBytFoObV5Xj0tPoyiBRveF+3f/JCQkxNShCCFEjmRHmH9FRUWh1WpxdXXNcNzV1ZULFy5ke11MTAxVqlQhKSkJMzMzVq1aRYcOHbJtn5SURFLSf/MMz507x4bQ9YTojLsXrVv1ZKPeLze5zWnUqToO/b6eB/ERlLd1p039AWiU7D+zxGKNikJaFUgDlNNhxE1phCgy1lYwf1QqAVMn4OPjg4OD8RbCCSGEMUlPYwHZ29sTHh7OiRMnmD9/PgEBARw6dCjb9kFBQTg6OupfL774IrV15lTFeFtn2dhqcXIuul7GJNWc1Fw+f8QnPuBBfAQAD+IjiE98kGP7WMqhGJowAlSSXkZRcvVoC3VrJPDu3DmmDkUIIbIlSeO/XFxcMDMz4/bt2xmO3759Gze37HsBNRoNnp6eNG7cmAkTJvDGG28QFJR97bUpU6YQExNDTEwMGzZsoLyZJfOoZLT3AeBeI5minKlqyEpnW+vylLd1B6C8rTu21uVzbB+LDWaGJo0aUCRpFCWYoqSV4FmxYjmXL182dThCCJElSRr/ZWlpSdOmTQkLC9Mf0+l0hIWF0apVK4Pvo9PpMgw/P8nKygoHBwcsLCyY/s5EhmjtKW/EEju29qk4OBVdLyMYNp9Ro2hoU38ArzQcmuvQNJDHHWZUqChJoyi5VODZ2tD7VR3jA0aaOhwhhMiSzGl8TEBAAAMGDKBZs2a0aNGC5cuXEx8fj7+/PwB+fn5UqVJF35MYFBREs2bNeOqpp0hKSuKrr77i008/5aOPPsr1We+/9x4292LpWEi9jEWVNKrAAwP3ndYoGuxtKhjUNk+7wugUFBep0ShKJhVItYAodxgUBN2f+55vvvkGb29vU4cmhBAZSNL4GB8fH+7evcvMmTOJjIykcePG7N+/X7845saNG2g0//WQxcfHM2LECG7evImNjQ316tVj48aN+Pj45PicW7duEfTuPBZrndEYaX9pADuHVOwc8tfjlqqqXEvU4WGtwTwPGacOjdFrNEI+9p+WnkZRwqRPvoh2geiKoGrA2R6GTtYydvxQzv16GQsL4811FkKIgpI6jSbg26cPt7/4mhlaZyPeVaV2w0eUs9XmuZcxVVVpfzaGM/Famtia8V1DR4MTx1Q0fKt7li/UlvmIOXtmaFljttbg9pqF91CMt123EIVGBRTgUTmIqgwpT0wJTkmBXi3NGDvyfcaMGWuKEIUQIksyp7GI/fzzz2z/YjtDtcYtq2HvpMXWLu8JI8C1RB1n4tN66s7Ea7mWaPhQr7H3nU6nxYwEDMwC7XSSMIoSQQV0ZnCnCkR4ZE4YASws4J2FWmbOmkJUVFRRhyiEENmSpLEI6XQ6Rg8eQl+dPZWMOjNApXKNpHyvmPaw1tDENm0xThNbMzysDf+2MDP6vtP/iTP0vrJyWhRz6r+v2PLwd22Ic4KcZqa82AEaeSUzc+a0oglQCCEMIEljEfr000+5eeESfVTj7S8N4Oicio2tLt+LX8wVhe8aOnKqiVOehqbTFcacRkjbFSZXUm5HFGPpn+OSrOFWLbhXOa2n0RDvBGkJWRfMuXPnCi0+IYTIC0kai0hcXByTxo1naKoD1kb9sqtpK6YLeBdzRcHTxizPCSPkY9GKgaLVcuhyWyikqrJ9oCiWVECngbuV4Z9akJzHHxOP2uDzto4xY4ciU8+FEMWBJI1FZP68ebg+TKIthpWnMZSTSyrWNrmmVoWqsIanYyn371aCOVAVFFk5LYqR9KHoh/8ORT8sT45D0TkZMknl7LkT7N6924gRCiFE/kjSWAT++usvlr//PqO1jihGTe9U3KsXvJexoAovabTBoL2nK0qNRmF6+qFom7Sh6KjKoCvg1GUHJxg1M5XxE4aTmJhY0BCFEKJAJGksAhPGjKG9rhx1yH27vbxwrpSKlbVpexlTVDOSjbhv9uNisUFjyLCcs/Q0CtN6fFX0PzXzPhSdk9f8wNruLsuWLTXeTYUQIh8kaSxk33//Pd/t/4a3dI5Gva+iqLhVTzJ5L6Mh+07nV6xqk/viHnsptyNMJ30oOsYZbhiwKjo/zMwgcJGW+Qvm8M8//xj35kIIkQeSNBai1NRURg8ZSn+tA85G3F8awLlSChYWuc74K3SFtQgGDNxKUFZOCxNI/7CWYAd/e8J9d1CN+yOeQbMX4YUOWiZPeafwHiKEELmQpLEQrVmzhofXb9IT45bYUTQqbtWTjd6jkR/RhVRuBwxIGqXcjihi6T2LKZYQUQNu14DUwutsz2D8u1o+/3wrJ06cKJoHCiHEEyRpLCQPHjxg2sRARqQ6YGHk7M7FNQVzc9P3MmrREGtILcV8yjVpVFXZc1oUmfQSOvfc4KYnPLIr2udXqQEDxugYNXqwlOARQpiEJI2FZPaMGdROVGll5OFbjUbFtVpyvgt5G5MKxBbSymmAZCxIzmnMT1VQpEajKGT6eYsV4O86EFsBk/Xy+4+H63//zmeffWaaAIQQZZokjYXgjz/+4OPVHzPS6CV2wMU9GTOz4tHLUFj7Tj8uTsklKZVyO6KQpP+UxTuk1Vu872b4bi6FpZwtjHs3lYmBo4mLizNtMEKIMkeSRiNTVZVxI0bQTbXFA+Mu6zUzU3GtWjx6GSFt32mD94fOp9iciqErKlSQnkZhXBnqLdaEO9UgtRit0O/cC1yrxbJw4QJThyKEKGMkaTSyr776iuNHjjJQ52D0e1esnIymmP0XK6x9p9M9UMtlX1bIQUUpYPFkIdKlf5+lWEJk9bR6i0mFN2U33xQlrQTP+0uXcO3aNVOHI4QoQ4pZClKyJScnM3boMAZp7bE3cokdM3MdFSsXn17GdIW1G0y6WNUGXXbfprJyWhhB+pxFrXlace6bnpBgT7GoTpCdBk3B+3Ud70wca+pQhBBliCSNRvTB//4HkffoauQSOwCVqhS/XkYo3DqNkMPwtJmU2xEFl76Tyz23wivOXVjGzNaxf/8+fvjhB1OHIoQoI4phGlIy3b59m7kzZjJK64C5kf/qmFvoqOieUux6GaEIehqxQSGLxS46FWTltMgnFdBq4L4r3EhfEV3CfhtWdIPBE7WMHjsYrVZ+FoQQha+E/ZosvqZOmsRzqRY8Vwg9b65Vit+wNECqqiGxkPadTheLTdbfpKqCIjUaRR6l11p8UCktWYxxAbUE/xb0HQkxD6+yZs0aU4cihCgDSvCvy+LjzJkzfLZxE8O0xl/8YmGpw8WtePYypu07XbiBxeS00EZ6GoWB0nsWH1SE63UgumLhbvtXVCytIGBeKjNmTiQ6OtrU4QghSjlJGgtIVVVGDxlKT50dlQuh1821alKxnWNV2PMZc3yGooKz1GgU2dMvcDH7bxg6ulLpSBYf17YreNZ/xJy5s0wdihCilCs1SePKlSvx8PDA2toaLy8vjh8/nm3bNWvW0Lp1a8qXL0/58uVp3759ju1z8vnnn3Mx/Fd8VeP3Mlpa6ajgmlosexkBYgpxC8F02W4l6CjldkTW0kvnaM3/XeCSPgxdypLFdIoCExdp+eijlVy8eNHU4QghSrFSkTRu3bqVgIAAZs2axenTp2nUqBHe3t7cuXMny/aHDh2ib9++HDx4kGPHjlGtWjVeeeUVbt26lafnJiQkMGHkKAanOlCuEL6UbtWSjH5PY9Gh5Dx0bCQJWKFVs8iaK6UW+rNFyfJ4ncU7Vf5b4FKS5ywaqvYz8JqfyrjxI0wdihCiFFNUVS0ee9IVgJeXF82bN2fFihUA6HQ6qlWrxujRo5k8eXKu12u1WsqXL8+KFSvw8/Mz+LlzZs1i2/z3WKmtiMbIY8hWNlrqNU4otr2MqWgI09Vnq/p8oT9rudl6HEj874AZKK0eoXk9odCfLYo/lbQZHI/Kpc1VfGRLsZ3SUZii70G3JmZ8tnEPnTt3NnU4QohSqMR/Bk9OTubUqVO0b99ef0yj0dC+fXuOHTtm0D0SEhJISUnB2dnZ4Of+/fffLAoKYpTWwegJI4BbtWSj39OYimLf6XSZnqNTwUXmM5Z16XMW45zgZi2IqAmP7CiTCSOAUwUYPlXLuIBhpKSkmDocIUQpVOKTxqioKLRaLa6urhmOu7q6EhkZadA9Jk2aROXKlTMknk9KSkoiNjZW/xo/ejQvaK2pb+Q6hSqABThVKL5zGSFt3+nCrtGYLlq1zXhAyu2UWenDIqlmaWVzrteFu1UguWg+vxR7vd4CnRLBihUfmjoUIUQpVOKTxoJauHAhW7ZsYefOnVhbZ58EBQUF4ejoqH9t372b8gZ0dukAraIhVaMhVdGgy6YbJM7Ckhv2Tpx0q4r5/6US76IDy3/7Uopp8ljY+06ni1bLoX3yiyDldsqU9GQxsRzcrgo36qYNRetkMVQGFhYQuCiV2XOmcffuXVOHI4QoZUr8r1wXFxfMzMy4fft2huO3b9/Gzc0tx2vfe+89Fi5cyHfffUfDhg1zbDtlyhQCAgLQ6XS0fP5FPK5G83y5KlzW6dCoKhpVRUFFq2hI1piRYmZGksaMeAsrEswtiLewJN7CklhLa2IsrYm1tCbaypr71uV4YGWDVpO2tHPmi/t5tuUtNIqKmgTqaSvUIzYQYZaW4hejUdmi6mmMxRoVBX3qIOV2yoT0uYpaDTwsn/ZKsTJ1VMVfq/+D515IYfr0yXz8cbCpwxFClCIlPmm0tLSkadOmhIWF8eqrrwJpC2HCwsIYNWpUttctXryY+fPn880339CsWbNcn2NlZYWVlRUhISH8eTOSix0D+MbMuHUZm7j+zQSvg2iUtORIsQKlVRJqyyS4YY7uJys4Y5WWOGa1oriIFdWcxljKofDYei0nFaWUlk8p6x5flffINi1RTLAvGyugjemdBVp6tlzP8OGjady4sanDEUKUEiU+aQQICAhgwIABNGvWjBYtWrB8+XLi4+Px9/cHwM/PjypVqhAUFATAokWLmDlzJp999hkeHh76uY92dnbY2dll+5zY2FjGvxNI6jOdwMgJo6VZKmu7bM3Yo/YvRQFqpGJWIxW1RwLqSSvUw9Zw37S9j0XV0/gQG8we/5q4Srmd0ia9VzHV4t9eRSfQFu4OlaVa9aeg71AdY8YO5YdDP6MU5wnSQogSo1QkjT4+Pty9e5eZM2cSGRlJ48aN2b9/v35xzI0bN9Bo/uuq+Oijj0hOTuaNN97IcJ9Zs2Yxe/bsbJ/z7rvziLcsD1WeNfp7mNLqO2o739X3MmZHsVVRXk5EfSkRrpij+8kGzv3717UIex+1qsIjLIvkWRnqQZohi2BKCf3wsxnEOaa9kmwotnN4S5ohgSrdGp9mx44d9OzZ09ThCCFKgVJRp7EoXLlyhaefaUDqS8PBqbJR793U7QYHfVfmmjBmR41VUH+xRv3JGmI1RdL7GIs147QDCvch/6pGFHPMtv/7LxXl9Xg0Lxbfwucie+mJok4DcQ5piWJiGa2rWBR2boDgJZW48Mc1bGxkibkQomBkppCBRo0Zh656E6MnjNbmKYR03YxagF5CxUFF0+ERmhkP0AyKhdopgAqawvs8EFdE8xnhybmTCkpFWQRTkui39TNLG3r+pwZcqwdRVSCxDNdVLAo9fMG+/D3ef/89U4cihCgFJGk0wIEDB/ju+4Ponn7F6Pee8eI3eDjex0xT8ERIMQOlQQpmQ2PRTItGaZMINv/e18h/mItiC8F0meZOSrmdYi296DZAsiVEu8Ctmmk1FaMqS6JYlDQaCFykJWjhu3neJlUIIZ4kSWMuUlNTGTpiFNq6/wdW2S+SyY+WVa4xutmPmBVCj6BSQYemawKaOQ9QfB9CjX8Xjxjhv3javtPlCn4jA2kx4xH/ztvUqBhUIFMUqfTvYJ0CCXZwzw1u1IabteGBKySVQxJFE2nSCl7upCVwUoCpQxFClHClYiFMYVq9ejV/342B/zPuHsvlLJIJ7rIZVdWAUnhJkGIOynPJ8FwyaoQZuqNWcMIakklblp2PfFVFKbKV0+keYoMNKVBehyIfdUwufW6iCiRbpW3fl2CXVnxbPooWP+Pm6ni12XZ+/vlnWrZsaepwhBAllCSNObh37x6TpkwjtdEboDHul2pO66+pah9dKL2M2VHctZj1TEDtmlDAouFFt+90umi1HJWUWHCVoemilv4d+mSSmGibliTqpGZmsedeDQaO0zF6zBB++Tk8QzUJIYQwlPzmyMH06TNIcqgCbvWMet+Xq19heNOfijRhfJxiBZpWSWjeiUYzNgaeSwQzNW2nFQNo1KLbdzpd9L/D4VJup/A9/l2g+//27j0symrfA/h3LswMEiiGclGUm7ftDUMhvIQZbk6a6cmTZju8HLMbmor31EhTMdOklHJLXto7E7eJVsoxjeSYZpsUOKlgec0rmDdE1IF533X+GCFUFJgZeJnh+3meeWbmdb1rvvDU+HOtd61XbS4OrzYBLtxZwHIuCLjiZd50mwWj/Rg5XuDchVz84x//UDoKEdkpjjQ+wKFDh5C0ahWkJ9+0ab+uuttI6pcMSVYpVjSWsnTTcJUKKJRrd6TxOu5cQ8lFMDZTfgQRMF+PWGww75VY+ijRgdciOgjnBsDEeSbMmDERgwcPhqurq9KRiMjOcKSxAkIIvBYzDrL/44BrU5v2vfDJr+HpUqh4wXgvlYuAOuI21DOvQf16AdCh2Dzy+IDRx9oeabx+Zzqc2+1UX/nVzKXvS5zMI4XXmgD5zYHTQcCpdsD5AOCyN3Cj0Z37PLNgdChRzwE+foVYsGCe0lGIyA5xpLEC33zzDf798wGIyMk27TcqIBcjOu23aZ+2plIBaGWCplXhQzcNr+1rGkuLRrmxDM6I3q18QVi+xpPUgElnvgaxRG8eNSx95r2c6yeVyrwFz8ioDzBmzKsICAhQOhIR2RHeEeYeRqMR/kGtcaFJVyDAdqsMGxuKkDl6MRo737T4zi9KERKAXCfIe5whfnOCJNQYLw/HLeht9hkqtQyNVoLGSYJGK0OrN8FJVwInvQlafQmcDbfQudkp9O3/MzQyoJYAtfzggbCKfsP2MmhWlexCZd4s2+R0/6NEZ34WrK7pAd6JUUMufBqbU7YqHYWI7AhHGu+xdGkCLt6UAP9Q2/bbdzMaGW7ZXcEImDcNR4cSaDqUQLqkRuaxIDzlmQa11lzoqTUCao0MtUaCWiNDo5XN77UyNBqprJ2mtL1WgsZJhtbJdKdINPdRFefLvxHm3Yo00p0iUir3Wr7zKC0uJZQVm6o7f6aS/5yBV6qgFDCP+smlD425GJQ15V5rAUlrfi3deS2rYT9VMNU54+JkDOiyHd9//z369OmjdBwishMcaSwnLy8PLQMCUdwtGmgSaLN+B7fJxmfPfmGz/pQiYC5YzgQ52ChWaeFYvogsfV/+z8tdHPjA2r9068vyz6UP9Z+vZfWdKWIWfqSQtR8C3yYHIjvrCLRajh8QUeVYNJYTPXwE1qf/H6TQv9msTy+XAhwYvQSuOqNdjjLe67yfeQsWIrJvJcXAf4ZqMXViAmJiYpSOQ0R2gJfD37F//36sT06G1P5pG/YqsOLpjXBxKrb7glEAKGzIgpHIUTjpgMkLTHg7bhquXr2qdBwisgMsGmHeYueV12MgB/UCXBrbrN+RnTIQ6f8btGr73iam9Lq7y15KJyEiW4p4GmgbfBvvvDNb6ShEZAdYNAJITk7GwdyjEK2ftFmffg0v4/0+X8FRJv+vNDUvyCAix6FSAVMWSvj7yhXIyclROg4R1XH1/prGoqIitAgIwpWWvYEWj9mkT7VKxs5hnyDE+4xDjDLKGuB0a+7tR+SoFk5V4+KxntjxbTpUKq7OIqKK1fsyIH7hQhTIBsC3i836HNd1N0J9frf7grHUNQ8WjESO7PXpMvYf2Itt27YpHYWI6rB6PdJ4+vRpBLZqA1OPl4HGLWzSZ3uPC9gz/EM4aRyjYJTVwO+tHWyLHSK6T3ISsOGTZsg5dAI6nU7pOERUB9Xr8aPxEydB9ulgs4LRSW3CmgFfwFFmd0pXTLNgJHJ8/zUKUDvl46OPPlQ6ChHVUfW2aPzhhx/wzdatkP/yHzbr860eO9H20YsOMy2tAlDornQKIqoNWi0w5T0T5r47G/n5+UrHIaI6SNGiMTExEX5+fjAYDAgLC0NGRsYD2x4+fBiDBw+Gn58fVCoVEhISLP5cSZIw5rU3ILV+EnB2s7if8sJ8TmFSWLrd78dYSgAo1gHFBqWTEFFtebw3EBphwsyZ05SOQkR1kGJF44YNGxAbG4u4uDhkZmaic+fOiIqKwsWLFytsf/PmTQQEBGDhwoXw8rJuw8DVq1fj+Jk8IKinVf2UcnEyYs0z6yGEg8xL31HUELzNHVE9M2m+hHVffI6srCyloxBRHaPYQpiwsDB069YNy5cvBwDIsgxfX1+MGzcO06dPf+i5fn5+mDBhAiZMmFDtzy0oKICvXwAK2z4DNOvw4IayBBRdMW/2rX74RX0JfVMwqtO/oVE7xihjqXP+gLGB0imIqLZ9GKfCkYwQ/LA7g1vwEFEZRUYai4uLceDAAURGRv4ZRK1GZGQk9u3bV6Of/c6cubhpeBTwaf/gRrIEpCcCO943P8vSA5v29T+Cl4N/criCUVIDRmelUxCREl6eLPDb0Wxs3LhR6ShEVIcoUjReunQJkiTB09PzruOenp7Iy8uz2ecYjUZcv3697JGZmYlly5dD6vAMHrrEuegKcPWs+fXVs+b3FWhsKMLKfhsgO9i0tMCde0w71o9FRFXk4gq8OceESVNicPPmTaXjEFEd4dCrp+Pj49GwYcOyR0hICKRHmgINvR9+oktjwL25+bV78wfcj1og4a8pcDfccpjFL+Xd5igjWchkAk4dNT+T/RowDGjU5Cref/89paMQUR2hSNHo4eEBjUZz37YO+fn5Vi9yKW/GjBkoKChAQUEBNm3aBI2+AfD4iMpPVGuA3jHAX6eYnyu4pvH5dtl4rs1Bh9lepzwVODVNljGZgOingGcfMz+zcLRfajUw7T0J7y2Kx5kzZ5SOQ0R1gCJFo06nQ0hICNLS0sqOybKMtLQ0hIeH2+xz9Ho93Nzc4OzsjNgp0yC1jQQaNKzayWoN4NqkwoLR55Fr+KhvisNNS5fHrXbIEmdPAoczza8PZ5rfk/3qHAb0GSBh6rRYpaMQUR2g2PR0bGwskpKS8NlnnyE3Nxevv/46ioqKMGrUKADA8OHDMWPGjLL2xcXFyM7ORnZ2NoqLi3Hu3DlkZ2fj2LFjlX5WYuLHOHflBhBgfUGqgoykfhvg7FTikNPSACCrAJl3gSELNPcH2j9mft3+MfN7sm/j58j4+uvN2Lt3r9JRiEhhit57evny5Xj//feRl5eH4OBgfPTRRwgLCwMA9O7dG35+fli7di0A4NSpU/D3v/9voIiICKSnpz/wMy5duoQWfgG4FTwE8GpjdebXuuzF4sivrO6nqkwm4OR5wN/HfMeG2mA0AOcCa+ezyPGYTOYRxub+tfffLNWslYuAvantsD/jENRqh74UnogeQtGisTaMefVVrNm2F1JVrmWsRCv3i/hp1FLo1FKt3F/aZAL6jAEyc4HH2gHfJ9X8X8ICwE1XIN82t+MmIgdw+xYwqKsWc99egdGjRysdh4gU4tD/ZPzll1+wZvVaSO37Wd2XVi1hzYD10KhErRSMgHmEMTPX/Doz1/y+NkgcHSKicgzOQOw8E96aGYvr168rHYeIFOKwRaMQAq++MRZyYLh5QYuVpjz+PTo1PVerq6X9fcwjjID52d+ndj5X4vWMRHSPvoOAFkFFmD//XaWjEJFCHHZ6evPmzRjy0kiYIicBTtbtH9PF8wzSX1quyF1favuaRgHgiidQ4FHzn0VE9uXIL0D0UxocOngEQUFBSscholrmkEXj7du34RfYGvleYYB/qFV9GbQl+PfID9Cy4VWH3JPxXgLAZS/g+qNKJyGiumjum2oYL/fF119tVzoKEdUyh5yeXrJkCS4ZAfh1tbqvuU+kwq/hlXpRMJZy4O0nichKY2fLSP/f77Bz506loxBRLXO4kcbz58/DPzAIxWEjAQ/rNonr3eIotg5Nsk0wOyEAXPIGCiu6cyIREYB/LAO2rfPHL9m/Qct9lYjqDYcbaZw8ZRqkpm2sLhgb6m/h0/7JkOT6N+zmoHuWE5GNDHsVuFV8BitWrFA6ChHVIocqGjMyMvCvjRshtX/a6r4WP7UFHg1uKLL4RWmq+jMTT0QWcNIBU+JNmP32NFy+fFnpOERUSxymaJRlGWNeewNS0BNAA3er+hrY+iCGtc+Cth4WjABQT39sIqqGXlFAx25GxMXNUjoKEdUShyka161bh5yjJ4DWEVb109SlEIlRGyHX49UgapPSCYjIHkxeIOHTVUk4dOiQ0lGIqBY4xEKYGzduoIV/IK4GPAX4drGiJ4FNg9fgKb/f6tVq6fIEgCI34KKv0kmIyB4smq7C+SPd8d3OH6CqrdtlEZEiHGKkccGCeFxXuQDNg63qZ3jHnxEVcKTeFowAoAKgLVE6BRHZi9emCWT930/45ptvlI5CRDXM7kcaT506hVZt2sLU81XAvbnF/bRwu4L9/70EztqSWru3dF1l0gKn2yidgojsxcbVwOcfeSP38Eno9Xql4xBRDbH7kcY3J8RCbtbZqoJRBRlJ/TdAp5HqfcEIAFoTV1ATUdU9NwJwcr6IhISlSkchohpk10Vjeno6Uv9nO+S/RFnVz+she9Gj+cl6PS19L22x0gmIyF5oNMC0RRLmzX8HeXl5Sschohpit9PTkiShXYdOOKr1A9r0trifNo3z8ePIBOg1ks2yOYL85kBRQ6VTEJE9mfSSBj7uw7B2zT+VjkJENcBuRxo//fRTnDz/BxDU0+I+tGoJq59ZDw1vgXIXAUB/S+kURGRvJs6TsGHDeuzfv1/pKERUA+yyaLx27RomT5sOU/t+gMby+55OCtuFjk3Pc1q6Aiwaiai6mvsB0WMljHvzFdjpJBYRPYRdFo1vx72DWw08Ae+/WNxH56ZnMaP7Tqi58OU+KtwpGvmdT0TVNDoWOHHqIJKTk5WOQkQ2ZnfXNB45cgQdOnWG1Hss4OZlUR86jQn7RiQg0P0SRxkf4pw/YGygdAoisjdbk4HlcxrjtyOn4eLionQcIrIRuxtpfGPsmxAtu1lcMALAzB47ENT4DxaMDyEAON9QOgUR2aN+QwAPrwK891680lGIyIYsKhoTExPh5+cHg8GAsLAwZGRkPLT9xo0b0bZtWxgMBnTs2BGpqakWhU1NTcXuvT9CbtfXovMBIMznFCaG/i8Xv1RBg0KlExCRPVKrgamLJCxe8h5Onz6tdBwispFqF40bNmxAbGws4uLikJmZic6dOyMqKgoXL16ssP2PP/6IYcOGYfTo0cjKysKgQYMwaNCgat/gvri4GK/FjIPUti+gs2zOtIFTMVb1T4YQvJCxMioAhtuAhvs1EpEFOnUD+g6UMWXKeKWjEJGNVPuaxrCwMHTr1g3Lly8HAMiyDF9fX4wbNw7Tp0+/r/3QoUNRVFSErVu3lh17/PHHERwcjBUrVlT5c5cs+QDT5i2G9OSbgFpTnchl3u/zFV7p8iM0ao4yVoUAcMUTKPBQOgkR2aOLF4CBj2nwP6m70KtXL6XjEJGVqjXSWFxcjAMHDiAyMvLPDtRqREZGYt++fRWes2/fvrvaA0BUVNQD21fk4sWLmPV2HKSOz1hcMEa0OIbXQ/ayYKwm16vgKmoiskhTb2D0JAnjxo+BJPEGCkT2rlqbHF66dAmSJMHT0/Ou456enjhy5EiF5+Tl5VXY/mG3mjIajTAajWXvJ06ahNuuzQB3X6DkdnUiAwAaOBmx/pmVuF5U7VOpCDDlA7e5ipqILPCfw4Ev1xxDYmIixo0bB5WKlwcR2SvLd8auQfHx8ZgzZ879f/D12xb1dxOAzybrMhERkaUkjB8/HsOGDUOTJk2UDkNEFqpW0ejh4QGNRoP8/Py7jufn58PLq+ItcLy8vKrVHgBmzJiB2NjYsvfXrl1Dy5YtcebMGbi5uVUnco25fv06fH19mcmO8gDMVFXMVDXMVDUFBQVo0aIFdDqd0lGIyArVKhp1Oh1CQkKQlpaGQYMGATAvhElLS8PYsWMrPCc8PBxpaWmYMGFC2bGdO3ciPDz8gZ+j1+uh1+vvO+7m5lZnvgRLMVPl6loegJmqipmqhpmqhlPTRPat2tPTsbGxGDFiBLp27YrQ0FAkJCSgqKgIo0aNAgAMHz4czZo1Q3y8eVPX8ePHIyIiAkuWLEH//v2RnJyM/fv3Y+XKlbb9SYiIiIioxlS7aBw6dCj++OMPvP3228jLy0NwcDC2b99ettjl9OnTUKv/XJTdvXt3fPHFF5g1axbeeusttGrVClu2bEGHDh1s91MQERERUY2yaCHM2LFjHzgdnZ6eft+x559/Hs8//7wlHwXAPF0dFxdX4ZS1UpipcnUtD8BMVcVMVcNMVVMXMxFR9VV7c28iIiIiqn8suvc0EREREdUvLBqJiIiIqFIsGomIiIioUiwaiYiIiKhSLBqJiIiIqFJ1pmhMTEyEn58fDAYDwsLCkJGR8dD2GzduRNu2bWEwGNCxY0ekpqYqlufw4cMYPHgw/Pz8oFKpkJCQYNMslmRKSkpCr1694O7uDnd3d0RGRlb6O63pTCkpKejatSsaNWoEFxcXBAcH45///KeimcpLTk6GSqUqu9uRUpnWrl0LlUp118NgMCiaCTDfzjMmJgbe3t7Q6/Vo3bq1ov/f9e7d+77fk0qlQv/+/RXLBAAJCQlo06YNnJ2d4evri4kTJ+L27duKZSopKcHcuXMRGBgIg8GAzp07Y/v27TbNs3v3bgwYMAA+Pj5QqVTYsmVLpeekp6fjscceg16vR1BQENauXWvTTERUA0QdkJycLHQ6nVi9erU4fPiwGDNmjGjUqJHIz8+vsP3evXuFRqMRixYtEjk5OWLWrFnCyclJHDx4UJE8GRkZYvLkyWL9+vXCy8tLLF261CY5rMn04osvisTERJGVlSVyc3PFyJEjRcOGDcXZs2cVy7Rr1y6RkpIicnJyxLFjx0RCQoLQaDRi+/btimUqdfLkSdGsWTPRq1cvMXDgQJvlsSTTmjVrhJubm7hw4ULZIy8vT9FMRqNRdO3aVfTr10/s2bNHnDx5UqSnp4vs7GzFMl2+fPmu39GhQ4eERqMRa9asUSzTunXrhF6vF+vWrRMnT54U3377rfD29hYTJ05ULNPUqVOFj4+P2LZtmzh+/Lj4+OOPhcFgEJmZmTbLlJqaKmbOnClSUlIEALF58+aHtj9x4oRo0KCBiI2NFTk5OWLZsmU2/y4gIturE0VjaGioiImJKXsvSZLw8fER8fHxFbYfMmSI6N+//13HwsLCxKuvvqpInvJatmxZI0WjNZmEEMJkMglXV1fx2Wef1ZlMQgjRpUsXMWvWLEUzmUwm0b17d/Hpp5+KESNG2LxorG6mNWvWiIYNG9o0g7WZPvnkExEQECCKi4vrTKZ7LV26VLi6uoobN24olikmJkb06dPnrmOxsbGiR48eimXy9vYWy5cvv+vYc889J/72t7/ZLFN5VSkap06dKtq3b3/XsaFDh4qoqKgayUREtqH49HRxcTEOHDiAyMjIsmNqtRqRkZHYt29fhefs27fvrvYAEBUV9cD2NZ2nptki082bN1FSUoLGjRvXiUxCCKSlpeHXX3/FE088oWimuXPnomnTphg9erRNctgi040bN9CyZUv4+vpi4MCBOHz4sKKZvv76a4SHhyMmJgaenp7o0KEDFixYAEmSFMt0r1WrVuGFF16Ai4uLYpm6d++OAwcOlE0XnzhxAqmpqejXr59imYxG432XNzg7O2PPnj02yWSJmvwOJ6Kao3jReOnSJUiSVHbv6lKenp7Iy8ur8Jy8vLxqta/pPDXNFpmmTZsGHx+f+76oaztTQUEBHnnkEeh0OvTv3x/Lli1D3759Fcu0Z88erFq1CklJSTbJYItMbdq0werVq/HVV1/h888/hyzL6N69O86ePatYphMnTuDLL7+EJElITU3F7NmzsWTJEsybN0+xTOVlZGTg0KFDePnll22Sx9JML774IubOnYuePXvCyckJgYGB6N27N9566y3FMkVFReGDDz7A0aNHIcsydu7ciZSUFFy4cMEmmSzxoO/w69ev49atWwqlIqLKKF40Us1buHAhkpOTsXnz5hpZUFEdrq6uyM7Oxs8//4z58+cjNja2wvuV14bCwkJER0cjKSkJHh4eimSoSHh4OIYPH47g4GBEREQgJSUFTZo0wd///nfFMsmyjKZNm2LlypUICQnB0KFDMXPmTKxYsUKxTOWtWrUKHTt2RGhoqKI50tPTsWDBAnz88cfIzMxESkoKtm3bhnfffVexTB9++CFatWqFtm3bQqfTYezYsRg1ahTUan79E1H1aJUO4OHhAY1Gg/z8/LuO5+fnw8vLq8JzvLy8qtW+pvPUNGsyLV68GAsXLsR3332HTp06KZ5JrVYjKCgIABAcHIzc3FzEx8ejd+/etZ7p+PHjOHXqFAYMGFB2TJZlAIBWq8Wvv/6KwMDAWs1UEScnJ3Tp0gXHjh2zKos1mby9veHk5ASNRlN2rF27dsjLy0NxcTF0Ol2tZypVVFSE5ORkzJ0716oMtsg0e/ZsREdHl414duzYEUVFRXjllVcwc+ZMqws1SzI1adIEW7Zswe3bt3H58mX4+Phg+vTpCAgIsCqLNR70He7m5gZnZ2eFUhFRZRT/p6ZOp0NISAjS0tLKjsmyjLS0NISHh1d4Tnh4+F3tAWDnzp0PbF/TeWqapZkWLVqEd999F9u3b0fXrl3rRKZ7ybIMo9GoSKa2bdvi4MGDyM7OLns8++yzePLJJ5GdnQ1fX99az1QRSZJw8OBBeHt7W53H0kw9evTAsWPHyopqAPjtt9/g7e1tdcFoaaZSGzduhNFoxEsvvWR1Dmsz3bx5877CsLTQFkIokqmUwWBAs2bNYDKZsGnTJgwcONDqPJaqye9wIqpBSq/EEcK8hYRerxdr164VOTk54pVXXhGNGjUq22YkOjpaTJ8+vaz93r17hVarFYsXLxa5ubkiLi7O5lvuVCeP0WgUWVlZIisrS3h7e4vJkyeLrKwscfToUZvksSTTwoULhU6nE19++eVd25IUFhYqlmnBggVix44d4vjx4yInJ0csXrxYaLVakZSUpFime9XE6unqZpozZ4749ttvxfHjx8WBAwfECy+8IAwGgzh8+LBimU6fPi1cXV3F2LFjxa+//iq2bt0qmjZtKubNm6dYplI9e/YUQ4cOtVkOazLFxcUJV1dXsX79enHixAmxY8cOERgYKIYMGaJYpp9++kls2rRJHD9+XOzevVv06dNH+Pv7i6tXr9osU2FhYdl3IADxwQcfiKysLPH7778LIYSYPn26iI6OLmtfuuXOlClTRG5urkhMTOSWO0R2oE4UjUIIsWzZMtGiRQuh0+lEaGio+Omnn8r+LCIiQowYMeKu9v/6179E69athU6nE+3btxfbtm1TLM/JkycFgPseERERimVq2bJlhZni4uIUyzRz5kwRFBQkDAaDcHd3F+Hh4SI5Odmmeaqb6V41UTRWN9OECRPK2np6eop+/frZdE89SzIJIcSPP/4owsLChF6vFwEBAWL+/PnCZDIpmunIkSMCgNixY4dNc1iaqaSkRLzzzjsiMDBQGAwG4evrK9544w2bFmjVzZSeni7atWsn9Hq9ePTRR0V0dLQ4d+6cTfPs2rWrwu+b0hwjRoy47/tw165dIjg4WOh0OhEQEGDT/TWJqGaohLDBnAkREREROTTFr2kkIiIiorqPRSMRERERVYpFIxERERFVikUjEREREVWKRSMRERERVYpFIxERERFVikUjEREREVWKRSMRERERVYpFIxERERFVikUjEREREVWKRSMRERERVer/AU96zcTsgjqVAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for strat in ternary_strategies[::5]:\n",
    "    poly_data = get_3d_poly_data(strat, v.X(\"NI\"), v.X(\"CR\"), include_single_phase=True)\n",
    "\n",
    "    # Plot\n",
    "    from pycalphad.plot.utils import phase_legend\n",
    "    handles, colorlist = phase_legend(sorted(set(map(PolyData3D.get_phases_label, poly_data))))\n",
    "\n",
    "    import matplotlib.pyplot as plt\n",
    "    from matplotlib import patches\n",
    "    fig, ax = plt.subplots(subplot_kw=dict(projection=\"triangular\"))\n",
    "    for pd in poly_data:\n",
    "        polygon = patches.Polygon(pd.xy, closed=True, edgecolor=colorlist[pd.get_phases_label()], facecolor=colorlist[pd.get_phases_label()])\n",
    "        ax.add_patch(polygon)\n",
    "        ax.scatter(pd.centroid_2d[0], pd.centroid_2d[1], c='k', s=2, label='centroids')\n",
    "    ax.legend(handles=handles, loc=\"center left\", bbox_to_anchor=(1, 0.5))\n",
    "    ax.set_title(f\"T = {round(strat.conditions[v.T])} K\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if stitch manually, we'll need to resample each polygon to have the same points, align them, and join them across temperatures to make our 3D shell\n",
    "# resampling might be useful just to get cleaner triangulations too.\n",
    "\n",
    "import numpy as np\n",
    "from scipy.interpolate import interp1d\n",
    "\n",
    "def resample_loop(xyz: np.ndarray, n_points: int) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Resample a closed loop (Nx3) to have exactly n_points, spaced by arc length.\n",
    "    \"\"\"\n",
    "    xyz = np.asarray(xyz)\n",
    "    assert xyz.shape[1] == 3\n",
    "\n",
    "    # Compute cumulative arc length\n",
    "    deltas = np.diff(xyz, axis=0)\n",
    "    dists = np.linalg.norm(deltas, axis=1)\n",
    "    cumlen = np.insert(np.cumsum(dists), 0, 0)\n",
    "\n",
    "    # Normalize to [0, 1]\n",
    "    total_length = cumlen[-1]\n",
    "    t = cumlen / total_length\n",
    "\n",
    "    # Interpolate\n",
    "    resampled = []\n",
    "    t_new = np.linspace(0, 1, n_points)\n",
    "\n",
    "    for dim in range(3):\n",
    "        f = interp1d(t, xyz[:, dim], kind='linear')\n",
    "        resampled.append(f(t_new))\n",
    "\n",
    "    return np.stack(resampled, axis=-1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stiched together slices into 105 polys\n"
     ]
    }
   ],
   "source": [
    "# arrange the slices\n",
    "\n",
    "x = v.X(\"NI\")\n",
    "y = v.X(\"CR\")\n",
    "\n",
    "poly_data = []\n",
    "for strat in ternary_strategies:\n",
    "    slice_poly_data = get_3d_poly_data(strat, x, y, include_single_phase=True)\n",
    "    # resample so it's a little cleaner\n",
    "    slice_poly_data = [PolyData3D(resample_loop(poly.xyz, 100), poly.phases) for poly in slice_poly_data]\n",
    "    poly_data.append(slice_poly_data)\n",
    "\n",
    "\n",
    "def merge_poly_slices(poly_data: list[list[PolyData3D]], centroid_distance_tol=0.1) -> list[PolyData3D]:\n",
    "    \"\"\"Take a list containing collections of PolyData3D for each 2D slice we're merging\n",
    "\n",
    "    The output is a list of PolyData3D where each poly is the point boundary of a 3D volume.\n",
    "    \"\"\"\n",
    "    merged_polys : list[PolyData3D] = []  # eventually 2D poly in every slice should be merged into a 3D poly in this list\n",
    "    current_polys: list[PolyData3D] = poly_data[0]\n",
    "    for new_slice_polys in poly_data[1:]:\n",
    "        matched_polys  : list[PolyData3D] = []\n",
    "        unmatched_polys: list[PolyData3D] = []\n",
    "        new_polys_matched_indices = set()\n",
    "        # Process all current polys into either matched (extended to this slice) or unmatched (terminated in previous slice)\n",
    "        for existing_poly in current_polys:\n",
    "            idx_distances = existing_poly.distances(new_slice_polys)\n",
    "            if len(idx_distances) == 0:\n",
    "                # No matches, so this poly should be terminated\n",
    "                unmatched_polys.append(existing_poly)\n",
    "                continue\n",
    "            # simple approach:\n",
    "            # take the closest distance as a match\n",
    "            match_idx, match_poly = idx_distances[0]\n",
    "            # but if the centroid is too far, don't actually match it\n",
    "            if existing_poly.distance(match_poly) > centroid_distance_tol:\n",
    "                unmatched_polys.append(existing_poly)\n",
    "                continue\n",
    "            # we disregard the notion that we might have a region that splits or joins currently (those will just be new or terminated)\n",
    "            new_polys_matched_indices.add(match_idx)\n",
    "            # create a new poly with the points list with the matched poly, phases should match by definition\n",
    "            # new_xyz should be an accumulation of all other slices (e.g. at some Ts) and this new match in a new slice (e.g. different T)\n",
    "            new_xyz = np.concat([existing_poly.xyz, match_poly.xyz], axis=0)\n",
    "            pd = PolyData3D(new_xyz, existing_poly.phases)\n",
    "            matched_polys.append(pd)\n",
    "        unmatched_new_poly_indices = set(range(len(new_slice_polys))) - new_polys_matched_indices\n",
    "        for i in unmatched_new_poly_indices:\n",
    "            # these polys weren't used to extend an exist poly, treat as new polys\n",
    "            matched_polys.append(new_slice_polys[i])\n",
    "            new_polys_matched_indices.add(match_idx)  # shouldn't need to do this at this time, but just for future bookkeeping purposes\n",
    "        # Set up for the next iteration:\n",
    "        # At this point, we should have\n",
    "        # - all our extended, existing polys _and_ any new polys in matched_polys\n",
    "        #   these become current_polys for the next iter\n",
    "        current_polys = matched_polys\n",
    "        # - all our terminated polys are in unmatched_polys\n",
    "        merged_polys.extend(unmatched_polys)\n",
    "\n",
    "    return merged_polys\n",
    "\n",
    "poly_data = merge_poly_slices(poly_data)\n",
    "print(f\"Stiched together slices into {len(poly_data)} polys\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PyVista visualizations\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyvista as pv\n",
    "from copy import deepcopy\n",
    "\n",
    "def mesh_points(cloud: pv.PolyData) -> pv.PolyData:\n",
    "    cloud = deepcopy(cloud)\n",
    "    points = cloud.points\n",
    "    num_points_to_sum = 20 # should not be larger points in a slice, or the resample size, if resampled\n",
    "    average_inplane_point_distance = np.sqrt(np.sum(np.square(points[0:num_points_to_sum,:2] - points[1:num_points_to_sum+1,:2]), axis=1)).mean()\n",
    "    z_point_diffs = points[:-1,[2]] - points[1:,[2]]\n",
    "    average_outofplane_point_distance = np.abs(z_point_diffs[np.nonzero(z_point_diffs)]).mean()\n",
    "    # print(average_inplane_point_distance,average_outofplane_point_distance)\n",
    "    calc_zscale = average_inplane_point_distance / average_outofplane_point_distance  # this * z rescales it\n",
    "    # scale the z points\n",
    "    cloud.points[:, 2] = points[:, 2] * calc_zscale\n",
    "\n",
    "    # create a point cloud, do Delaunay 3D alpha shapes\n",
    "    cloud = pv.PolyData(points)\n",
    "    surf = cloud.delaunay_3d(alpha=0.5)\n",
    "    # extract the gometry (back to PolyData) so we can rescale the points back to our original data\n",
    "    mesh = surf.extract_geometry()\n",
    "\n",
    "    # rescale back to original\n",
    "    mesh.points[:,2] /= calc_zscale\n",
    "    return mesh\n",
    "\n",
    "def is_meshable(cloud: pv.PolyData) -> bool:\n",
    "    # Check that the dataset is 3D\n",
    "    if np.isclose(cloud.bounds.x_min, cloud.bounds.x_max):\n",
    "        return False\n",
    "    elif np.isclose(cloud.bounds.y_min, cloud.bounds.y_max):\n",
    "        return False\n",
    "    elif np.isclose(cloud.bounds.z_min, cloud.bounds.z_max):\n",
    "        return False\n",
    "    else:\n",
    "        return True\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "outdir = Path(\"pyvista-polys-2\")\n",
    "outdir.mkdir(exist_ok=True, parents=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[0m\u001b[33m2025-05-03 13:16:49.598 (  21.512s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12d8ffed0): 1 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:49.616 (  21.530s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bfef3f0): 5 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:49.660 (  21.574s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bff71d0): 13 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:49.700 (  21.614s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a076ce0): 19 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:49.730 (  21.644s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a0809c0): 1 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:49.774 (  21.688s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12d8ffed0): 46 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:49.821 (  21.735s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a0ab9b0): 53 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:49.867 (  21.781s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30d744190): 45 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:49.906 (  21.820s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a0272e0): 34 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:49.945 (  21.859s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x14d0d6800): 8 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:49.983 (  21.897s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30d748050): 33 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.015 (  21.929s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bfdfd20): 28 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.050 (  21.964s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a079640): 33 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.080 (  21.994s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bfeeea0): 35 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.135 (  22.049s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bf4a560): 36 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.189 (  22.102s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a07e8f0): 23 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.229 (  22.142s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12d8ffed0): 11 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.235 (  22.149s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x303547460): 3 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.244 (  22.158s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x303552a80): 19 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.254 (  22.168s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bff78b0): 16 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.274 (  22.188s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bfe0970): 18 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.285 (  22.199s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x3035504e0): 4 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.335 (  22.249s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bffa400): 30 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.386 (  22.300s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a0084b0): 18 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.447 (  22.361s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a07eb80): 14 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.545 (  22.459s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x14d0d6800): 36 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.604 (  22.518s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30d731b90): 25 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.746 (  22.660s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a082080): 9 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.786 (  22.700s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x3035498a0): 18 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.860 (  22.773s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bffc3a0): 52 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.909 (  22.823s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bfdfd20): 21 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.951 (  22.865s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a064920): 29 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.970 (  22.883s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a0084b0): 4 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.979 (  22.893s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a08a470): 3 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:50.988 (  22.902s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a082b40): 5 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.043 (  22.957s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a07a020): 15 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.064 (  22.978s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bfeb0a0): 1 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.077 (  22.991s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30d741ca0): 1 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.086 (  23.000s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12d8ffed0): 8 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.248 (  23.162s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12d8ffed0): 1 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.282 (  23.196s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bfeeea0): 3 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.304 (  23.218s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30d746960): 14 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.315 (  23.229s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12d8ffed0): 2 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.325 (  23.239s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30d720fd0): 4 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.502 (  23.416s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x303543ca0): 5 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.514 (  23.428s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12d8ffed0): 1 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.524 (  23.438s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bf4d230): 4 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.534 (  23.448s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bffb600): 4 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.544 (  23.458s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x12bfe1030): 3 degenerate triangles encountered, mesh quality suspect\u001b[0m\n",
      "\u001b[0m\u001b[33m2025-05-03 13:16:51.578 (  23.491s) [          15BA26]      vtkDelaunay3D.cxx:514   WARN| vtkDelaunay3D (0x30a0814f0): 5 degenerate triangles encountered, mesh quality suspect\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "# build and save point clouds and mesh files\n",
    "for i, pd in enumerate(poly_data):\n",
    "    points = pd.xyz\n",
    "    phase_label = pd.get_phases_label()\n",
    "    # we write index so files with the same phases are not duplicated\n",
    "    basename = f\"{i}--{phase_label}--\"\n",
    "\n",
    "    cloud = pv.PolyData(points)\n",
    "    cloud_filename = basename + \"cloud_polydata.ply\"\n",
    "    cloud.save(outdir / cloud_filename)\n",
    "\n",
    "    if is_meshable(cloud):\n",
    "        mesh = mesh_points(cloud)\n",
    "        mesh_filename = basename + \"mesh_polydata.ply\"\n",
    "        mesh.save(outdir / mesh_filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if you have all the files written, you can safely restart from here\n",
    "from dataclasses import dataclass\n",
    "from pycalphad.plot.utils import phase_legend\n",
    "import pyvista as pv\n",
    "import numpy as np\n",
    "from pathlib import Path\n",
    "\n",
    "@dataclass\n",
    "class PVHelper():\n",
    "    i: int\n",
    "    cloud: pv.PolyData\n",
    "    mesh: pv.PolyData | None\n",
    "    phase_label: str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "outdir = Path(\"pyvista-polys-2\")\n",
    "outdir.mkdir(exist_ok=True, parents=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load clouds and meshes\n",
    "pv_data: list[PVHelper] = []\n",
    "\n",
    "for filename in sorted(outdir.glob(\"*cloud_polydata.ply\")):\n",
    "    filename_str = filename.name\n",
    "    i = int(str(filename_str).split(\"--\")[0])\n",
    "    phase_label = filename_str.split(\"--\")[1]\n",
    "    cloud = pv.read(filename)\n",
    "    mesh_filename = outdir / filename_str.replace(\"cloud_polydata\", \"mesh_polydata\")\n",
    "    if mesh_filename.exists():\n",
    "        mesh = pv.read(mesh_filename)\n",
    "    else:\n",
    "        mesh = None\n",
    "    pv_data.append(PVHelper(i, cloud, mesh, phase_label))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[0m\u001b[33m2025-05-03 13:16:58.192 (  30.106s) [          15BA26]        vtkRenderer.cxx:1162  WARN| vtkOpenGLRenderer (0x17fbac000): Resetting view-up since view plane normal is parallel\u001b[0m\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7d71740f358d4466b37df5a19c9286a4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Widget(value='<iframe src=\"http://localhost:59423/index.html?ui=P_0x17f4c6050_0&reconnect=auto\" class=\"pyvista…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "handles, colorlist = phase_legend(sorted(set(map(lambda x: x.phase_label, pv_data))))\n",
    "\n",
    "# Plot point clouds\n",
    "plotter = pv.Plotter()\n",
    "# track our highest and lowest z indices so we can scale later\n",
    "upper_z_bound = -np.inf\n",
    "lower_z_bound = np.inf\n",
    "for pvh in pv_data:\n",
    "    cloud = pvh.cloud\n",
    "    mesh = pvh.mesh\n",
    "    phase_label = pvh.phase_label\n",
    "    upper_z_bound = max(cloud.bounds.z_max, upper_z_bound)\n",
    "    lower_z_bound = min(cloud.bounds.z_min, lower_z_bound)\n",
    "    plotter.add_points(cloud, color=colorlist[phase_label])\n",
    "zscale = 1 / (upper_z_bound - lower_z_bound)\n",
    "plotter.set_scale(zscale=zscale)  # pyvista uses a cartesian box to plot, we need to scale the z so that the axis is similar size to our [0, 1] composition domain\n",
    "plotter.show_bounds(location='all')\n",
    "plotter.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[0m\u001b[33m2025-05-03 13:16:59.128 (  31.042s) [          15BA26]        vtkRenderer.cxx:1162  WARN| vtkOpenGLRenderer (0x12eb68200): Resetting view-up since view plane normal is parallel\u001b[0m\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ae930373d89a464dbfe015120917dd03",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Widget(value='<iframe src=\"http://localhost:59423/index.html?ui=P_0x30107a790_1&reconnect=auto\" class=\"pyvista…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pycalphad.plot.utils import phase_legend\n",
    "handles, colorlist = phase_legend(sorted(set(map(lambda x: x.phase_label, pv_data))))\n",
    "\n",
    "# Plot point clouds\n",
    "plotter = pv.Plotter()\n",
    "# track our highest and lowest z indices so we can scale later\n",
    "upper_z_bound = -np.inf\n",
    "lower_z_bound = np.inf\n",
    "for pvh in pv_data:\n",
    "    mesh = pvh.mesh\n",
    "    phase_label = pvh.phase_label\n",
    "    if mesh is None:\n",
    "        continue\n",
    "    upper_z_bound = max(mesh.bounds.z_max, upper_z_bound)\n",
    "    lower_z_bound = min(mesh.bounds.z_min, lower_z_bound)\n",
    "    plotter.add_mesh(mesh, color=colorlist[phase_label])\n",
    "zscale = 1 / (upper_z_bound - lower_z_bound)\n",
    "plotter.set_scale(zscale=zscale)  # pyvista uses a cartesian box to plot, we need to scale the z so that the axis is similar size to our [0, 1] composition domain\n",
    "plotter.show_bounds(location='all')\n",
    "plotter.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
 }
diff --git a/meshes.html b/meshes.html
 <!DOCTYPE html>
 <html>
  <head>
    <meta http-equiv="Content-type" content="text/html; charset=utf-8"/>
    <meta name="viewport" content="width=device-width, height=device-height, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no">
  </head>
  <body>
    <div class="content"></div>
 <script type="text/javascript">
 !function(){var e={334:function(){const e=document.querySelector("head");e&&[16,32,96,160,196].forEach((t=>{const n=document.createElement("link");n.setAttribute("rel","icon"),n.setAttribute("href",`https://kitware.github.io/vtk-js/icon/favicon-${t}x${t}.png`),n.setAttribute("sizes",`${t}x${t}`),n.setAttribute("type","image/png"),e.appendChild(n)}))},819:function(e,t,n){"use strict";n.r(t),n.d(t,{initLocalFileLoader:function(){return cI},load:function(){return lI}});var r={};n.r(r),n.d(r,{add:function(){return Q},adjoint:function(){return v},clone:function(){return u},copy:function(){return d},create:function(){return c},determinant:function(){return y},equals:function(){return re},exactEquals:function(){return ne},frob:function(){return Z},fromQuat:function(){return k},fromQuat2:function(){return V},fromRotation:function(){return O},fromRotationTranslation:function(){return D},fromRotationTranslationScale:function(){return _},fromRotationTranslationScaleOrigin:function(){return F},fromScaling:function(){return P},fromTranslation:function(){return w},fromValues:function(){return p},fromXRotation:function(){return R},fromYRotation:function(){return M},fromZRotation:function(){return E},frustum:function(){return G},getRotation:function(){return N},getScaling:function(){return B},getTranslation:function(){return L},identity:function(){return g},invert:function(){return h},lookAt:function(){return q},mul:function(){return oe},multiply:function(){return T},multiplyScalar:function(){return ee},multiplyScalarAndAdd:function(){return te},ortho:function(){return K},orthoNO:function(){return j},orthoZO:function(){return $},perspective:function(){return z},perspectiveFromFieldOfView:function(){return H},perspectiveNO:function(){return U},perspectiveZO:function(){return W},rotate:function(){return C},rotateX:function(){return S},rotateY:function(){return A},rotateZ:function(){return I},scale:function(){return x},set:function(){return f},str:function(){return Y},sub:function(){return ae},subtract:function(){return J},targetTo:function(){return X},translate:function(){return b},transpose:function(){return m}});var o={};n.r(o),n.d(o,{add:function(){return Me},adjoint:function(){return me},clone:function(){return le},copy:function(){return ce},create:function(){return ie},determinant:function(){return he},equals:function(){return Be},exactEquals:function(){return Le},frob:function(){return Re},fromMat2d:function(){return Ae},fromMat4:function(){return se},fromQuat:function(){return Ie},fromRotation:function(){return Ce},fromScaling:function(){return Se},fromTranslation:function(){return xe},fromValues:function(){return ue},identity:function(){return pe},invert:function(){return ge},mul:function(){return Ne},multiply:function(){return ve},multiplyScalar:function(){return De},multiplyScalarAndAdd:function(){return Ve},normalFromMat4:function(){return we},projection:function(){return Pe},rotate:function(){return Te},scale:function(){return be},set:function(){return de},str:function(){return Oe},sub:function(){return _e},subtract:function(){return Ee},translate:function(){return ye},transpose:function(){return fe}}),n(334);var a=1e-6,i="undefined"!=typeof Float32Array?Float32Array:Array;Math.random;var s=Math.PI/180;function l(e){return e*s}function c(){var e=new i(16);return i!=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 u(e){var t=new i(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 d(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 p(e,t,n,r,o,a,s,l,c,u,d,p,f,g,m,h){var v=new i(16);return v[0]=e,v[1]=t,v[2]=n,v[3]=r,v[4]=o,v[5]=a,v[6]=s,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 f(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 g(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 m(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 h(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],y=n*s-r*i,T=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,P=d*h-p*m,O=d*v-f*m,R=p*v-f*h,M=y*R-T*O+b*P+x*w-C*I+S*A;return M?(M=1/M,e[0]=(s*R-l*O+c*P)*M,e[1]=(o*O-r*R-a*P)*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*T)*M,e[7]=(u*S-p*b+f*T)*M,e[8]=(i*O-s*w+c*A)*M,e[9]=(r*w-n*O-a*A)*M,e[10]=(g*C-m*b+v*y)*M,e[11]=(d*b-u*C-f*y)*M,e[12]=(s*I-i*P-l*A)*M,e[13]=(n*P-r*I+o*A)*M,e[14]=(m*T-g*x-h*y)*M,e[15]=(u*x-d*T+p*y)*M,e):null}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];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 T(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],y=t[15],T=n[0],b=n[1],x=n[2],C=n[3];return e[0]=T*r+b*s+x*d+C*m,e[1]=T*o+b*l+x*p+C*h,e[2]=T*a+b*c+x*f+C*v,e[3]=T*i+b*u+x*g+C*y,T=n[4],b=n[5],x=n[6],C=n[7],e[4]=T*r+b*s+x*d+C*m,e[5]=T*o+b*l+x*p+C*h,e[6]=T*a+b*c+x*f+C*v,e[7]=T*i+b*u+x*g+C*y,T=n[8],b=n[9],x=n[10],C=n[11],e[8]=T*r+b*s+x*d+C*m,e[9]=T*o+b*l+x*p+C*h,e[10]=T*a+b*c+x*f+C*v,e[11]=T*i+b*u+x*g+C*y,T=n[12],b=n[13],x=n[14],C=n[15],e[12]=T*r+b*s+x*d+C*m,e[13]=T*o+b*l+x*p+C*h,e[14]=T*a+b*c+x*f+C*v,e[15]=T*i+b*u+x*g+C*y,e}function b(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 x(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 C(e,t,n,r){var o,i,s,l,c,u,d,p,f,g,m,h,v,y,T,b,x,C,S,A,I,w,P,O,R=r[0],M=r[1],E=r[2],D=Math.hypot(R,M,E);return D<a?null:(R*=D=1/D,M*=D,E*=D,o=Math.sin(n),s=1-(i=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],y=t[10],T=t[11],b=R*R*s+i,x=M*R*s+E*o,C=E*R*s-M*o,S=R*M*s-E*o,A=M*M*s+i,I=E*M*s+R*o,w=R*E*s+M*o,P=M*E*s-R*o,O=E*E*s+i,e[0]=l*b+p*x+h*C,e[1]=c*b+f*x+v*C,e[2]=u*b+g*x+y*C,e[3]=d*b+m*x+T*C,e[4]=l*S+p*A+h*I,e[5]=c*S+f*A+v*I,e[6]=u*S+g*A+y*I,e[7]=d*S+m*A+T*I,e[8]=l*w+p*P+h*O,e[9]=c*w+f*P+v*O,e[10]=u*w+g*P+y*O,e[11]=d*w+m*P+T*O,t!==e&&(e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15]),e)}function S(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 A(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 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[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 w(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 O(e,t,n){var r,o,i,s=n[0],l=n[1],c=n[2],u=Math.hypot(s,l,c);return u<a?null:(s*=u=1/u,l*=u,c*=u,r=Math.sin(t),i=1-(o=Math.cos(t)),e[0]=s*s*i+o,e[1]=l*s*i+c*r,e[2]=c*s*i-l*r,e[3]=0,e[4]=s*l*i-c*r,e[5]=l*l*i+o,e[6]=c*l*i+s*r,e[7]=0,e[8]=s*c*i+l*r,e[9]=l*c*i-s*r,e[10]=c*c*i+o,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,e)}function R(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 M(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 E(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,y=i*c;return e[0]=1-(f+m),e[1]=d+y,e[2]=p-v,e[3]=0,e[4]=d-y,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 V(e,t){var n=new i(3),r=-t[0],o=-t[1],a=-t[2],s=t[3],l=t[4],c=t[5],u=t[6],d=t[7],p=r*r+o*o+a*a+s*s;return p>0?(n[0]=2*(l*s+d*r+c*a-u*o)/p,n[1]=2*(c*s+d*o+u*r-l*a)/p,n[2]=2*(u*s+d*a+l*o-c*r)/p):(n[0]=2*(l*s+d*r+c*a-u*o),n[1]=2*(c*s+d*o+u*r-l*a),n[2]=2*(u*s+d*a+l*o-c*r)),D(e,t,n),e}function L(e,t){return e[0]=t[12],e[1]=t[13],e[2]=t[14],e}function B(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 N(e,t){var n=new i(3);B(n,t);var r=1/n[0],o=1/n[1],a=1/n[2],s=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=s+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):s>d&&s>m?(v=2*Math.sqrt(1+s-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-s-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-s-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,y=s*c,T=s*u,b=r[0],x=r[1],C=r[2];return e[0]=(1-(g+h))*b,e[1]=(p+T)*b,e[2]=(f-y)*b,e[3]=0,e[4]=(p-T)*x,e[5]=(1-(d+h))*x,e[6]=(m+v)*x,e[7]=0,e[8]=(f+y)*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 F(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,y=l*c,T=l*u,b=l*d,x=r[0],C=r[1],S=r[2],A=o[0],I=o[1],w=o[2],P=(1-(m+v))*x,O=(f+b)*x,R=(g-T)*x,M=(f-b)*C,E=(1-(p+v))*C,D=(h+y)*C,V=(g+T)*S,L=(h-y)*S,B=(1-(p+m))*S;return e[0]=P,e[1]=O,e[2]=R,e[3]=0,e[4]=M,e[5]=E,e[6]=D,e[7]=0,e[8]=V,e[9]=L,e[10]=B,e[11]=0,e[12]=n[0]+A-(P*A+M*I+V*w),e[13]=n[1]+I-(O*A+E*I+L*w),e[14]=n[2]+w-(R*A+D*I+B*w),e[15]=1,e}function k(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 G(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 U(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 z=U;function W(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 H(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 j(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=j;function $(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 q(e,t,n,r){var o,i,s,l,c,u,d,p,f,m,h=t[0],v=t[1],y=t[2],T=r[0],b=r[1],x=r[2],C=n[0],S=n[1],A=n[2];return Math.abs(h-C)<a&&Math.abs(v-S)<a&&Math.abs(y-A)<a?g(e):(d=h-C,p=v-S,f=y-A,o=b*(f*=m=1/Math.hypot(d,p,f))-x*(p*=m),i=x*(d*=m)-T*f,s=T*p-b*d,(m=Math.hypot(o,i,s))?(o*=m=1/m,i*=m,s*=m):(o=0,i=0,s=0),l=p*s-f*i,c=f*o-d*s,u=d*i-p*o,(m=Math.hypot(l,c,u))?(l*=m=1/m,c*=m,u*=m):(l=0,c=0,u=0),e[0]=o,e[1]=l,e[2]=d,e[3]=0,e[4]=i,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+i*v+s*y),e[13]=-(l*h+c*v+u*y),e[14]=-(d*h+p*v+f*y),e[15]=1,e)}function X(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 Y(e){return"mat4("+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 Z(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 Q(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 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,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 te(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 ne(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 re(e,t){var n=e[0],r=e[1],o=e[2],i=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],y=e[15],T=t[0],b=t[1],x=t[2],C=t[3],S=t[4],A=t[5],I=t[6],w=t[7],P=t[8],O=t[9],R=t[10],M=t[11],E=t[12],D=t[13],V=t[14],L=t[15];return Math.abs(n-T)<=a*Math.max(1,Math.abs(n),Math.abs(T))&&Math.abs(r-b)<=a*Math.max(1,Math.abs(r),Math.abs(b))&&Math.abs(o-x)<=a*Math.max(1,Math.abs(o),Math.abs(x))&&Math.abs(i-C)<=a*Math.max(1,Math.abs(i),Math.abs(C))&&Math.abs(s-S)<=a*Math.max(1,Math.abs(s),Math.abs(S))&&Math.abs(l-A)<=a*Math.max(1,Math.abs(l),Math.abs(A))&&Math.abs(c-I)<=a*Math.max(1,Math.abs(c),Math.abs(I))&&Math.abs(u-w)<=a*Math.max(1,Math.abs(u),Math.abs(w))&&Math.abs(d-P)<=a*Math.max(1,Math.abs(d),Math.abs(P))&&Math.abs(p-O)<=a*Math.max(1,Math.abs(p),Math.abs(O))&&Math.abs(f-R)<=a*Math.max(1,Math.abs(f),Math.abs(R))&&Math.abs(g-M)<=a*Math.max(1,Math.abs(g),Math.abs(M))&&Math.abs(m-E)<=a*Math.max(1,Math.abs(m),Math.abs(E))&&Math.abs(h-D)<=a*Math.max(1,Math.abs(h),Math.abs(D))&&Math.abs(v-V)<=a*Math.max(1,Math.abs(v),Math.abs(V))&&Math.abs(y-L)<=a*Math.max(1,Math.abs(y),Math.abs(L))}var oe=T,ae=J;function ie(){var e=new i(9);return i!=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 se(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 le(e){var t=new i(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 ce(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 ue(e,t,n,r,o,a,s,l,c){var u=new i(9);return u[0]=e,u[1]=t,u[2]=n,u[3]=r,u[4]=o,u[5]=a,u[6]=s,u[7]=l,u[8]=c,u}function de(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 pe(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 fe(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 ge(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 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];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 he(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 ve(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],y=n[6],T=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]=y*r+T*i+b*c,e[7]=y*o+T*s+b*u,e[8]=y*a+T*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 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=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 be(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 xe(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 Ce(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 Se(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 Ae(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 Ie(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 we(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],y=n*s-r*i,T=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,P=d*h-p*m,O=d*v-f*m,R=p*v-f*h,M=y*R-T*O+b*P+x*w-C*I+S*A;return M?(M=1/M,e[0]=(s*R-l*O+c*P)*M,e[1]=(l*w-i*R-c*I)*M,e[2]=(i*O-s*w+c*A)*M,e[3]=(o*O-r*R-a*P)*M,e[4]=(n*R-o*w+a*I)*M,e[5]=(r*w-n*O-a*A)*M,e[6]=(m*S-h*C+v*x)*M,e[7]=(h*b-g*S-v*T)*M,e[8]=(g*C-m*b+v*y)*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 Oe(e){return"mat3("+e[0]+", "+e[1]+", "+e[2]+", "+e[3]+", "+e[4]+", "+e[5]+", "+e[6]+", "+e[7]+", "+e[8]+")"}function Re(e){return Math.hypot(e[0],e[1],e[2],e[3],e[4],e[5],e[6],e[7],e[8])}function Me(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 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 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 Ve(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 Le(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 Be(e,t){var n=e[0],r=e[1],o=e[2],i=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],y=t[6],T=t[7],b=t[8];return Math.abs(n-p)<=a*Math.max(1,Math.abs(n),Math.abs(p))&&Math.abs(r-f)<=a*Math.max(1,Math.abs(r),Math.abs(f))&&Math.abs(o-g)<=a*Math.max(1,Math.abs(o),Math.abs(g))&&Math.abs(i-m)<=a*Math.max(1,Math.abs(i),Math.abs(m))&&Math.abs(s-h)<=a*Math.max(1,Math.abs(s),Math.abs(h))&&Math.abs(l-v)<=a*Math.max(1,Math.abs(l),Math.abs(v))&&Math.abs(c-y)<=a*Math.max(1,Math.abs(c),Math.abs(y))&&Math.abs(u-T)<=a*Math.max(1,Math.abs(u),Math.abs(T))&&Math.abs(d-b)<=a*Math.max(1,Math.abs(d),Math.abs(b))}var Ne=ve,_e=Ee,Fe=n(152),ke=n.n(Fe),Ge=n(177);const Ue=n.n(Ge)()(),ze={vtkObject:()=>null};function We(e){if(null==e)return e;if(e.isA)return e;if(!e.vtkClass)return Ue.console&&Ue.console.error&&Ue.console.error("Invalid VTK object"),null;const t=ze[e.vtkClass];if(!t)return Ue.console&&Ue.console.error&&Ue.console.error(`No vtk class found for Object of type ${e.vtkClass}`),null;const n={...e};Object.keys(n).forEach((e=>{n[e]&&"object"==typeof n[e]&&n[e].vtkClass&&(n[e]=We(n[e]))}));const r=t(n);return r&&r.modified&&r.modified(),r}We.register=function(e,t){ze[e]=t};class He extends Array{push(){for(let e=0;e<arguments.length;e++)this.includes(arguments[e])||super.push(arguments[e]);return this.length}}let je=0;const Ke=Symbol("void"),$e={};function qe(){}["log","debug","info","warn","error","time","timeEnd","group","groupEnd"].forEach((e=>{$e[e]=qe})),Ue.console=console.hasOwnProperty("log")?console:$e;const Xe={debug:qe,error:Ue.console.error||qe,info:Ue.console.info||qe,log:Ue.console.log||qe,warn:Ue.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("_"===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=["TB","GB","MB","KB"];let o=Number(e),a="B";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]:" ";const n=[];let r=e;for(;r>1e3;)n.push(("000"+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 Object.values(ot).some((t=>e instanceof t))}function gt(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}function mt(e){return e&&e.isA?e.getState():e}function ht(e){setTimeout(e,0)}function vt(e,t){const n=performance.now();e.finally((()=>{const e=performance.now()-n;t(e)}))}function yt(){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=++je),"classHierarchy"in t){if(!(t.classHierarchy instanceof He)){const e=new He;for(let n=0;n<t.classHierarchy.length;n++)e.push(t.classHierarchy[n]);t.classHierarchy=e}}else t.classHierarchy=new He("vtkObject");function r(e){n[e]=null}function o(e){return Object.freeze({unsubscribe:function(){r(e)}})}return e.isDeleted=()=>!!t.deleted,e.modified=r=>{t.deleted?et("instance deleted - cannot call any method"):r&&r<e.getMTime()||(t.mtime=++je,n.forEach((t=>t&&t(e))))},e.onModified=e=>{if(t.deleted)return et("instance deleted - cannot call any method"),null;const r=n.length;return n.push(e),o(r)},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!==["mtime"].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]||"_"===e[0]?delete n[e]:n[e].isA?n[e]=n[e].getState():Array.isArray(n[e])?n[e]=n[e].map(mt):ft(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(),i=Object.keys(o).sort();i.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(", ")}`),e.modified()},e.toJSON=function(){return e.getState()},e}const Tt={object:(e,t,n)=>function(){return{...t[n.name]}}};function bt(e,t,n){n.forEach((n=>{if("object"==typeof n){const r=Tt[n.type];e[`get${lt(n.name)}`]=r?r(e,t,n):()=>t[n.name]}else e[`get${lt(n)}`]=()=>t[n]}))}const xt={enum(e,t,n){const r=`_on${lt(n.name)}Changed`;return o=>{if("string"==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("Set Enum with invalid string argument")}if("number"==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("Set Enum outside numeric range")}return!1}throw et(`Set Enum with invalid argument (String/Number) ${n}, ${o}`),new TypeError("Set Enum with invalid argument (String/Number)")}},object(e,t,n){1===n.params?.length&&tt('Setter of type "object" with a single "param" 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 Ct(e){if("object"==typeof e){const t=xt[e.type];if(t)return(n,r)=>t(n,r,e);throw et(`No setter for field ${e}`),new TypeError("No setter for field")}return function(t,n){const r=`_on${lt(e)}Changed`;return function(o){if(n.deleted)return et("instance deleted - cannot call any method"),!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 St(e,t,n){n.forEach((n=>{"object"==typeof n?e[`set${lt(n.name)}`]=Ct(n)(e,t):e[`set${lt(n)}`]=Ct(n)(e,t)}))}function At(e,t,n){bt(e,t,n),St(e,t,n)}function It(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 wt(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("instance deleted - cannot call any method"),!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 Pt(e,t,n,r){let o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:void 0;It(e,t,n),wt(e,t,n,r,o)}function Ot(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 Rt(e,t,n,r){function o(n){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;t.deleted?et("instance deleted - cannot call any method"):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("instance deleted - cannot call any method");else{if(r>=t.numberOfInputs){let n=`algorithm ${e.getClassName()} only has `;return n+=`${t.numberOfInputs}`,n+=" input ports. To add more input ports, use addInputConnection()",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("instance deleted - cannot call any method"),null):(e.shouldUpdate()&&e.update(),t.output[n])}if(t.inputData?t.inputData=t.inputData.map(We):t.inputData=[],t.inputConnection?t.inputConnection=t.inputConnection.map(We):t.inputConnection=[],t.output?t.output=t.output.map(We):t.output=[],t.inputArrayToProcess?t.inputArrayToProcess=t.inputArrayToProcess.map(We):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("instance deleted - cannot call any method"):o(e,i())},e.addInputConnection=function(e){t.deleted?et("instance deleted - cannot call any method"):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.shouldUpdate()&&e.requestData&&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]:"Scalars";for(;t.inputArrayToProcess.length<e;)t.inputArrayToProcess.push(null);t.inputArrayToProcess[e]={arrayName:n,fieldAssociation:r,attributeType:o}}}const Mt=Symbol("Event abort");function Et(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)}}function s(e){return Object.freeze({unsubscribe:function(){i(e)}})}e[`invoke${lt(n)}`]=function(){if(t.deleted)return void et("instance deleted - cannot call any method");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)===Mt)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("instance deleted - cannot call any method"),null;const i=a++;return r.push([i,e,o]),r.sort(((e,t)=>t[2]-e[2])),s(i)},e.delete=()=>{o(),r.forEach((e=>{let[t]=e;return i(t)}))}}function Dt(e,t){const n=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};const n={},r={};return e(r,n,t),Object.freeze(r)};return t&&We.register(t,n),n}function Vt(){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 Lt(e){return e&&e.isA&&e.isA("vtkObject")}function Bt(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[],r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[];if(Lt(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=>{Bt(e,t,n,r)})):Bt(o,t,n,r)}))}return n}function Nt(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=()=>{o=null,n||e.apply(l,i)},u=n&&!o;clearTimeout(o),o=setTimeout(c,t),u&&e.apply(l,i)};return a.cancel=()=>clearTimeout(o),a}function _t(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 Ft(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 kt=1;const Gt="__root__";function Ut(e,t){Ft(e,t);const n=e.delete;t.proxyId=""+kt++,t.ui=JSON.parse(JSON.stringify(t.ui||[])),bt(e,t,["proxyId","proxyGroup","proxyName"]),At(e,t,["proxyManager"]);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 e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:Gt;return o[e]}function s(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:Gt;const r=[],o=t.proxyId,a=i(n)||[];for(let t=0;t<a.length;t++){const n=a[t],i=e[`get${lt(n)}`],l={id:o,name:n,value:i?i():void 0},c=s(n);c.length&&(l.children=c),r.push(l)}return r}a(t.ui,Gt),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,Gt),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(!gt(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)}function c(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)}}function u(){for(;o.length;)o.pop().subscription.unsubscribe()}const d={bind:c,unbind:l,unsubscribe:u,persistent:n};return t.propertyLinkMap[e]=d,d},e.listPropertyNames=()=>s().map((e=>e.name)),e.getPropertyByName=e=>s().find((t=>t.name===e)),e.getPropertyDomainByName=e=>(r[e]||{}).domain,e.getProxySection=()=>({id:t.proxyId,name:t.proxyGroup,ui:t.ui,properties:s()}),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,ht((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("application"===s){const n=t.proxyManager.getPropertyLink(r,a);e.registerPropertyLinkForGC(n,"application"),n.bind(e,o,i)}}}))}function zt(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 Wt(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&&bt(e,t,a)}function Ht(e){let t=0,n=0,r=0,o=0;return"detail"in e&&(n=e.detail),"wheelDelta"in e&&(n=-e.wheelDelta/120),"wheelDeltaY"in e&&(n=-e.wheelDeltaY/120),"wheelDeltaX"in e&&(t=-e.wheelDeltaX/120),"axis"in e&&e.axis===e.HORIZONTAL_AXIS&&(t=n,n=0),r=10*t,o=10*n,"deltaY"in e&&(o=e.deltaY),"deltaX"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 jt={algo:Rt,capitalize:st,chain:Vt,debounce:Nt,enumToString:function(e,t){return Object.keys(e).find((n=>e[n]===t))},event:Et,EVENT_ABORT:Mt,formatBytesToProperUnit:ut,formatNumbersWithThousandSeparator:dt,get:bt,getArray:It,getCurrentGlobalMTime:function(){return je},getStateArrayMapFunc:mt,isVtkObject:Lt,keystore:Ft,measurePromiseExecution:vt,moveToProtected:Ot,newInstance:Dt,newTypedArray:at,newTypedArrayFrom:it,normalizeWheel:Ht,obj:yt,proxy:Ut,proxyPropertyMapping:zt,proxyPropertyState:Wt,safeArrays:pt,set:St,setArray:wt,setGet:At,setGetArray:Pt,setImmediate:ht,setLoggerFunction:Ye,throttle:_t,traverseInstanceTree:Bt,TYPED_ARRAYS:ot,uncapitalize:ct,VOID:Ke,vtkDebugMacro:Je,vtkErrorMacro:et,vtkInfoMacro:Qe,vtkLogMacro:Ze,vtkOnceErrorMacro:rt,vtkWarningMacro:tt,objectSetterMap:xt},Kt=Object.freeze({__proto__:null,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:ht,measurePromiseExecution:vt,obj:yt,get:bt,set:St,setGet:At,getArray:It,setArray:wt,setGetArray:Pt,moveToProtected:Ot,algo:Rt,EVENT_ABORT:Mt,event:Et,newInstance:Dt,chain:Vt,isVtkObject:Lt,traverseInstanceTree:Bt,debounce:Nt,throttle:_t,keystore:Ft,proxy:Ut,proxyPropertyMapping:zt,proxyPropertyState:Wt,normalizeWheel:Ht,default:jt});const{vtkErrorMacro:$t}=jt;function qt(e,t){t.classHierarchy.push("vtkViewNode"),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=>{if(!t._parent)return null;return t._parent.getLastAncestorOfType(e)||(t._parent.isA(e)?t._parent: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=t=>{if(t&&t.length)for(let n=0;n<t.length;++n){const r=t[n];e.addMissingNode(r)}},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 $t("Cannot create view nodes without my own factory"),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()}}const Xt={renderable:null,myFactory:null,children:[],visited:!1};function Yt(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Xt,n),jt.obj(e,t),jt.event(e,t,"event"),t._renderableChildMap=new Map,jt.get(e,t,["visited"]),jt.setGet(e,t,["_parent","renderable","myFactory"]),jt.getArray(e,t,["children"]),jt.moveToProtected(e,t,["parent"]),qt(e,t)}var Zt={newInstance:jt.newInstance(Yt,"vtkViewNode"),extend:Yt,PASS_TYPES:["Build","Render"]};function Qt(e,t){t.overrides||(t.overrides={}),t.classHierarchy.push("vtkViewNodeFactory"),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}}const Jt={};function en(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Jt,n),jt.obj(e,t),Qt(e,t)}var tn={newInstance:jt.newInstance(en,"vtkViewNodeFactory"),extend:en};const nn=Object.create(null);function rn(e,t){nn[e]=t}function on(e,t){t.classHierarchy.push("vtkOpenGLViewNodeFactory")}const an={};function sn(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,an,n),t.overrides=nn,tn.extend(e,t,n),on(0,t)}var ln={newInstance:jt.newInstance(sn,"vtkOpenGLViewNodeFactory"),extend:sn};function cn(e,t){t.classHierarchy.push("vtkOpenGLCamera"),e.buildPass=n=>{n&&(t._openGLRenderer=e.getFirstAncestorOfType("vtkOpenGLRenderer"),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()){d(t.keyMatrices.wcvc,t.renderable.getViewMatrix()),se(t.keyMatrices.normalMatrix,t.keyMatrices.wcvc),ge(t.keyMatrices.normalMatrix,t.keyMatrices.normalMatrix),m(t.keyMatrices.wcvc,t.keyMatrices.wcvc);const e=t._openGLRenderer.getAspectRatio();d(t.keyMatrices.vcpc,t.renderable.getProjectionMatrix(e,-1,1)),m(t.keyMatrices.vcpc,t.keyMatrices.vcpc),T(t.keyMatrices.wcpc,t.keyMatrices.vcpc,t.keyMatrices.wcvc),t.keyMatrixTime.modified(),t.lastRenderer=n}return t.keyMatrices}}const un={context:null,lastRenderer:null,keyMatrixTime:null,keyMatrices:null};const dn=Dt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,un,n),Zt.extend(e,t,n),t.keyMatrixTime={},yt(t.keyMatrixTime),t.keyMatrices={normalMatrix:new Float64Array(9),vcpc:new Float64Array(16),wcvc:new Float64Array(16),wcpc:new Float64Array(16)},At(e,t,["context","keyMatrixTime"]),cn(e,t)}));rn("vtkCamera",dn);const{vtkDebugMacro:pn}=Kt;function fn(e,t){t.classHierarchy.push("vtkOpenGLRenderer"),e.buildPass=n=>{if(n){if(!t.renderable)return;e.updateLights(),e.prepareNodes(),e.addMissingNode(t.renderable.getActiveCamera()),e.addMissingNodes(t.renderable.getViewPropsWithNestedProps()),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||(pn("No lights are on, creating one."),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()))}}const gn={context:null,_openGLRenderWindow:null,selector:null};const mn=Dt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,gn,n),Zt.extend(e,t,n),bt(e,t,["shaderCache"]),At(e,t,["selector"]),Ot(0,t,["openGLRenderWindow"]),fn(e,t)}),"vtkOpenGLRenderer");function hn(e,t){t.classHierarchy.push("vtkOpenGLActor"),e.buildPass=n=>{if(n){t._openGLRenderWindow=e.getLastAncestorOfType("vtkOpenGLRenderWindow"),t._openGLRenderer=e.getFirstAncestorOfType("vtkOpenGLRenderer"),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("vtkOpenGLTexture")?(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(),d(t.keyMatrices.mcwc,t.renderable.getMatrix()),m(t.keyMatrices.mcwc,t.keyMatrices.mcwc),t.renderable.getIsIdentity()?pe(t.keyMatrices.normalMatrix):(se(t.keyMatrices.normalMatrix,t.keyMatrices.mcwc),ge(t.keyMatrices.normalMatrix,t.keyMatrices.normalMatrix),fe(t.keyMatrices.normalMatrix,t.keyMatrices.normalMatrix)),t.keyMatrixTime.modified()),t.keyMatrices)}rn("vtkRenderer",mn);const vn={context:null,keyMatrixTime:null,keyMatrices:null,activeTextures:null};const yn=Dt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,vn,n),Zt.extend(e,t,n),t.keyMatrixTime={},yt(t.keyMatrixTime,{mtime:0}),t.keyMatrices={normalMatrix:pe(new Float64Array(9)),mcwc:g(new Float64Array(16))},At(e,t,["context"]),bt(e,t,["activeTextures"]),hn(e,t)}));function Tn(e,t){t.classHierarchy.push("vtkOpenGLActor2D"),e.buildPass=n=>{if(n){if(!t.renderable)return;t._openGLRenderWindow=e.getLastAncestorOfType("vtkOpenGLRenderWindow"),t._openGLRenderer=e.getFirstAncestorOfType("vtkOpenGLRenderer"),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("vtkOpenGLTexture")?(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()}}rn("vtkActor",yn);const bn={context:null,activeTextures:null};const xn=Dt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,bn,n),Zt.extend(e,t,n),At(e,t,["context"]),bt(e,t,["activeTextures"]),Tn(e,t)}));function Cn(){var e=new i(3);return i!=Float32Array&&(e[0]=0,e[1]=0,e[2]=0),e}function Sn(e){var t=e[0],n=e[1],r=e[2];return Math.hypot(t,n,r)}function An(e,t,n){var r=new i(3);return r[0]=e,r[1]=t,r[2]=n,r}function In(e,t,n,r){return e[0]=t,e[1]=n,e[2]=r,e}function wn(e,t,n){return e[0]=t[0]+n[0],e[1]=t[1]+n[1],e[2]=t[2]+n[2],e}function Pn(e,t,n){return e[0]=t[0]-n[0],e[1]=t[1]-n[1],e[2]=t[2]-n[2],e}function On(e,t,n){return e[0]=t[0]*n,e[1]=t[1]*n,e[2]=t[2]*n,e}function Rn(e,t){return e[0]=1/t[0],e[1]=1/t[1],e[2]=1/t[2],e}function Mn(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 En(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function Dn(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 Vn(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 Ln(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 Bn(e,t){return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]}function Nn(e,t){var n=e[0],r=e[1],o=e[2],i=t[0],s=t[1],l=t[2];return Math.abs(n-i)<=a*Math.max(1,Math.abs(n),Math.abs(i))&&Math.abs(r-s)<=a*Math.max(1,Math.abs(r),Math.abs(s))&&Math.abs(o-l)<=a*Math.max(1,Math.abs(o),Math.abs(l))}rn("vtkActor2D",xn);var _n=Pn,Fn=(Cn(),Math.sqrt(50)),kn=Math.sqrt(10),Gn=Math.sqrt(2);function Un(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>=Fn?10:a>=kn?5:a>=Gn?2:1)*Math.pow(10,o):-Math.pow(10,-o)/(a>=Fn?10:a>=kn?5:a>=Gn?2:1)}function zn(e,t){return null==e||null==t?NaN:e<t?-1:e>t?1:e>=t?0:NaN}function Wn(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=zn,r=(t,n)=>zn(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 Hn=Wn(zn),jn=Hn.right;Hn.left,Wn((function(e){return null===e?NaN:+e})).center;var Kn=jn;function $n(e,t,n){e.prototype=t.prototype=n,n.constructor=e}function qn(e,t){var n=Object.create(e.prototype);for(var r in t)n[r]=t[r];return n}function Xn(){}var Yn=.7,Zn=1/Yn,Qn="\\s*([+-]?\\d+)\\s*",Jn="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*",er="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*",tr=/^#([0-9a-f]{3,8})$/,nr=new RegExp(`^rgb\\(${Qn},${Qn},${Qn}\\)$`),rr=new RegExp(`^rgb\\(${er},${er},${er}\\)$`),or=new RegExp(`^rgba\\(${Qn},${Qn},${Qn},${Jn}\\)$`),ar=new RegExp(`^rgba\\(${er},${er},${er},${Jn}\\)$`),ir=new RegExp(`^hsl\\(${Jn},${er},${er}\\)$`),sr=new RegExp(`^hsla\\(${Jn},${er},${er},${Jn}\\)$`),lr={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 cr(){return this.rgb().formatHex()}function ur(){return this.rgb().formatRgb()}function dr(e){var t,n;return e=(e+"").trim().toLowerCase(),(t=tr.exec(e))?(n=t[1].length,t=parseInt(t[1],16),6===n?pr(t):3===n?new hr(t>>8&15|t>>4&240,t>>4&15|240&t,(15&t)<<4|15&t,1):8===n?fr(t>>24&255,t>>16&255,t>>8&255,(255&t)/255):4===n?fr(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=nr.exec(e))?new hr(t[1],t[2],t[3],1):(t=rr.exec(e))?new hr(255*t[1]/100,255*t[2]/100,255*t[3]/100,1):(t=or.exec(e))?fr(t[1],t[2],t[3],t[4]):(t=ar.exec(e))?fr(255*t[1]/100,255*t[2]/100,255*t[3]/100,t[4]):(t=ir.exec(e))?Cr(t[1],t[2]/100,t[3]/100,1):(t=sr.exec(e))?Cr(t[1],t[2]/100,t[3]/100,t[4]):lr.hasOwnProperty(e)?pr(lr[e]):"transparent"===e?new hr(NaN,NaN,NaN,0):null}function pr(e){return new hr(e>>16&255,e>>8&255,255&e,1)}function fr(e,t,n,r){return r<=0&&(e=t=n=NaN),new hr(e,t,n,r)}function gr(e){return e instanceof Xn||(e=dr(e)),e?new hr((e=e.rgb()).r,e.g,e.b,e.opacity):new hr}function mr(e,t,n,r){return 1===arguments.length?gr(e):new hr(e,t,n,null==r?1:r)}function hr(e,t,n,r){this.r=+e,this.g=+t,this.b=+n,this.opacity=+r}function vr(){return`#${xr(this.r)}${xr(this.g)}${xr(this.b)}`}function yr(){const e=Tr(this.opacity);return`${1===e?"rgb(":"rgba("}${br(this.r)}, ${br(this.g)}, ${br(this.b)}${1===e?")":`, ${e})`}`}function Tr(e){return isNaN(e)?1:Math.max(0,Math.min(1,e))}function br(e){return Math.max(0,Math.min(255,Math.round(e)||0))}function xr(e){return((e=br(e))<16?"0":"")+e.toString(16)}function Cr(e,t,n,r){return r<=0?e=t=n=NaN:n<=0||n>=1?e=t=NaN:t<=0&&(e=NaN),new Ar(e,t,n,r)}function Sr(e){if(e instanceof Ar)return new Ar(e.h,e.s,e.l,e.opacity);if(e instanceof Xn||(e=dr(e)),!e)return new Ar;if(e instanceof Ar)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 Ar(i,s,l,e.opacity)}function Ar(e,t,n,r){this.h=+e,this.s=+t,this.l=+n,this.opacity=+r}function Ir(e){return(e=(e||0)%360)<0?e+360:e}function wr(e){return Math.max(0,Math.min(1,e||0))}function Pr(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 Or(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}$n(Xn,dr,{copy(e){return Object.assign(new this.constructor,this,e)},displayable(){return this.rgb().displayable()},hex:cr,formatHex:cr,formatHex8:function(){return this.rgb().formatHex8()},formatHsl:function(){return Sr(this).formatHsl()},formatRgb:ur,toString:ur}),$n(hr,mr,qn(Xn,{brighter(e){return e=null==e?Zn:Math.pow(Zn,e),new hr(this.r*e,this.g*e,this.b*e,this.opacity)},darker(e){return e=null==e?Yn:Math.pow(Yn,e),new hr(this.r*e,this.g*e,this.b*e,this.opacity)},rgb(){return this},clamp(){return new hr(br(this.r),br(this.g),br(this.b),Tr(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:vr,formatHex:vr,formatHex8:function(){return`#${xr(this.r)}${xr(this.g)}${xr(this.b)}${xr(255*(isNaN(this.opacity)?1:this.opacity))}`},formatRgb:yr,toString:yr})),$n(Ar,(function(e,t,n,r){return 1===arguments.length?Sr(e):new Ar(e,t,n,null==r?1:r)}),qn(Xn,{brighter(e){return e=null==e?Zn:Math.pow(Zn,e),new Ar(this.h,this.s,this.l*e,this.opacity)},darker(e){return e=null==e?Yn:Math.pow(Yn,e),new Ar(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 hr(Pr(e>=240?e-240:e+120,o,r),Pr(e,o,r),Pr(e<120?e+240:e-120,o,r),this.opacity)},clamp(){return new Ar(Ir(this.h),wr(this.s),wr(this.l),Tr(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=Tr(this.opacity);return`${1===e?"hsl(":"hsla("}${Ir(this.h)}, ${100*wr(this.s)}%, ${100*wr(this.l)}%${1===e?")":`, ${e})`}`}}));var Rr=e=>()=>e;function Mr(e,t){var n=t-e;return n?function(e,t){return function(n){return e+n*t}}(e,n):Rr(isNaN(e)?t:e)}var Er=function e(t){var n=function(e){return 1==(e=+e)?Mr: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):Rr(isNaN(t)?n:t)}}(t);function r(e,t){var r=n((e=mr(e)).r,(t=mr(t)).r),o=n(e.g,t.g),a=n(e.b,t.b),i=Mr(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+""}}return r.gamma=e,r}(1);function Dr(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=mr(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+""}}}function Vr(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]=Ur(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 Lr(e,t){var n=new Date;return e=+e,t=+t,function(r){return n.setTime(e*(1-r)+t*r),n}}function Br(e,t){return e=+e,t=+t,function(n){return e*(1-n)+t*n}}function Nr(e,t){var n,r={},o={};for(n in null!==e&&"object"==typeof e||(e={}),null!==t&&"object"==typeof t||(t={}),t)n in e?r[n]=Ur(e[n],t[n]):o[n]=t[n];return function(e){for(n in r)o[n]=r[n](e);return o}}Dr((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 Or((n-r/t)*t,i,o,a,s)}})),Dr((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 Or((n-r/t)*t,o,a,i,s)}}));var _r=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Fr=new RegExp(_r.source,"g");function kr(e,t){var n,r,o,a=_r.lastIndex=Fr.lastIndex=0,i=-1,s=[],l=[];for(e+="",t+="";(n=_r.exec(e))&&(r=Fr.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:Br(n,r)})),a=Fr.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)+""}}(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("")})}function Gr(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 Ur(e,t){var n,r=typeof t;return null==t||"boolean"===r?Rr(t):("number"===r?Br:"string"===r?(n=dr(t))?(t=n,Er):kr:t instanceof dr?Er:t instanceof Date?Lr:function(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}(t)?Gr:Array.isArray(t)?Vr:"function"!=typeof t.valueOf&&"function"!=typeof t.toString||isNaN(t)?Nr:Br)(e,t)}function zr(e,t){return e=+e,t=+t,function(n){return Math.round(e*(1-n)+t*n)}}function Wr(e){return+e}var Hr=[0,1];function jr(e){return e}function Kr(e,t){return(t-=e=+e)?function(n){return(n-e)/t}:function(e){return function(){return e}}(isNaN(t)?NaN:.5)}function $r(e,t,n){var r=e[0],o=e[1],a=t[0],i=t[1];return o<r?(r=Kr(o,r),a=n(i,a)):(r=Kr(r,o),a=n(a,i)),function(e){return a(r(e))}}function qr(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]=Kr(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 Xr(e,t){return t.domain(e.domain()).range(e.range()).interpolate(e.interpolate()).clamp(e.clamp()).unknown(e.unknown())}function Yr(){return function(){var e,t,n,r,o,a,i=Hr,s=Hr,l=Ur,c=jr;function u(){var e,t,n,l=Math.min(i.length,s.length);return c!==jr&&(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?qr:$r,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),Br)))(n)))},d.domain=function(e){return arguments.length?(i=Array.from(e,Wr),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=zr,u()},d.clamp=function(e){return arguments.length?(c=!!e||jr,u()):c!==jr},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()}}()(jr,jr)}function Zr(e,t){switch(arguments.length){case 0:break;case 1:this.range(e);break;default:this.range(t).domain(e)}return this}var Qr,Jr=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function eo(e){if(!(t=Jr.exec(e)))throw new Error("invalid format: "+e);var t;return new to({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 to(e){this.fill=void 0===e.fill?" ":e.fill+"",this.align=void 0===e.align?">":e.align+"",this.sign=void 0===e.sign?"-":e.sign+"",this.symbol=void 0===e.symbol?"":e.symbol+"",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?"":e.type+""}function no(e,t){if((n=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<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 ro(e){return(e=no(Math.abs(e)))?e[1]:NaN}function oo(e,t){var n=no(e,t);if(!n)return e+"";var r=n[0],o=n[1];return o<0?"0."+new Array(-o).join("0")+r:r.length>o+1?r.slice(0,o+1)+"."+r.slice(o+1):r+new Array(o-r.length+2).join("0")}eo.prototype=to.prototype,to.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(void 0===this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(void 0===this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var ao={"%":(e,t)=>(100*e).toFixed(t),b:e=>Math.round(e).toString(2),c:e=>e+"",d:function(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString("en").replace(/,/g,""):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)=>oo(100*e,t),r:oo,s:function(e,t){var n=no(e,t);if(!n)return e+"";var r=n[0],o=n[1],a=o-(Qr=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("0"):a>0?r.slice(0,a)+"."+r.slice(a):"0."+new Array(1-a).join("0")+no(e,Math.max(0,t+a-1))[0]},X:e=>Math.round(e).toString(16).toUpperCase(),x:e=>Math.round(e).toString(16)};function io(e){return e}var so,lo,co,uo=Array.prototype.map,po=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function fo(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=Un(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>=Fn?o*=10:a>=kn?o*=5:a>=Gn&&(o*=2),t<e?-o:o}(e,t,n);switch((r=eo(null==r?",f":r)).type){case"s":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(ro(t)/3)))-ro(Math.abs(e)))}(a,i))||(r.precision=o),co(r,i);case"":case"e":case"g":case"p":case"r":null!=r.precision||isNaN(o=function(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,ro(t)-ro(e))+1}(a,Math.max(Math.abs(e),Math.abs(t))))||(r.precision=o-("e"===r.type));break;case"f":case"%":null!=r.precision||isNaN(o=function(e){return Math.max(0,-ro(Math.abs(e)))}(a))||(r.precision=o-2*("%"===r.type))}return lo(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=Un(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 go(){var e=Yr();return e.copy=function(){return Xr(e,go())},Zr.apply(e,arguments),fo(e)}so=function(e){var t,n,r=void 0===e.grouping||void 0===e.thousands?io:(t=uo.call(e.grouping,Number),n=e.thousands+"",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?"":e.currency[0]+"",a=void 0===e.currency?"":e.currency[1]+"",i=void 0===e.decimal?".":e.decimal+"",s=void 0===e.numerals?io:function(e){return function(t){return t.replace(/[0-9]/g,(function(t){return e[+t]}))}}(uo.call(e.numerals,String)),l=void 0===e.percent?"%":e.percent+"",c=void 0===e.minus?"−":e.minus+"",u=void 0===e.nan?"NaN":e.nan+"";function d(e){var t=(e=eo(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,y=e.type;"n"===y?(m=!0,y="g"):ao[y]||(void 0===h&&(h=12),v=!0,y="g"),(f||"0"===t&&"="===n)&&(f=!0,t="0",n="=");var T="$"===p?o:"#"===p&&/[boxX]/.test(y)?"0"+y.toLowerCase():"",b="$"===p?a:/[%p]/.test(y)?l:"",x=ao[y],C=/[defgprs%]/.test(y);function S(e){var o,a,l,p=T,S=b;if("c"===y)S=x(e)+S,e="";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".":o=t=r;break;case"0":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&&"+"!==d&&(A=!1),p=(A?"("===d?d:c:"-"===d||"("===d?"":d)+p,S=("s"===y?po[8+Qr/3]:"")+S+(A&&"("===d?")":""),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):"";switch(m&&f&&(e=r(w+e,w.length?g-S.length:1/0),w=""),n){case"<":e=p+e+S+w;break;case"=":e=p+w+e+S;break;case"^":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(y)?Math.max(1,Math.min(21,h)):Math.max(0,Math.min(20,h)),S.toString=function(){return e+""},S}return{format:d,formatPrefix:function(e,t){var n=d(((e=eo(e)).type="f",e)),r=3*Math.max(-8,Math.min(8,Math.floor(ro(t)/3))),o=Math.pow(10,-r),a=po[8+r/3];return function(e){return n(o*e)+a}}}}({thousands:",",grouping:[3],currency:["$",""]}),lo=so.format,co=so.formatPrefix;var mo=n(640),ho=n.n(mo);const vo=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],yo=[1,0,0,0,1,0,0,0,1],To=1e-6,bo=1e-12,{vtkErrorMacro:xo,vtkWarningMacro:Co}=jt;let So=0;function Ao(e){return()=>xo(`vtkMath::${e} - NOT IMPLEMENTED`)}function Io(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 wo(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 Po(){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 Oo(e){return e/180*Math.PI}function Ro(e){return 180*e/Math.PI}const{round:Mo,floor:Eo,ceil:Do,min:Vo,max:Lo}=Math;const Bo=Ao("ceilLog2"),No=Ao("factorial");function _o(e){let t=1;for(;t<e;)t*=2;return t}function Fo(e){return e===_o(e)}const ko=Ao("gaussian");function Go(e,t,n){return n[0]=e[0]+t[0],n[1]=e[1]+t[1],n[2]=e[2]+t[2],n}function Uo(e,t,n){return n[0]=e[0]-t[0],n[1]=e[1]-t[1],n[2]=e[2]-t[2],n}function zo(e,t){return e[0]*=t,e[1]*=t,e[2]*=t,e}function Wo(e,t){return e[0]*=t,e[1]*=t,e}function Ho(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 jo(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function Ko(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 $o(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 qo(e){const t=$o(e);return 0!==t&&(e[0]/=t,e[1]/=t,e[2]/=t),t}function Xo(e,t){return e[0]*t[0]+e[1]*t[1]}function Yo(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 Zo(e){return Math.sqrt(e[0]*e[0]+e[1]*e[1])}function Qo(e){const t=Zo(e);return 0!==t&&(e[0]/=t,e[1]/=t),t}function Jo(){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 ea(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 ta(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 na(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 ra(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 oa(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:To;if(e.length!==t.length)return!1;function r(e,r){return Math.abs(e-t[r])<=n}return e.every(r)}const aa=oa;function ia(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 sa(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 la(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 ca(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;if(!`${e}`.includes("e"))return+`${Math.round(`${e}e+${t}`)}e-${t}`;const n=`${e}`.split("e");let r="";return+n[1]+t>0&&(r="+"),+`${Math.round(`${+n[0]}e${r}${+n[1]+t}`)}e-${t}`}function ua(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]=ca(e[0],n),t[1]=ca(e[1],n),t[2]=ca(e[2],n),t}function da(e,t,n,r){let o,a,i,s,l,c,u,d,p,f,g,m,h,v,y,T;const b=Po(t),x=Po(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(sa(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)),y=1/Math.sqrt(1+p*p),m=p*y,f=m/(1+y),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 Co("vtkMath::Jacobi: Error extracting eigenfunctions"),0;for(a=0;a<t-1;a++){for(i=a,T=n[i],o=a+1;o<t;o++)(n[o]>=T||Math.abs(n[o]-T)<bo)&&(i=o,T=n[i]);i!==a&&(n[i]=n[a],n[a]=T,wo(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 pa(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];da([...n],4,[0,0,0,0],r),t[0]=r[0],t[1]=r[4],t[2]=r[8],t[3]=r[12]}function fa(e,t){for(let n=0;n<9;n++)t[n]=e[n];const n=Po(3),r=Po(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]&&(wo(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,wo(t,3,1,2)),r[2]=2;let u=0;if(ra(t)<0){u=1;for(let e=0;e<9;e++)t[e]=-t[e]}const d=Po(4);if(pa(t,d),la(d,t),u)for(let e=0;e<9;e++)t[e]=-t[e];1!==r[1]&&wo(t,3,r[1],1),0!==r[0]&&wo(t,3,r[0],0)}function ga(e,t,n){let r,o,a,i,s,l;if(da([...e],3,t,n),t[0]!==t[1]||t[0]!==t[2]){for(na(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,Io(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=Ko([n[3*i],n[3*i+1],n[3*i+2]],[n[3*o],n[3*o+1],n[3*o+2]],[]);qo(e);const c=Ko(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 na(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,Io(n,3,i,0)}if(Math.abs(n[4])<Math.abs(n[7])){const e=t[2];t[2]=t[1],t[1]=e,Io(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]);ra(n)<0&&(n[6]=-n[6],n[7]=-n[7],n[8]=-n[8]),na(n,n)}else ia(n)}function ma(e,t,n){let r,o,a,i,s,l,c,u=0;const d=Po(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 Co("Unable to factor linear system"),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])<=bo)return Co("Unable to factor linear system"),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 ha(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 va(e,t,n){if(2===n){const n=Po(2),r=Jo(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=Po(n);return 0===ma(e,r,n)?0:(ha(e,r,t,n),1)}function ya(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:null,o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null;const a=r||Po(n),i=o||Po(n);if(0===ma(e,a,n))return null;for(let r=0;r<n;r++){for(let e=0;e<n;e++)i[e]=0;i[r]=1,ha(e,a,i,n);for(let e=0;e<n;e++)t[e*n+r]=i[e]}return t}function Ta(e,t,n,r){if(e<n)return Co("Insufficient number of samples. Underdetermined."),0;let o,a,i;const s=Po(n*n),l=Po(n),c=Po(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(da(s,n,l,c),o=0;o<n;o++)r[o]=c[o*n+n-1];return 1}function ba(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?.3333333333333333+s*(i-o)/(l-c):.6666666666666666+s*(o-a)/(l-c),n<0&&(n+=1)):n=0,t[0]=n,t[1]=r,t[2]=u}function xa(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 Ca(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 Sa(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 Aa(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 Ia(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 wa(e,t){const n=[0,0,0];Ia(e,n),Sa(n,t)}function Pa(e,t){const n=[0,0,0];Ca(e,n),Aa(n,t)}function Oa(e){return e[0]=1,e[1]=-1,e[2]=1,e[3]=-1,e[4]=1,e[5]=-1,e}function Ra(e){return!(e[1]-e[0]<0)}function Ma(e,t,n){return e<t?t:e>n?n:e}function Ea(e,t,n){let r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:[0,0,0];return r[0]=Ma(e[0],t[0],n[0]),r[1]=Ma(e[1],t[1],n[1]),r[2]=Ma(e[2],t[2],n[2]),r}const Da=Ao("GetScalarTypeFittingRange"),Va=Ao("GetAdjustedScalarRange");const La=e=>!Number.isFinite(e),{isFinite:Ba,isNaN:Na}=Number,_a=Na;function Fa(){return[].concat([Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE])}function ka(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 Ga(e){const t=Math.floor(255*e);return t>15?t.toString(16):`0${t.toString(16)}`}function Ua(e){return Math.round(255*e)}var za={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:Oo,degreesFromRadians:Ro,round:Mo,floor:Eo,ceil:Do,ceilLog2:Bo,min:Vo,max:Lo,arrayMin:function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,r=1/0;for(let o=t,a=e.length;o<a;o+=n)e[o]<r&&(r=e[o]);return r},arrayMax:function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,r=-1/0;for(let o=t,a=e.length;o<a;o+=n)r<e[o]&&(r=e[o]);return r},arrayRange:function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,r=1/0,o=-1/0;for(let a=t,i=e.length;a<i;a+=n)e[a]<r&&(r=e[a]),o<e[a]&&(o=e[a]);return[r,o]},isPowerOfTwo:Fo,nearestPowerOfTwo:_o,factorial:No,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=Po(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){ho()(`${e}`,{global:!0}),So=e},getSeed:function(){return So},random:function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;const n=t-e;return e+n*Math.random()},gaussian:ko,add:Go,subtract:Uo,multiplyScalar:zo,multiplyScalar2D:Wo,multiplyAccumulate:Ho,multiplyAccumulate2D:function(e,t,n,r){return r[0]=e[0]+t[0]*n,r[1]=e[1]+t[1]*n,r},dot:jo,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:Ko,norm:$o,normalize:qo,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=jo(t,t);if(0===r)return n[0]=0,n[1]=0,n[2]=0,!1;const o=jo(e,t)/r;for(let e=0;e<3;e++)n[e]=t[e];return zo(n,o),!0},projectVector2D:function(e,t,n){const r=Xo(t,t);if(0===r)return n[0]=0,n[1]=0,!1;const o=Xo(e,t)/r;for(let e=0;e<2;e++)n[e]=t[e];return Wo(n,o),!0},distance2BetweenPoints:Yo,angleBetweenVectors:function(e,t){const n=[0,0,0];return Ko(e,t,n),Math.atan2($o(n),jo(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:Xo,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:Zo,normalize2D:Qo,determinant2x2:Jo,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&&(Io(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,Io(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=+Jo(s,u,l,d),f=-Jo(i,c,l,d),g=+Jo(i,c,s,u),m=-Jo(o,u,a,d),h=+Jo(r,c,a,d),v=-Jo(r,c,o,u),y=+Jo(o,s,a,l),T=-Jo(r,i,a,l),b=+Jo(r,i,o,s),x=r*p+o*f+a*g,C=p*t[0]+m*t[1]+y*t[2],S=f*t[0]+h*t[1]+T*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:ea,multiply3x3_mat3:ta,multiplyMatrix:function(e,t,n,r,o,a,i){r!==o&&xo("Number of columns of A must match number of rows of B.");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:na,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=+Jo(i,c,s,u),p=-Jo(a,l,s,u),f=+Jo(a,l,i,c),g=-Jo(r,c,o,u),m=+Jo(n,l,o,u),h=-Jo(n,l,r,c),v=+Jo(r,i,o,s),y=-Jo(n,a,o,s),T=+Jo(n,a,r,i),b=n*d+r*p+o*f;0===b&&Co("Matrix has 0 determinant"),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]=y/b,t[8]=T/b},identity3x3:ia,identity:sa,isIdentity:function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:To;return aa(e,vo,t)},isIdentity3x3:function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:To;return aa(e,yo,t)},determinant3x3:ra,quaternionToMatrix3x3:la,areEquals:oa,areMatricesEqual:aa,roundNumber:ca,roundVector:ua,matrix3x3ToQuaternion:pa,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],y=e[3]*t[3];n[0]=r-l-f-y,n[1]=o+s+g-v,n[2]=a-u+d+h,n[3]=i+c-p+m},orthogonalize3x3:fa,diagonalize3x3:ga,singularValueDecomposition3x3:function(e,t,n,r){let o;const a=[...e],i=ra(a);if(i<0)for(o=0;o<9;o++)a[o]=-a[o];fa(a,t),na(a,a),ta(a,t,r),ga(r,n,r),ta(t,r,t),na(r,r),i<0&&(n[0]=-n[0],n[1]=-n[1],n[2]=-n[2])},solveLinearSystem:va,invertMatrix:ya,luFactorLinearSystem:ma,luSolveLinearSystem:ha,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 da(e,3,t,n)},jacobiN:da,solveHomogeneousLeastSquares:Ta,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 Co("Insufficient number of samples. Underdetermined."),0;const s=Po(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])>bo&&(p=0,s[u]=0);if(p&&1===o)return Co("Detected homogeneous system (Y=0), calling SolveHomogeneousLeastSquares()"),Ta(e,t,n,a);if(p)g=1;else for(u=0;u<o;u++)s[u]&&(g=1)}g&&(l=Po(n),f=Ta(e,t,n,l));const m=Po(n*n),h=Po(n*n),v=Po(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 y=ya(m,h,n);if(y)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&&y:y},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:ba,hsv2rgb:xa,lab2xyz:Ca,xyz2lab:Sa,xyz2rgb:Aa,rgb2xyz:Ia,rgb2lab:wa,lab2rgb:Pa,uninitializeBounds:Oa,areBoundsInitialized:Ra,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:Ma,clampVector:Ea,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:Da,getAdjustedScalarRange:Va,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=Po(3),a=Po(3),i=Po(3),s=Po(3),l=Po(3),c=Po(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=$o(s),d=$o(l),p=$o(i),f=Po(3);Ko(o,a,f);const g=$o(f),m=u*d*p/(2*g),h=2*g*g,v=d*d*jo(o,c)/h,y=p*p*jo(s,a)/h,T=u*u*jo(i,l)/h;for(let o=0;o<3;++o)r[o]=v*e[o]+y*t[o]+T*n[o];return m},inf:1/0,negInf:-1/0,isInf:La,isNan:Na,isNaN:Na,isFinite:Ba,createUninitializedBounds:Fa,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:ka,floatToHex2:Ga,floatRGB2HexCode:function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"#";return`${t}${e.map(Ga).join("")}`},float2CssRGBA:function(e){return 3===e.length?`rgb(${e.map(Ua).join(", ")})`:`rgba(${Ua(e[0]||0)}, ${Ua(e[1]||0)}, ${Ua(e[2]||0)}, ${e[3]||0})`}};function Wa(e,t){t.classHierarchy.push("vtkImplicitFunction"),e.functionValue=n=>{if(!t.transform)return e.evaluateFunction(n);const r=[];return t.transform.transformPoint(n,r),e.evaluateFunction(r)},e.evaluateFunction=e=>{jt.vtkErrorMacro("not implemented")}}const Ha={};function ja(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ha,n),jt.obj(e,t),jt.setGet(e,t,["transform"]),Wa(e,t)}var Ka={newInstance:jt.newInstance(ja,"vtkImplicitFunction"),extend:ja};const $a=1e-6,qa="coincide",Xa="disjoint";function Ya(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 Za(e,t,n,r){const o=[];Uo(e,t,o);const a=jo(n,o);r[0]=e[0]-a*n[0],r[1]=e[1]-a*n[1],r[2]=e[2]-a*n[2]}function Qa(e,t,n){const r=jo(e,t);let o=jo(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 Ja(e,t,n,r){const o=[];Uo(e,t,o);const a=jo(n,o),i=jo(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 ei(e,t,n,r){const o={intersection:!1,betweenPoints:!1,t:Number.MAX_VALUE,x:[]},a=[],i=[];Uo(t,e,a),Uo(n,e,i);const s=jo(r,i),l=jo(r,a);let c,u;return c=l<0?-l:l,u=s<0?-s*$a:s*$a,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 ti(e,t,n,r){const o={intersection:!1,l0:[],l1:[],error:null},a=[];Ko(t,r,a);const i=a.map((e=>Math.abs(e)));if(i[0]+i[1]+i[2]<$a){const r=[];return Uo(e,n,r),0===jo(t,r)?o.error=qa:o.error=Xa,o}let s;s=i[0]>i[1]&&i[0]>i[2]?"x":i[1]>i[2]?"y":"z";const l=[],c=-jo(t,e),u=-jo(r,n);switch(s){case"x":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"y":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"z":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,Go(l,a,o.l1),o.intersection=!0,o}const ni={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:Ya,projectPoint:Za,projectVector:Qa,generalizedProjectPoint:Ja,intersectWithLine:ei,intersectWithPlane:ti,DISJOINT:Xa,COINCIDE:qa};function ri(e,t){t.classHierarchy.push("vtkPlane"),e.distanceToPlane=e=>Ya(e,t.origin,t.normal),e.projectPoint=(e,n)=>{Za(e,t.origin,t.normal,n)},e.projectVector=(e,n)=>Qa(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)=>{Ja(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)=>ei(e,n,t.origin,t.normal),e.intersectWithPlane=(e,n)=>ti(e,n,t.origin,t.normal)}const oi={normal:[0,0,1],origin:[0,0,0]};function ai(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,oi,n),Ka.extend(e,t,n),jt.setGetArray(e,t,["normal","origin"],3),ri(e,t)}var ii={newInstance:jt.newInstance(ai,"vtkPlane"),extend:ai,...ni};const si=[Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE,Number.MAX_VALUE,-Number.MAX_VALUE];function li(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 ci(e){return e?.length>=6&&e[0]<=e[1]&&e[2]<=e[3]&&e[4]<=e[5]}function ui(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 di(e){return ui(e,si)}function pi(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 fi(e,t){if(0===t.length)return e;if(Array.isArray(t[0]))for(let n=0;n<t.length;++n)pi(e,...t[n]);else for(let n=0;n<t.length;n+=3)pi(e,...t.slice(n,n+3));return e}function gi(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 mi(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 hi(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 vi(e,t){return e[0]-=t,e[1]+=t,e[2]-=t,e[3]+=t,e[4]-=t,e[5]+=t,e}function yi(e,t,n,r){return!!ci(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 Ti(e){return[.5*(e[0]+e[1]),.5*(e[2]+e[3]),.5*(e[4]+e[5])]}function bi(e,t){return e[2*t+1]-e[2*t]}function xi(e){return[bi(e,0),bi(e,1),bi(e,2)]}function Ci(e){return e.slice(0,2)}function Si(e){return e.slice(2,4)}function Ai(e){return e.slice(4,6)}function Ii(e){const t=xi(e);return t[0]>t[1]?t[0]>t[2]?t[0]:t[2]:t[1]>t[2]?t[1]:t[2]}function wi(e){if(ci(e)){const t=xi(e);return Math.sqrt(t[0]*t[0]+t[1]*t[1]+t[2]*t[2])}return null}function Pi(e){return[e[0],e[2],e[4]]}function Oi(e){return[e[1],e[3],e[5]]}function Ri(e,t){return e<=0&&t>=0||e>=0&&t<=0}function Mi(e,t){let n=0;for(let r=0;r<2;r++)for(let o=2;o<4;o++)for(let a=4;a<6;a++)t[n++]=[e[r],e[o],e[a]];return t}function Ei(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 Di(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[];const r=Mi(e,[]);for(let e=0;e<r.length;++e)Vn(r[e],r[e],t);return di(n),fi(n,r)}function Vi(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 Li(e,t,n,r){const o=[].concat(si),a=e.getData();for(let e=0;e<a.length;e+=3){const i=[a[e],a[e+1],a[e+2]],s=jo(i,t);o[0]=Math.min(s,o[0]),o[1]=Math.max(s,o[1]);const l=jo(i,n);o[2]=Math.min(l,o[2]),o[3]=Math.max(l,o[3]);const c=jo(i,r);o[4]=Math.min(c,o[4]),o[5]=Math.max(c,o[5])}return o}function Bi(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 Ni(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=ii.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 _i(e,t){if(!ci(e)||!ci(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 Fi(e,t){if(!ci(e)||!ci(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 ki(e,t,n,r){return!(t<e[0]||t>e[1]||n<e[2]||n>e[3]||r<e[4]||r>e[5])}function Gi(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++]=ii.evaluate(n,t,l)}let i=2;for(;i--&&!(Ri(o[r[i][0]],o[r[i][4]])&&Ri(o[r[i][1]],o[r[i][5]])&&Ri(o[r[i][2]],o[r[i][6]])&&Ri(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}class Ui{constructor(e){this.bounds=e,this.bounds||(this.bounds=new Float64Array(si))}getBounds(){return this.bounds}equals(e){return li(this.bounds,e)}isValid(){return ci(this.bounds)}setBounds(e){return ui(this.bounds,e)}reset(){return di(this.bounds)}addPoint(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return pi(this.bounds,...t)}addPoints(e){return fi(this.bounds,e)}addBounds(e,t,n,r,o,a){return gi(this.bounds,e,t,n,r,o,a)}setMinPoint(e,t,n){return mi(this.bounds,e,t,n)}setMaxPoint(e,t,n){return hi(this.bounds,e,t,n)}inflate(e){return vi(this.bounds,e)}scale(e,t,n){return yi(this.bounds,e,t,n)}getCenter(){return Ti(this.bounds)}getLength(e){return bi(this.bounds,e)}getLengths(){return xi(this.bounds)}getMaxLength(){return Ii(this.bounds)}getDiagonalLength(){return wi(this.bounds)}getMinPoint(){return Pi(this.bounds)}getMaxPoint(){return Oi(this.bounds)}getXRange(){return Ci(this.bounds)}getYRange(){return Si(this.bounds)}getZRange(){return Ai(this.bounds)}getCorners(e){return Mi(this.bounds,e)}computeCornerPoints(e,t){return Ei(this.bounds,e,t)}computeLocalBounds(e,t,n){return Li(this.bounds,e,t,n)}transformBounds(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return Di(this.bounds,e,t)}computeScale3(e){return Vi(this.bounds,e)}cutWithPlane(e,t){return Gi(this.bounds,e,t)}intersectBox(e,t,n,r){return Bi(this.bounds,e,t,n,r)}intersectPlane(e,t){return Ni(this.bounds,e,t)}intersect(e){return _i(this.bounds,e)}intersects(e){return Fi(this.bounds,e)}containsPoint(e,t,n){return ki(this.bounds,e,t,n)}contains(e){return Fi(this.bounds,e)}}var zi,Wi={newInstance:function(e){const t=e&&e.bounds;return new Ui(t)},equals:li,isValid:ci,setBounds:ui,reset:di,addPoint:pi,addPoints:fi,addBounds:gi,setMinPoint:mi,setMaxPoint:hi,inflate:vi,scale:yi,scaleAboutCenter:function(e,t,n,r){if(!ci(e))return!1;const o=Ti(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],yi(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:Ti,getLength:bi,getLengths:xi,getMaxLength:Ii,getDiagonalLength:wi,getMinPoint:Pi,getMaxPoint:Oi,getXRange:Ci,getYRange:Si,getZRange:Ai,getCorners:Mi,computeCornerPoints:Ei,computeLocalBounds:Li,transformBounds:Di,computeScale3:Vi,cutWithPlane:Gi,intersectBox:Bi,intersectPlane:Ni,intersect:_i,intersects:Fi,containsPoint:ki,contains:function(e,t){return!!Fi(e,t)&&!!ki(e,...Pi(t))&&!!ki(e,...Oi(t))},INIT_BOUNDS:si};function Hi(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 ji(){var e=new i(4);return i!=Float32Array&&(e[0]=0,e[1]=0,e[2]=0),e[3]=1,e}function Ki(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 $i(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}zi=new i(4),i!=Float32Array&&(zi[0]=0,zi[1]=0,zi[2]=0,zi[3]=0);var qi=function(e,t,n,r){var o=new i(4);return o[0]=e,o[1]=t,o[2]=n,o[3]=r,o};Cn(),An(1,0,0),An(0,1,0),ji(),ji(),ie();var Xi={CoordinateSystem:{DISPLAY:0,WORLD:1}};const{CoordinateSystem:Yi}=Xi;function Zi(e){return()=>jt.vtkErrorMacro(`vtkProp::${e} - NOT IMPLEMENTED`)}function Qi(e,t){t.classHierarchy.push("vtkProp"),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=Zi("pick"),e.hasKey=Zi("hasKey"),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(Yi.WORLD),e.setCoordinateSystemToDisplay=()=>e.setCoordinateSystem(Yi.DISPLAY)}const Ji={allocatedRenderTime:10,coordinateSystem:Yi.WORLD,dragable:!0,estimatedRenderTime:0,paths:null,pickable:!0,renderTimeMultiplier:1,savedEstimatedRenderTime:0,textures:[],useBounds:!0,visibility:!0};function es(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ji,n),jt.obj(e,t),jt.get(e,t,["estimatedRenderTime","allocatedRenderTime"]),jt.setGet(e,t,["_parentProp","coordinateSystem","dragable","pickable","renderTimeMultiplier","useBounds","visibility"]),jt.moveToProtected(e,t,["parentProp"]),Qi(e,t)}var ts={newInstance:jt.newInstance(es,"vtkProp"),extend:es,...Xi};function ns(e,t){t.classHierarchy.push("vtkProp3D"),e.addPosition=n=>{t.position=t.position.map(((e,t)=>e+n[t])),e.modified()},e.getOrientationWXYZ=()=>{const e=ji();N(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>a?(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[Ro(r),n[0],n[1],n[2]]},e.getOrientationQuaternion=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[];return N(e,t.rotation)},e.rotateX=n=>{0!==n&&(S(t.rotation,t.rotation,Oo(n)),e.modified())},e.rotateY=n=>{0!==n&&(A(t.rotation,t.rotation,Oo(n)),e.modified())},e.rotateZ=n=>{0!==n&&(I(t.rotation,t.rotation,Oo(n)),e.modified())},e.rotateWXYZ=(n,r,o,a)=>{if(0===n||0===r&&0===o&&0===a)return;const i=Oo(n),s=ji();Ki(s,[r,o,a],i);const l=new Float64Array(16);k(l,s),T(t.rotation,t.rotation,l),e.modified()},e.rotateQuaternion=n=>{if(Math.abs(n[3])>=.999999)return;const r=k(new Float64Array(16),n);T(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],g(t.rotation),e.rotateZ(o),e.rotateX(n),e.rotateY(r),e.modified(),!0),e.setUserMatrix=n=>!aa(t.userMatrix,n)&&(d(t.userMatrix,n),e.modified(),!0),e.getMatrix=()=>(e.computeMatrix(),t.matrix),e.computeMatrix=()=>{if(e.getMTime()>t.matrixMTime.getMTime()){g(t.matrix),t.userMatrix&&T(t.matrix,t.matrix,t.userMatrix),b(t.matrix,t.matrix,t.origin),b(t.matrix,t.matrix,t.position),T(t.matrix,t.matrix,t.rotation),x(t.matrix,t.matrix,t.scale),b(t.matrix,t.matrix,[-t.origin[0],-t.origin[1],-t.origin[2]]),m(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.getCenter=()=>Wi.getCenter(t.bounds),e.getLength=()=>Wi.getLength(t.bounds),e.getXRange=()=>Wi.getXRange(t.bounds),e.getYRange=()=>Wi.getYRange(t.bounds),e.getZRange=()=>Wi.getZRange(t.bounds),e.getUserMatrix=()=>t.userMatrix,e.onModified((function(){e.computeMatrix()}))}const rs={origin:[0,0,0],position:[0,0,0],orientation:[0,0,0],rotation:null,scale:[1,1,1],bounds:[1,-1,1,-1,1,-1],userMatrix:null,userMatrixMTime:null,cachedProp3D:null,isIdentity:!0,matrixMTime:null};function os(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,rs,n),ts.extend(e,t,n),t.matrixMTime={},jt.obj(t.matrixMTime),jt.get(e,t,["bounds","isIdentity"]),jt.getArray(e,t,["orientation"]),jt.setGetArray(e,t,["origin","position","scale"],3),t.matrix=g(new Float64Array(16)),t.rotation=g(new Float64Array(16)),t.userMatrix=g(new Float64Array(16)),t.transform=null,ns(e,t)}var as={newInstance:jt.newInstance(os,"vtkProp3D"),extend:os};const is={FLAT:0,GOURAUD:1,PHONG:2},ss={POINTS:0,WIREFRAME:1,SURFACE:2};var ls={Shading:is,Representation:ss,Interpolation:is};const{Representation:cs,Interpolation:us}=ls;function ds(e){return()=>jt.vtkErrorMacro(`vtkProperty::${e} - NOT IMPLEMENTED`)}function ps(e,t){t.classHierarchy.push("vtkProperty"),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=ds("ComputeCompositeColor"),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=ds("AddShaderVariable"),e.setInterpolationToFlat=()=>e.setInterpolation(us.FLAT),e.setInterpolationToGouraud=()=>e.setInterpolation(us.GOURAUD),e.setInterpolationToPhong=()=>e.setInterpolation(us.PHONG),e.getInterpolationAsString=()=>jt.enumToString(us,t.interpolation),e.setRepresentationToWireframe=()=>e.setRepresentation(cs.WIREFRAME),e.setRepresentationToSurface=()=>e.setRepresentation(cs.SURFACE),e.setRepresentationToPoints=()=>e.setRepresentation(cs.POINTS),e.getRepresentationAsString=()=>jt.enumToString(cs,t.representation)}const fs={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:us.GOURAUD,representation:cs.SURFACE,edgeVisibility:!1,backfaceCulling:!1,frontfaceCulling:!1,pointSize:1,lineWidth:1,lighting:!0,shading:!1,materialName:null};function gs(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,fs,n),jt.obj(e,t),jt.setGet(e,t,["lighting","interpolation","ambient","diffuse","metallic","roughness","normalStrength","emission","baseIOR","specular","specularPower","opacity","edgeVisibility","lineWidth","pointSize","backfaceCulling","frontfaceCulling","representation","diffuseTexture","metallicTexture","roughnessTexture","normalTexture","ambientOcclusionTexture","emissionTexture"]),jt.setGetArray(e,t,["ambientColor","specularColor","diffuseColor","edgeColor"],3),ps(e,t)}var ms={newInstance:jt.newInstance(gs,"vtkProperty"),extend:gs,...ls};const{vtkDebugMacro:hs}=jt;function vs(e,t){t.classHierarchy.push("vtkActor");const n={...e};e.getActors=()=>[e],e.getIsOpaque=()=>{if(t.forceOpaque)return!0;if(t.forceTranslucent)return!1;t.property||e.getProperty();let n=t.property.getOpacity()>=1;return n=n&&(!t.texture||!t.texture.isTranslucent()),n=n&&(!t.mapper||t.mapper.getIsOpaque()),n},e.hasTranslucentPolygonalGeometry=()=>null!==t.mapper&&(null===t.property&&e.setProperty(e.makeProperty()),!e.getIsOpaque()),e.makeProperty=ms.newInstance,e.getProperty=()=>(null===t.property&&(t.property=e.makeProperty()),t.property),e.getBounds=()=>{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.concat(),t.bounds=[1,-1,1,-1,1,-1],t.boundsMTime.modified(),n;if(!t.mapperBounds||n[0]!==t.mapperBounds[0]||n[1]!==t.mapperBounds[1]||n[2]!==t.mapperBounds[2]||n[3]!==t.mapperBounds[3]||n[4]!==t.mapperBounds[4]||n[5]!==t.mapperBounds[5]||e.getMTime()>t.boundsMTime.getMTime()){hs("Recomputing bounds..."),t.mapperBounds=n.concat();const r=[];Wi.getCorners(n,r),e.computeMatrix();const o=new Float64Array(16);m(o,t.matrix),r.forEach((e=>Vn(e,e,o))),t.bounds[0]=t.bounds[2]=t.bounds[4]=Number.MAX_VALUE,t.bounds[1]=t.bounds[3]=t.bounds[5]=-Number.MAX_VALUE,t.bounds=t.bounds.map(((e,t)=>t%2==0?r.reduce(((e,n)=>e>n[t/2]?n[t/2]:e),e):r.reduce(((e,n)=>e<n[(t-1)/2]?n[(t-1)/2]:e),e))),t.boundsMTime.modified()}return t.bounds},e.getMTime=()=>{let e=n.getMTime();if(null!==t.property){const n=t.property.getMTime();e=n>e?n:e}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)}}const ys={mapper:null,property:null,backfaceProperty:null,forceOpaque:!1,forceTranslucent:!1,bounds:[1,-1,1,-1,1,-1]};function Ts(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ys,n),as.extend(e,t,n),t.boundsMTime={},jt.obj(t.boundsMTime),jt.set(e,t,["property"]),jt.setGet(e,t,["backfaceProperty","forceOpaque","forceTranslucent","mapper"]),vs(e,t)}var bs={newInstance:jt.newInstance(Ts,"vtkActor"),extend:Ts};const xs={Int8Array:1,Uint8Array:1,Uint8ClampedArray:1,Int16Array:2,Uint16Array:2,Int32Array:4,Uint32Array:4,Float32Array:4,Float64Array:8},Cs={VOID:"",CHAR:"Int8Array",SIGNED_CHAR:"Int8Array",UNSIGNED_CHAR:"Uint8Array",UNSIGNED_CHAR_CLAMPED:"Uint8ClampedArray",SHORT:"Int16Array",UNSIGNED_SHORT:"Uint16Array",INT:"Int32Array",UNSIGNED_INT:"Uint32Array",FLOAT:"Float32Array",DOUBLE:"Float64Array"};var Ss={DefaultDataType:Cs.FLOAT,DataTypeByteSize:xs,VtkDataTypes:Cs};const{vtkErrorMacro:As}=Kt,{DefaultDataType:Is}=Ss,ws=1e-6;function Ps(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 Os(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 Ps(r,0,1)}return Ps(e,t<0?0:t,n)}function Rs(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 Ms(e){return Object.prototype.toString.call(e).slice(8,-1)}const Es={computeRange:Os,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:()=>({min:e,max:t,count:n,sum:r,mean:r/n}),getRange:()=>({min:e,max:t})}},fastComputeRange:Ps,getDataType:Ms,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=$o(r,t);a>n&&(n=a)}return n}};function Ds(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("vtkDataArray"),e.dataChange=()=>{t.ranges=null,e.modified()},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.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=Rs(t.ranges,t.numberOfComponents)),o=t.ranges[r],o?(t.rangeTuple[0]=o.min,t.rangeTuple[1]=o.max,t.rangeTuple):(o=Os(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=Rs(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.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]:ws;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(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:1;return e*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=Ms(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),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()||As("numberOfComponents must match");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)}}const Vs={name:"",numberOfComponents:1,dataType:Is,rangeTuple:[0,0]};function Ls(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};if(Object.assign(t,Vs,n),Array.isArray(n.values)&&void 0===n.dataType&&console.warn("vtkDataArray.newInstance: no dataType provided, converting to Float32Array"),!t.empty&&!t.values&&!t.size)throw new TypeError("Cannot create vtkDataArray object without: size > 0, values");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=Ms(t.values)),yt(e,t),St(e,t,["name","numberOfComponents"]),t.size%t.numberOfComponents!=0)throw new RangeError("model.size is not a multiple of model.numberOfComponents");Ds(e,t)}const Bs=Dt(Ls,"vtkDataArray");var Ns={newInstance:Bs,extend:Ls,...Es,...Ss};function _s(e,t){t.classHierarchy.push("vtkAbstractMapper"),e.update=()=>{e.getInputData()},e.addClippingPlane=n=>!!n.isA("vtkPlane")&&!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])}}jt.vtkErrorMacro(`Clipping plane index ${n} is out of range.`)}}const Fs={clippingPlanes:[]};var ks=function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Fs,n),jt.obj(e,t),jt.algo(e,t,1,0),t.clippingPlanes||(t.clippingPlanes=[]),_s(e,t)};function Gs(e,t){e.getBounds=()=>(jt.vtkErrorMacro("vtkAbstractMapper3D.getBounds - NOT IMPLEMENTED"),Fa()),e.getCenter=()=>{const n=e.getBounds();return t.center=Wi.isValid(n)?Wi.getCenter(n):null,t.center?.slice()},e.getLength=()=>{const t=e.getBounds();return Wi.getDiagonalLength(t)}}const Us=e=>({bounds:[...Wi.INIT_BOUNDS],center:[0,0,0],viewSpecificProperties:{},...e});var zs=function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Us(n)),ks(e,t,n),jt.setGet(e,t,["viewSpecificProperties"]),Gs(e,t)};const{vtkErrorMacro:Ws,vtkWarningMacro:Hs}=jt;function js(e,t){t.classHierarchy.push("vtkFieldData");const n=e.getState;t.arrays&&(t.arrays=t.arrays.map((e=>({data:We(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.arrays().map((e=>({array: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=>"number"==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():""},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 Ws("Unhandled case in passData");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=Ns.newInstance({name:a.getName(),dataType:a.getDataType(),numberOfComponents:i,values:jt.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),Hs("Unexpected case in interpolateData")}else t.insertTuples(s.getTuples());else Ws("Unhandled case in interpolateData");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=Ns.newInstance({name:s.getName(),dataType:s.getDataType(),numberOfComponents:l,values:jt.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}}const Ks={arrays:[],copyFieldFlags:[],doCopyAllOn:!0,doCopyAllOff:!1};function $s(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ks,n),jt.obj(e,t),js(e,t)}var qs={newInstance:jt.newInstance($s,"vtkFieldData"),extend:$s};const Xs={DEFAULT:0,SINGLE:1,DOUBLE:2};var Ys={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:Xs,PointGhostTypes:{DUPLICATEPOINT:1,HIDDENPOINT:2},ghostArrayName:"vtkGhostType"};const{AttributeTypes:Zs,AttributeCopyOperations:Qs}=Ys,{vtkWarningMacro:Js}=jt;function el(e,t){const n=["Scalars","Vectors","Normals","TCoords","Tensors","GlobalIds","PedigreeIds"];function r(e){let t=n.find((t=>Zs[t.toUpperCase()]===e||"number"!=typeof e&&t.toLowerCase()===e.toLowerCase()));return void 0===t&&(t=null),t}t.classHierarchy.push("vtkDataSetAttributes");const o={...e};e.checkNumberOfComponents=e=>!0,e.setAttribute=(n,o)=>{const a=r(o);if(n&&"PEDIGREEIDS"===a.toUpperCase()&&!n.isA("vtkDataArray"))return Js(`Cannot set attribute ${a}. The attribute must be a vtkDataArray.`),-1;if(n&&!e.checkNumberOfComponents(n,a))return Js(`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("PEDIGREEIDS"!==a.toUpperCase()){const t=e.getArrayByIndex(n);if(!t.isA("vtkDataArray"))return Js(`Cannot set attribute ${a}. Only vtkDataArray subclasses can be set as active attributes.`),-1;if(!e.checkNumberOfComponents(t,a))return Js(`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[Qs.PASSDATA][Zs[e]]=!1},e[`copy${n}On`]=()=>{const e=n.toUpperCase();t.copyAttributeFlags[Qs.PASSDATA][Zs[e]]=!0}})),e.initializeAttributeCopyFlags=()=>{t.copyAttributeFlags=[],Object.keys(Qs).filter((e=>"ALLCOPY"!==e)).forEach((e=>{t.copyAttributeFlags[Qs[e]]=Object.keys(Zs).filter((e=>"NUM_ATTRIBUTES"!==e)).reduce(((e,t)=>(e[Zs[t]]=!0,e)),[])})),t.copyAttributeFlags[Qs.COPYTUPLE][Zs.GLOBALIDS]=!1,t.copyAttributeFlags[Qs.INTERPOLATE][Zs.GLOBALIDS]=!1,t.copyAttributeFlags[Qs.COPYTUPLE][Zs.PEDIGREEIDS]=!1},e.initialize=jt.chain(e.initialize,e.initializeAttributeCopyFlags),t.dataArrays&&Object.keys(t.dataArrays).length&&Object.keys(t.dataArrays).forEach((n=>{t.dataArrays[n].ref||"vtkDataArray"!==t.dataArrays[n].type||e.addArray(Ns.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()}const tl={activeScalars:-1,activeVectors:-1,activeTensors:-1,activeNormals:-1,activeTCoords:-1,activeGlobalIds:-1,activePedigreeIds:-1};function nl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,tl,n),qs.extend(e,t,n),jt.setGet(e,t,["activeScalars","activeNormals","activeTCoords","activeVectors","activeTensors","activeGlobalIds","activePedigreeIds"]),t.arrays||(t.arrays={}),el(e,t)}var rl={newInstance:jt.newInstance(nl,"vtkDataSetAttributes"),extend:nl,...Ys};const ol=["pointData","cellData","fieldData"];function al(e,t){t.classHierarchy.push("vtkDataSet"),ol.forEach((e=>{t[e]?t[e]=We(t[e]):t[e]=rl.newInstance()}));const n=e.shallowCopy;e.shallowCopy=function(e){let r=arguments.length>1&&void 0!==arguments[1]&&arguments[1];n(e,r),ol.forEach((n=>{t[n]=rl.newInstance(),t[n].shallowCopy(e.getReferenceByName(n))}))}}const il={};function sl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,il,n),jt.obj(e,t),jt.setGet(e,t,ol),al(e,t)}var ll={newInstance:jt.newInstance(sl,"vtkDataSet"),extend:sl,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 cl={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 ul={StructuredType:cl};const{StructuredType:dl}=ul;var pl={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]?dl.EMPTY:3===t?dl.XYZ_GRID:2===t?e[0]===e[1]?dl.YZ_PLANE:e[2]===e[3]?dl.XZ_PLANE:dl.XY_PLANE:1===t?e[0]<e[1]?dl.X_LINE:e[2]<e[3]?dl.Y_LINE:dl.Z_LINE:dl.SINGLE_POINT},...ul};const{vtkErrorMacro:fl}=jt;function gl(e,t){t.classHierarchy.push("vtkImageData"),e.setExtent=function(){if(t.deleted)return fl("instance deleted - cannot call any method"),!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=pl.getDataDescriptionFromExtent(t.extent),e.modified()),i},e.setDimensions=function(){let n,r,o;if(t.deleted)fl("instance deleted - cannot call any method");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 fl("Bad dimension specification");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 fl("Requesting a point from an empty image."),null;const o=new Float64Array(3);switch(t.dataDescription){case cl.EMPTY:return null;case cl.SINGLE_POINT:break;case cl.X_LINE:o[0]=n;break;case cl.Y_LINE:o[1]=n;break;case cl.Z_LINE:o[2]=n;break;case cl.XY_PLANE:o[0]=n%r[0],o[1]=n/r[0];break;case cl.YZ_PLANE:o[1]=n%r[1],o[2]=n/r[1];break;case cl.XZ_PLANE:o[0]=n%r[0],o[2]=n/r[0];break;case cl.XYZ_GRID:o[0]=n%r[0],o[1]=n/r[0]%r[1],o[2]=n/(r[0]*r[1]);break;default:fl("Invalid dataDescription")}const a=[0,0,0];return e.indexToWorld(o,a),a},e.getBounds=()=>e.extentToBounds(e.getSpatialExtent()),e.extentToBounds=e=>Wi.transformBounds(e,t.indexToWorld),e.getSpatialExtent=()=>Wi.inflate([...t.extent],.5),e.computeTransforms=()=>{w(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],x(t.indexToWorld,t.indexToWorld,t.spacing),h(t.worldToIndex,t.indexToWorld)},e.indexToWorld=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return Vn(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 Vn(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 Wi.transformBounds(e,t.indexToWorld,n)},e.worldToIndexBounds=function(e){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];return Wi.transformBounds(e,t.worldToIndex,n)},e.onModified(e.computeTransforms),e.computeTransforms(),e.getCenter=()=>Wi.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];Wi.computeCornerPoints(r,o,a),ua(o,o),ua(a,a);const i=e.getDimensions();Ea(o,[0,0,0],[i[0]-1,i[1]-1,i[2]-1],o),Ea(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,v=Math.sqrt(h);return{minimum:d,maximum:u,average:m,variance:h,sigma:v,count:g}},e.computeIncrements=function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;const n=[];let r=t;for(let t=0;t<3;++t)n[t]=r,r*=e[2*t+1]-e[2*t]+1;return n},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 fl(`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 fl(`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 ml={direction:null,indexToWorld:null,worldToIndex:null,spacing:[1,1,1],origin:[0,0,0],extent:[0,-1,0,-1,0,-1],dataDescription:cl.EMPTY};function hl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,ml,n),ll.extend(e,t,n),t.direction?Array.isArray(t.direction)&&(t.direction=new Float64Array(t.direction.slice(0,9))):t.direction=pe(new Float64Array(9)),t.indexToWorld=new Float64Array(16),t.worldToIndex=new Float64Array(16),jt.get(e,t,["indexToWorld","worldToIndex"]),jt.setGetArray(e,t,["origin","spacing"],3),jt.setGetArray(e,t,["direction"],9),jt.getArray(e,t,["extent"],6),gl(e,t)}var vl={newInstance:jt.newInstance(hl,"vtkImageData"),extend:hl};const yl={LUMINANCE:1,LUMINANCE_ALPHA:2,RGB:3,RGBA:4};var Tl={VectorMode:{MAGNITUDE:0,COMPONENT:1,RGBCOLORS:2},ScalarMappingTarget:yl},bl={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:xl,VectorMode:Cl}=Tl,{VtkDataTypes:Sl}=Ns,{ColorMode:Al}=bl,{vtkErrorMacro:Il}=jt;function wl(e){return e}function Pl(e){return Math.floor(255*e+.5)}function Ol(e,t){t.classHierarchy.push("vtkScalarsToColors"),e.setVectorModeToMagnitude=()=>e.setVectorMode(Cl.MAGNITUDE),e.setVectorModeToComponent=()=>e.setVectorMode(Cl.COMPONENT),e.setVectorModeToRGBColors=()=>e.setVectorMode(Cl.RGBCOLORS),e.build=()=>{},e.isOpaque=()=>!0,e.setAnnotations=(n,r)=>{if(!(n&&!r||!n&&r))if(n&&r&&n.length!==r.length)Il("Values and annotations do not have the same number of tuples so ignoring");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===Al.DEFAULT&&(t.getDataType()===Sl.UNSIGNED_CHAR||t.getDataType()===Sl.UNSIGNED_CHAR_CLAMPED)||n===Al.DIRECT_SCALARS&&t)a=e.convertToRGBA(t,o,t.getNumberOfTuples());else{const n={type:"vtkDataArray",name:"temp",numberOfComponents:4,dataType:Sl.UNSIGNED_CHAR},i=jt.newTypedArray(n.dataType,4*t.getNumberOfTuples());n.values=i,n.size=i.length,a=Ns.newInstance(n);let s=r;s<0&&o>1?e.mapVectorsThroughTable(t,a,xl.RGBA,-1,-1):(s<0&&(s=0),s>=o&&(s=o-1),e.mapScalarsThroughTable(t,a,xl.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===Cl.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!==Cl.MAGNITUDE||1!==c&&1!==s||(i=Cl.COMPONENT));let u=0;switch(l>0&&(u=l),i){case Cl.COMPONENT:e.mapScalarsThroughTable(t,n,r,u);break;case Cl.RGBCOLORS:break;case Cl.MAGNITUDE:default:{const o=Ns.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=Pl(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()===Sl.UNSIGNED_CHAR)return n;const i=Ns.newInstance({numberOfComponents:4,empty:!0,size:4*o,dataType:Sl.UNSIGNED_CHAR});if(o<=0)return i;a=a>0?a:0,a=a<1?a:1;let s=wl;switch(n.getDataType()!==Sl.FLOAT&&n.getDataType()!==Sl.DOUBLE||(s=Pl),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 Il("Cannot convert colors"),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!==Al.DEFAULT||n.getDataType()!==Sl.UNSIGNED_CHAR)&&r!==Al.DIRECT_SCALARS||(3===a||1===a?t.alpha>=1:255===n.getRange(a-1)[0])}}const Rl={alpha:1,vectorComponent:0,vectorSize:-1,vectorMode:Cl.COMPONENT,mappingRange:null,annotationArray:null,annotatedValueMap:null,indexedLookup:!1};function Ml(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Rl,n),jt.obj(e,t),t.mappingRange=[0,255],t.annotationArray=[],t.annotatedValueMap=[],jt.setGet(e,t,["vectorSize","vectorComponent","vectorMode","alpha","indexedLookup"]),jt.setArray(e,t,["mappingRange"],2),jt.getArray(e,t,["mappingRange"]),Ol(e,t)}var El={newInstance:jt.newInstance(Ml,"vtkScalarsToColors"),extend:Ml,...Tl};const{vtkErrorMacro:Dl}=jt;function Vl(e,t){t.classHierarchy.push("vtkLookupTable"),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=_a(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===yl.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===yl.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,xa(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 Dl("Expected 4 components for RGBA colors"),!1;if(n.getDataType()!==Cs.UNSIGNED_CHAR)return Dl("Expected unsigned char values for RGBA colors"),!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())}const Ll={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 Bl(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ll,n),El.extend(e,t,n),t.table||(t.table=[]),t.buildTime={},jt.obj(t.buildTime),t.opaqueFlagBuildTime={},jt.obj(t.opaqueFlagBuildTime,{mtime:0}),t.insertTime={},jt.obj(t.insertTime,{mtime:0}),jt.get(e,t,["buildTime"]),jt.setGet(e,t,["numberOfColors","useAboveRangeColor","useBelowRangeColor"]),jt.setArray(e,t,["alphaRange","hueRange","saturationRange","valueRange"],2),jt.setArray(e,t,["nanColor","belowRangeColor","aboveRangeColor"],4),jt.getArray(e,t,["hueRange","saturationRange","valueRange","alphaRange","nanColor","belowRangeColor","aboveRangeColor"]),Vl(e,t)}var Nl={newInstance:jt.newInstance(Bl,"vtkLookupTable"),extend:Bl};const _l={Off:0,PolygonOffset:1};let Fl=_l.PolygonOffset,kl=_l.Off;const Gl=["VTK_RESOLVE_OFF","VTK_RESOLVE_POLYGON_OFFSET"];function Ul(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0;const t=kl===e;return kl=e,t}var zl={Resolve:_l,getResolveCoincidentTopologyAsString:function(){return Gl[kl]},getResolveCoincidentTopologyPolygonOffsetFaces:function(){return Fl},getResolveCoincidentTopology:function(){return kl},setResolveCoincidentTopology:Ul,setResolveCoincidentTopologyPolygonOffsetFaces:function(e){const t=Fl===e;return Fl=e,t},setResolveCoincidentTopologyToDefault:function(){return Ul(_l.Off)},setResolveCoincidentTopologyToOff:function(){return Ul(_l.Off)},setResolveCoincidentTopologyToPolygonOffset:function(){return Ul(_l.PolygonOffset)}};function Wl(e,t,n){n.forEach((n=>{e[`get${n.method}`]=()=>t[n.key],e[`set${n.method}`]=jt.objectSetterMap.object(e,t,{name:n.key,params:["factor","offset"]})}))}const Hl=["Polygon","Line","Point"],jl={modified:()=>{}};Wl(jl,{Polygon:{factor:2,offset:0},Line:{factor:1,offset:-1},Point:{factor:0,offset:-2}},Hl.map((e=>({key:e,method:`ResolveCoincidentTopology${e}OffsetParameters`}))));var Kl={implementCoincidentTopologyMethods:function(e,t){void 0===t.resolveCoincidentTopology&&(t.resolveCoincidentTopology=!1),jt.setGet(e,t,["resolveCoincidentTopology"]),t.topologyOffset={Polygon:{factor:0,offset:0},Line:{factor:0,offset:0},Point:{factor:0,offset:0}},Object.keys(zl).forEach((t=>{e[t]=zl[t]})),Object.keys(jl).filter((e=>"modified"!==e)).forEach((t=>{e[t]=jl[t]})),Wl(e,t.topologyOffset,Hl.map((e=>({key:e,method:`RelativeCoincidentTopology${e}OffsetParameters`})))),e.getCoincidentTopologyPolygonOffsetParameters=()=>{const t=jl.getResolveCoincidentTopologyPolygonOffsetParameters(),n=e.getRelativeCoincidentTopologyPolygonOffsetParameters();return{factor:t.factor+n.factor,offset:t.offset+n.offset}},e.getCoincidentTopologyLineOffsetParameters=()=>{const t=jl.getResolveCoincidentTopologyLineOffsetParameters(),n=e.getRelativeCoincidentTopologyLineOffsetParameters();return{factor:t.factor+n.factor,offset:t.offset+n.offset}},e.getCoincidentTopologyPointOffsetParameter=()=>{const t=jl.getResolveCoincidentTopologyPointOffsetParameters(),n=e.getRelativeCoincidentTopologyPointOffsetParameters();return{factor:t.factor+n.factor,offset:t.offset+n.offset}}},staticOffsetAPI:jl,otherStaticMethods:zl,CATEGORIES:Hl,Resolve:_l};const $l={MIN_KNOWN_PASS:0,ACTOR_PASS:0,COMPOSITE_INDEX_PASS:1,ID_LOW24:2,ID_HIGH24:3,MAX_KNOWN_PASS:3};var ql={PassTypes:$l};const{FieldAssociations:Xl}=ll,{staticOffsetAPI:Yl,otherStaticMethods:Zl}=Kl,{ColorMode:Ql,ScalarMode:Jl,GetArray:ec}=bl,{VectorMode:tc}=Tl,{VtkDataTypes:nc}=Ns;function rc(e){return()=>jt.vtkErrorMacro(`vtkMapper::${e} - NOT IMPLEMENTED`)}function oc(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 ac(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 ic=new WeakMap;function sc(e,t){t.classHierarchy.push("vtkMapper"),e.getBounds=()=>{const n=e.getInputData();return n?(t.static||e.update(),t.bounds=n.getBounds()):t.bounds=Fa(),t.bounds},e.setForceCompileOnly=e=>{t.forceCompileOnly=e},e.setSelectionWebGLIdsToVTKIds=e=>{t.selectionWebGLIdsToVTKIds=e},e.createDefaultLookupTable=()=>{t.lookupTable=Nl.newInstance()},e.getColorModeAsString=()=>jt.enumToString(Ql,t.colorMode),e.setColorModeToDefault=()=>e.setColorMode(0),e.setColorModeToMapScalars=()=>e.setColorMode(1),e.setColorModeToDirectScalars=()=>e.setColorMode(2),e.getScalarModeAsString=()=>jt.enumToString(Jl,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===Jl.DEFAULT)i=e.getPointData().getScalars(),i||(i=e.getCellData().getScalars(),s=!0);else if(n===Jl.USE_POINT_DATA)i=e.getPointData().getScalars();else if(n===Jl.USE_CELL_DATA)i=e.getCellData().getScalars(),s=!0;else if(n===Jl.USE_POINT_FIELD_DATA){const t=e.getPointData();i=r===ec.BY_ID?t.getArrayByIndex(o):t.getArrayByName(a)}else if(n===Jl.USE_CELL_FIELD_DATA){const t=e.getCellData();s=!0,i=r===ec.BY_ID?t.getArrayByIndex(o):t.getArrayByName(a)}else if(n===Jl.USE_FIELD_DATA){const t=e.getFieldData();i=r===ec.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();i&&Nl.getLogRange(a,a);const s=t.lookupTable.getAlpha();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,u=n**3-3,d=4094,p=2,f=r?u:d;t.numberOfColorsInRange=Math.min(Math.max(e,p),f);const g=t.numberOfColorsInRange+3,m=t.numberOfColorsInRange+2,h=r?[Math.min(Math.ceil(g/n**0),n),Math.min(Math.ceil(g/n**1),n),Math.min(Math.ceil(g/n**2),n)]:[m,2,1],v=h[0]*h[1]*h[2],y=new Float64Array(v);y.fill(NaN);const T=t.numberOfColorsInRange,b=T+2,x=[0,0,0],C=a[0],S=a[1]-a[0];for(let e=0;e<b;++e){const t=C+S*(e-1)/(T-1);y[(c=h,(l=x)[0]+c[0]*(l[1]+c[1]*l[2]))]=i?10**t:t,oc(x,h)}const A=Ns.newInstance({numberOfComponents:1,values:y}),I=t.lookupTable.mapScalars(A,t.colorMode,0);t.colorTextureMap=vl.newInstance(),t.colorTextureMap.setDimensions(h),t.colorTextureMap.getPointData().setScalars(I),t.lookupTable.setAlpha(s)}var l,c;const u=t.lookupTable.getVectorMode()===tc.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("/"),c=ic.get(e);if(c&&c.stringHash===l)return c.textureCoordinates;const u=(n[1]-n[0])/(r-1),[d,p]=[n[0]-u,n[1]+u],f=d-.5*u,g=1/(p-d+u),m=d,h=(r+1)/(p-d),v=e.getData(),y=e.getNumberOfTuples(),T=e.getNumberOfComponents(),b=t<0||t>=T,x=o[2]<=1?2:3,C=Ns.newInstance({numberOfComponents:x,values:new Float32Array(y*x)}),S=C.getData(),A=[0,0,0];ac(A,r+2,o);let I=0,w=0;const P=[.5,.5,.5];for(let e=0;e<y;++e){let e;if(b){let t=0;for(let e=0;e<T;++e){const n=v[I+e];t+=n*n}e=Math.sqrt(t)}else e=v[I+t];if(I+=T,a&&(e=Nl.applyLogScale(e,n,n)),_a(e))P[0]=A[0],P[1]=A[1],P[2]=A[2];else if(i){let t=(e-m)*h;t<1?t=0:t>r&&(t=r+1),ac(P,t,o)}else{P[1]=.49;const t=(e-f)*g;P[0]=t>1e3?1e3:t<-1e3?-1e3:t}for(let e=0;e<x;++e)S[w++]=P[e]}return ic.set(e,{stringHash:l,textureCoordinates:C}),C}(n,u,a,t.numberOfColorsInRange,t.colorTextureMap.getDimensions(),i,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===Ql.DIRECT_SCALARS)&&(!t.interpolateScalarsBeforeMapping||t.lookupTable&&t.lookupTable.getIndexedLookup()||!e||t.colorMode===Ql.DEFAULT&&e.getDataType()===nc.UNSIGNED_CHAR||t.colorMode===Ql.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=rc("AcquireInvertibleLookupTable"),e.valueToColor=rc("ValueToColor"),e.colorToValue=rc("ColorToValue"),e.useInvertibleColorFor=rc("UseInvertibleColorFor"),e.clearInvertibleColor=rc("ClearInvertibleColor"),e.processSelectorPixelBuffers=(e,n)=>{if(!e||!t.selectionWebGLIdsToVTKIds||!t.populateSelectionSettings)return;const r=e.getRawPixelBuffer($l.ID_LOW24),o=e.getRawPixelBuffer($l.ID_HIGH24),a=e.getCurrentPass(),i=e.getFieldAssociation();let s=null;i===Xl.FIELD_ASSOCIATION_POINTS?s=t.selectionWebGLIdsToVTKIds.points:i===Xl.FIELD_ASSOCIATION_CELLS&&(s=t.selectionWebGLIdsToVTKIds.cells),s&&n.forEach((t=>{if(a===$l.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($l.ID_LOW24);i[t]=255&a,i[t+1]=(65280&a)>>8,i[t+2]=(16711680&a)>>16}else if(a===$l.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($l.ID_HIGH24)[t]=(4278190080&a)>>24}}))}}const lc={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 cc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,lc,n),zs(e,t,n),jt.get(e,t,["areScalarsMappedFromCells","colorCoordinates","colorMapColors","colorTextureMap","numberOfColorsInRange","selectionWebGLIdsToVTKIds"]),jt.setGet(e,t,["colorByArrayName","arrayAccessMode","colorMode","fieldDataTupleId","interpolateScalarsBeforeMapping","lookupTable","populateSelectionSettings","renderTime","scalarMode","scalarVisibility","static","useLookupTableScalarRange","customShaderAttributes"]),jt.setGetArray(e,t,["scalarRange"],2),Kl.implementCoincidentTopologyMethods(e,t),sc(e,t)}var uc={newInstance:jt.newInstance(cc,"vtkMapper"),extend:cc,...Yl,...Zl,...bl};function dc(e){let t=0;return e.filter(((e,n)=>n===t&&(t+=e+1,!0)))}function pc(e){let t=0;for(let n=0;n<e.length;)n+=e[n]+1,t++;return t}const fc={extractCellSizes:dc,getNumberOfCells:pc};function gc(e,t){t.classHierarchy.push("vtkCellArray");const n={...e};e.getNumberOfCells=n=>void 0===t.numberOfCells||n?(t.cellSizes?t.numberOfCells=t.cellSizes.length:t.numberOfCells=pc(e.getData()),t.numberOfCells):t.numberOfCells,e.getCellSizes=n=>void 0===t.cellSizes||n?(t.cellSizes=dc(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=>{const r=e.getNumberOfCells();return e.insertNextTuples([n.length,...n]),++t.numberOfCells,null!=t.cellSizes&&t.cellSizes.push(n.length),r}}function mc(e){return{empty:!0,numberOfComponents:1,dataType:Cs.UNSIGNED_INT,...e}}function hc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Ns.extend(e,t,mc(n)),gc(e,t)}var vc={newInstance:jt.newInstance(hc,"vtkCellArray"),extend:hc,...fc};const{vtkErrorMacro:yc}=jt,Tc=[1,-1,1,-1,1,-1];function bc(e,t){t.classHierarchy.push("vtkPoints"),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=jt.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.getBounds=()=>{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);return t.bounds[4]=o[0],t.bounds[5]=o[1],t.bounds}if(2!==e.getNumberOfComponents())return yc(`getBounds called on an array with components of\n        ${e.getNumberOfComponents()}`),Tc;const n=e.getRange(0);t.bounds[0]=n[0],t.bounds[1]=n[1];const r=e.getRange(1);return t.bounds[2]=r[0],t.bounds[3]=r[1],t.bounds[4]=0,t.bounds[5]=0,t.bounds},e.computeBounds=e.getBounds,e.setNumberOfComponents(t.numberOfComponents<2?3:t.numberOfComponents)}const xc={empty:!0,numberOfComponents:3,dataType:Cs.FLOAT,bounds:[1,-1,1,-1,1,-1]};function Cc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,xc,n),Ns.extend(e,t,n),bc(e,t)}var Sc={newInstance:jt.newInstance(Cc,"vtkPoints"),extend:Cc};function Ac(e,t){t.classHierarchy.push("vtkCell"),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=jt.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=()=>{const e=t.points.getNumberOfPoints(),n=[];if(e){t.points.getPoint(0,n),t.bounds[0]=n[0],t.bounds[1]=n[0],t.bounds[2]=n[1],t.bounds[3]=n[1],t.bounds[4]=n[2],t.bounds[5]=n[2];for(let r=1;r<e;r++)t.points.getPoint(r,n),t.bounds[0]=n[0]<t.bounds[0]?n[0]:t.bounds[0],t.bounds[1]=n[0]>t.bounds[1]?n[0]:t.bounds[1],t.bounds[2]=n[1]<t.bounds[2]?n[1]:t.bounds[2],t.bounds[3]=n[1]>t.bounds[3]?n[1]:t.bounds[3],t.bounds[4]=n[2]<t.bounds[4]?n[2]:t.bounds[4],t.bounds[5]=n[2]>t.bounds[5]?n[2]:t.bounds[5]}else Oa(t.bounds);return t.bounds},e.getLength2=()=>{e.getBounds();let n=0,r=0;for(let e=0;e<3;e++)r=t.bounds[2*e+1]-t.bounds[2*e],n+=r*r;return n},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)=>{jt.vtkErrorMacro("vtkCell.evaluatePosition is not implemented.")}}const Ic={bounds:[-1,-1,-1,-1,-1,-1],pointsIds:[]};function wc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Ic,n),jt.obj(e,t),t.points||(t.points=Sc.newInstance()),jt.get(e,t,["points","pointsIds"]),Ac(e,t)}var Pc={newInstance:jt.newInstance(wc,"vtkCell"),extend:wc};function Oc(e,t){t.classHierarchy.push("vtkCellLinks"),e.buildLinks=n=>{const r=n.getPoints().getNumberOfPoints(),o=n.getNumberOfCells(),a=new Uint32Array(r);if(n.isA("vtkPolyData")){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++)Pc.newInstance().getPointsIds().forEach((t=>{e.incrementLinkCount(t)}));e.allocateLinks(r),t.maxId=r-1;for(let t=0;t<o;++t)Pc.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}}const Rc={array:null,maxId:0,extend:0};function Mc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Rc,n),jt.obj(e,t),Oc(e,t)}var Ec={newInstance:jt.newInstance(Mc,"vtkCellLinks"),extend:Mc};const Dc=0,Vc=1,Lc=2,Bc=3,Nc=4,_c=5,Fc=6,kc=7,Gc=9,Uc=21,zc=41,Wc=42,Hc=["vtkEmptyCell","vtkVertex","vtkPolyVertex","vtkLine","vtkPolyLine","vtkTriangle","vtkTriangleStrip","vtkPolygon","vtkPixel","vtkQuad","vtkTetra","vtkVoxel","vtkHexahedron","vtkWedge","vtkPyramid","vtkPentagonalPrism","vtkHexagonalPrism","UnknownClass","UnknownClass","UnknownClass","UnknownClass","vtkQuadraticEdge","vtkQuadraticTriangle","vtkQuadraticQuad","vtkQuadraticTetra","vtkQuadraticHexahedron","vtkQuadraticWedge","vtkQuadraticPyramid","vtkBiQuadraticQuad","vtkTriQuadraticHexahedron","vtkQuadraticLinearQuad","vtkQuadraticLinearWedge","vtkBiQuadraticQuadraticWedge","vtkBiQuadraticQuadraticHexahedron","vtkBiQuadraticTriangle","vtkCubicLine","vtkQuadraticPolygon","UnknownClass","UnknownClass","UnknownClass","UnknownClass","vtkConvexPointSet","UnknownClass","UnknownClass","UnknownClass","UnknownClass","UnknownClass","UnknownClass","UnknownClass","UnknownClass","UnknownClass","vtkParametricCurve","vtkParametricSurface","vtkParametricTriSurface","vtkParametricQuadSurface","vtkParametricTetraRegion","vtkParametricHexRegion","UnknownClass","UnknownClass","UnknownClass","vtkHigherOrderEdge","vtkHigherOrderTriangle","vtkHigherOrderQuad","vtkHigherOrderPolygon","vtkHigherOrderTetrahedron","vtkHigherOrderWedge","vtkHigherOrderPyramid","vtkHigherOrderHexahedron"],jc={getClassNameFromTypeId:function(e){return e<Hc.length?Hc[e]:"UnknownClass"},getTypeIdFromClassName:function(e){return Hc.findIndex(e)},isLinear:function(e){return e<Uc||e===zc||e===Wc},hasSubCells:function(e){return e===Fc||e===Nc||e===Lc}};function Kc(e,t){t.classHierarchy.push("vtkCellTypes"),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]=Dc},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()}}const $c={size:0,maxId:-1,extend:1e3};function qc(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,$c,n),jt.obj(e,t),jt.get(e,t,["size","maxId","extend"]),jt.getArray(e,t,["typeArray","locationArray"]),Kc(e,t)}var Xc={newInstance:jt.newInstance(qc,"vtkCellTypes"),extend:qc,...jc},Yc={IntersectionState:{NO_INTERSECTION:0,YES_INTERSECTION:1,ON_LINE:2}};const{IntersectionState:Zc}=Yc;function Qc(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=jo(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=Yo(i,e),o}function Jc(e,t,n,r,o,a){const i=[],s=[],l=[];o[0]=0,a[0]=0,Uo(t,e,i),Uo(r,n,s),Uo(n,e,l);const c=[jo(i,i),-jo(i,s),-jo(i,s),jo(s,s)],u=[];if(u[0]=jo(i,l),u[1]=-jo(s,l),0===va(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=Qc(s[e],l[e],c[e]),u.distance<i&&(i=u.distance);return Zc.ON_LINE}return o[0]=u[0],a[0]=u[1],o[0]>=0&&o[0]<=1&&a[0]>=0&&a[0]<=1?Zc.YES_INTERSECTION:Zc.NO_INTERSECTION}const eu={distanceToLine:Qc,intersection:Jc};function tu(e,t){t.classHierarchy.push("vtkLine"),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=Jc(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===Zc.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(Yo(o,s)<=r*r)return i.intersect=1,i}else{let t;if(i.t<0)return t=Qc(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=Qc(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=Qc(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=Qc(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,i,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];(i=u*g+d*m+p*h+f*v)<0&&(i=-i,g=-g,m=-m,h=-h,v=-v),1-i>a?(o=Math.acos(i),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)}const nu={orientations:null};function ru(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,nu,n),Pc.extend(e,t,n),jt.setGet(e,t,["orientations"]),tu(e,t)}var ou={newInstance:jt.newInstance(ru,"vtkLine"),extend:ru,...eu,...Yc};function au(e,t){t.classHierarchy.push("vtkPointSet"),t.points?t.points=We(t.points):t.points=Sc.newInstance(),e.getNumberOfPoints=()=>t.points.getNumberOfPoints(),e.getBounds=()=>t.points.getBounds(),e.computeBounds=()=>{e.getBounds()};const n=e.shallowCopy;e.shallowCopy=function(e){let r=arguments.length>1&&void 0!==arguments[1]&&arguments[1];n(e,r),t.points=Sc.newInstance(),t.points.shallowCopy(e.getPoints())}}const iu={};function su(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,iu,n),ll.extend(e,t,n),jt.setGet(e,t,["points"]),au(e,t)}var lu={newInstance:jt.newInstance(su,"vtkPointSet"),extend:su};function cu(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 uu(e,t,n,r){cu(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)}const du={computeNormalDirection:cu,computeNormal:uu,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=[];uu(e,t,n,d),uu(r,o,a,p);const f=-jo(d,e),g=-jo(p,r),m=[jo(p,e)+g,jo(p,t)+g,jo(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=[jo(d,r)+f,jo(d,o)+f,jo(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],y=[r,o,a],T=jo(d,p),b=(f-g*T)/(T*T-1),x=(g-f*T)/(T*T-1),C=[b*d[0]+x*p[0],b*d[1]+x*p[1],b*d[2]+x*p[2]],S=Ko(d,p,[]);qo(S);let A=0,I=0;const w=[],P=[];let O,R,M=50,E=50;for(let t=0;t<3;t++){const n=t,o=(t+1)%3,a=ii.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++]=jo(a.x,S)-jo(C,S));const s=ii.intersectWithLine(y[n],y[o],e,d);s.intersection&&s.t>0-i&&s.t<1+i&&(s.t<1+i&&s.t>1-i&&(E=I),P[I++]=jo(s.x,S)-jo(C,S))}if(A>2){A--;const e=w[2];w[2]=w[M],w[M]=e}if(I>2){I--;const e=P[2];P[2]=P[E],P[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(P[0])||Number.isNaN(P[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(P[0]>P[1]){const e=P[1];P[1]=P[0],P[0]=e}return w[1]<P[0]||P[1]<w[0]?{intersect:!1,coplanar:s,pt1:l,pt2:c,surfaceId:u}:(w[0]<P[0]?w[1]<P[1]?(u[0]=2,u[1]=1,O=P[0],R=w[1]):(u[0]=2,u[1]=2,O=P[0],R=P[1]):w[1]<P[1]?(u[0]=1,u[1]=1,O=w[0],R=w[1]):(u[0]=1,u[1]=2,O=w[0],R=P[1]),Ho(C,S,O,l),Ho(C,S,R,c),{intersect:!0,coplanar:s,pt1:l,pt2:c,surfaceId:u})}};function pu(e,t){t.classHierarchy.push("vtkTriangle"),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(uu(u,d,p,f),0!==f[0]||0!==f[1]||0!==f[2]){const t=ii.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=Yo(u,d),h=Yo(d,p),v=Yo(p,u);t.line||(t.line=ou.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 y=t.line.intersectWithLine(n,r,o,a,i);if(s.betweenPoints=y.betweenPoints,s.t=y.t,y.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]=jo(n,e)/v,i[1]=jo(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 y=[];let T,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),cu(l,c,u,d),ii.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&&(y[s++]=i);for(i=0;i<2;i++)f[i]=I[y[i]]-u[y[i]],g[i]=l[y[i]]-u[y[i]],m[i]=c[y[i]]-u[y[i]];if(h=Jo(g,m),0===h)return r[0]=0,r[1]=0,a.evaluation=-1,a;if(r[0]=Jo(f,m)/h,r[1]=Jo(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=Yo(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(T=Yo(e,u),b=ou.distanceToLine(e,l,u,t,S),x=ou.distanceToLine(e,u,c,t,A),T<b?(a.dist2=T,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(T=Yo(e,l),b=ou.distanceToLine(e,l,u,t,S),x=ou.distanceToLine(e,l,c,t,A),T<b?(a.dist2=T,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(T=Yo(e,c),b=ou.distanceToLine(e,c,u,t,S),x=ou.distanceToLine(e,l,c,t,A),T<b?(a.dist2=T,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=ou.distanceToLine(e,l,c,n);a.dist2=t.distance}else if(o[1]<0){const t=ou.distanceToLine(e,c,u,n);a.dist2=t.distance}else if(o[2]<0){const t=ou.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}}const fu={};function gu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,fu,n),Pc.extend(e,t,n),pu(e,t)}var mu={newInstance:jt.newInstance(gu,"vtkTriangle"),extend:gu,...du};const hu=["verts","lines","polys","strips"],{vtkWarningMacro:vu}=jt,yu={[Bc]:ou,[Nc]:ou,[_c]:mu};function Tu(e,t){t.classHierarchy.push("vtkPolyData"),hu.forEach((n=>{e[`getNumberOf${function(e){return e.replace(/(?:^\w|[A-Z]|\b\w)/g,(e=>e.toUpperCase())).replace(/\s+/g,"")}(n)}`]=()=>t[n].getNumberOfCells(),t[n]?t[n]=We(t[n]):t[n]=vc.newInstance()})),e.getNumberOfCells=()=>hu.reduce(((e,n)=>e+t[n].getNumberOfCells()),0);const n=e.shallowCopy;e.shallowCopy=function(e){let r=arguments.length>1&&void 0!==arguments[1]&&arguments[1];n(e,r),hu.forEach((n=>{t[n]=vc.newInstance(),t[n].shallowCopy(e.getReferenceByName(n))}))},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?Lc:Vc,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?Nc:Bc,1===t&&vu("Building VTK_LINE ",n," with only one point, but VTK_LINE needs at least two points. Check the input."),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]=_c;break;case 4:l[n]=Gc;break;default:l[n]=kc}t<3&&vu("Building VTK_TRIANGLE ",n," with less than three points, but VTK_TRIANGLE needs at least three points. Check the input."),e+=t+1})),u+=u.subarray(o),l+=l.subarray(o)}if(a){let e=0;l.fill(Fc,0,a),t.strips.getCellSizes().forEach(((t,n)=>{u[n]=e,e+=t+1}))}t.cells=Xc.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=Ec.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 Vc:case Lc:o=t.verts;break;case Bc:case Nc:o=t.lines;break;case _c:case Gc:case kc:o=t.polys;break;case Fc: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||yu[r.cellType].newInstance();return o.initialize(e.getPoints(),r.cellPointIds),o}}const bu={};function xu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,bu,n),lu.extend(e,t,n),jt.get(e,t,["cells","links"]),jt.setGet(e,t,["verts","lines","polys","strips"]),Tu(e,t)}var Cu={newInstance:jt.newInstance(xu,"vtkPolyData"),extend:xu};function Su(e,t){t.classHierarchy.push("vtkTexture"),e.imageLoaded=()=>{t.image.removeEventListener("load",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.jsImageData=n,t.imageLoaded=!0,e.modified())},e.setCanvas=n=>{t.canvas!==n&&(null!==n&&(e.setInputData(null),e.setInputConnection(null),t.image=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.image=n,t.imageLoaded=!1,n.complete?e.imageLoaded():n.addEventListener("load",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),(n>1)+(r>1)+(o>1)},e.getInputAsJsImageData=()=>{if(!t.imageLoaded||e.getInputData())return null;if(t.jsImageData)return t.jsImageData();if(t.canvas)return t.canvas.getContext("2d").getImageData(0,0,t.canvas.width,t.canvas.height);if(t.image){const e=document.createElement("canvas");e.width=t.image.width,e.height=t.image.height;const n=e.getContext("2d");return n.translate(0,e.height),n.scale(1,-1),n.drawImage(t.image,0,0,t.image.width,t.image.height),n.getImageData(0,0,e.width,e.height)}return null}}const Au={image:null,canvas:null,jsImageData:null,imageLoaded:!1,repeat:!1,interpolate:!1,edgeClamp:!1,mipLevel:0,resizable:!1};function Iu(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Au,n),jt.obj(e,t),jt.algo(e,t,6,0),jt.get(e,t,["canvas","image","jsImageData","imageLoaded","resizable"]),jt.setGet(e,t,["repeat","edgeClamp","interpolate","mipLevel"]),Su(e,t)}const wu={generateMipmaps:(e,t,n,r)=>{const o=[1,2,1],a=e.length/(t*n);let i=t,s=n,l=e;const c=[l];for(let e=0;e<r;e++){const e=[...l];i/=2,s/=2,l=new Uint8ClampedArray(i*s*a);const t=a*i;let n=0;for(let r=0;r<l.length;r+=a){r%t==0&&(n+=2*a*i);for(let o=0;o<a;o++){let i=e[n+o];i+=e[n+a+o],i+=e[n-2*t+o],i+=e[n-2*t+a+o],i/=4,l[r+o]=i}n+=2*a}let r=[...l];for(let e=0;e<l.length;e+=a)for(let n=0;n<a;n++){let i=-(o.length-1)/2,s=4,c=0;for(let l=0;l<o.length;l++){let u=e+n+i*a;const d=u%t-(e+n)%t;d>a&&(u+=t),d<-a&&(u-=t),r[u]?c+=r[u]*o[l]:s-=o[l],i+=1}l[e+n]=c/s}r=[...l];for(let e=0;e<l.length;e+=a)for(let n=0;n<a;n++){let a=-(o.length-1)/2,i=4,s=0;for(let l=0;l<o.length;l++){const c=e+n+a*t;r[c]?s+=r[c]*o[l]:i-=o[l],a+=1}l[e+n]=s/i}c.push(l)}return c}};var Pu={newInstance:jt.newInstance(Iu,"vtkTexture"),extend:Iu,...wu};const Ou=[[-1,0,0],[1,0,0],[0,-1,0],[0,1,0],[0,0,-1],[0,0,1]],Ru=[[8,7,11,3],[9,1,10,5],[4,9,0,8],[2,11,6,10],[0,3,2,1],[4,5,6,7]],Mu=[[0,1],[1,3],[2,3],[0,2],[4,5],[5,7],[6,7],[4,6],[0,4],[1,5],[3,7],[2,6]],Eu=[0,1,0,1,0,1,0,1,2,2,2,2],Du=[[1,2],[1,2],[0,2],[0,2],[0,1],[0,1]],Vu=new Float64Array(3),Lu=new Float64Array(3),Bu=new Float64Array(3),Nu=new Float64Array(3),_u=new Float64Array(3),Fu=new Float64Array(3),ku=new Float64Array(16);function Gu(e,t){e.strokeStyle=t.strokeColor,e.lineWidth=t.strokeSize,e.fillStyle=t.fontColor,e.font=`${t.fontStyle} ${t.fontSize}px ${t.fontFamily}`}function Uu(e){const t=[],n=[];for(let r=0;r<3;r++){const o=go().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}}function zu(e,t){t.classHierarchy.push("vtkCubeAxesActorHelper"),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;Vu[0]=c[3*n],Vu[1]=c[3*n+1],Vu[2]=c[3*n+2],Vn(Bu,Vu,r),Bu[0]+=.1,Vn(Lu,Bu,o),Pn(_u,Lu,Vu),Bu[0]-=.1,Bu[1]+=.1,Vn(Lu,Bu,o),Pn(Fu,Lu,Vu);for(let e=0;e<3;e++)_u[e]/=.05*u[0],Fu[e]/=.05*u[1];let d=s.ptIdx,p=s.cellIdx;Vu[0]=c[3*n],Vu[1]=c[3*n+1],Vu[2]=c[3*n+2],a[0]<-.5?On(Bu,_u,a[0]*i-l.width):a[0]>.5?On(Bu,_u,a[0]*i):On(Bu,_u,a[0]*i-l.width/2),wn(Vu,Vu,Bu),On(Bu,Fu,a[1]*i-l.height/2),wn(Vu,Vu,Bu),s.points[3*d]=Vu[0],s.points[3*d+1]=Vu[1],s.points[3*d+2]=Vu[2],s.tcoords[2*d]=l.tcoords[0],s.tcoords[2*d+1]=l.tcoords[1],d++,On(Bu,_u,l.width),wn(Vu,Vu,Bu),s.points[3*d]=Vu[0],s.points[3*d+1]=Vu[1],s.points[3*d+2]=Vu[2],s.tcoords[2*d]=l.tcoords[2],s.tcoords[2*d+1]=l.tcoords[3],d++,On(Bu,Fu,l.height),wn(Vu,Vu,Bu),s.points[3*d]=Vu[0],s.points[3*d+1]=Vu[1],s.points[3*d+2]=Vu[2],s.tcoords[2*d]=l.tcoords[4],s.tcoords[2*d+1]=l.tcoords[5],d++,On(Bu,_u,l.width),Pn(Vu,Vu,Bu),s.points[3*d]=Vu[0],s.points[3*d+1]=Vu[1],s.points[3*d+2]=Vu[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);m(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);h(ku,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;){Vu[0]=f[3*u],Vu[1]=f[3*u+1],Vu[2]=f[3*u+2],Vn(Bu,Vu,n),Vu[0]=f[3*u+3],Vu[1]=f[3*u+4],Vu[2]=f[3*u+5],Vn(Nu,Vu,n),Pn(Bu,Bu,Nu);const r=[Bu[0],Bu[1]];Qo(r),e.createPolyDataForOneLabel(g[d],u,n,ku,r,t.renderable.getAxisTitlePixelOffset(),c),u+=2,d++;for(let o=0;o<t.renderable.getTickCounts()[p];o++)e.createPolyDataForOneLabel(g[d],u,n,ku,r,t.renderable.getTickLabelPixelOffset(),c),u++,d++;p++}const v=Ns.newInstance({numberOfComponents:2,values:l,name:"TextureCoordinates"});t.tmPolyData.getPointData().setTCoords(v),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()}}const Wu=jt.newInstance((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{renderable:null};Object.assign(t,{},n),jt.obj(e,t),t.tmPolyData=Cu.newInstance(),t.tmMapper=uc.newInstance(),t.tmMapper.setInputData(t.tmPolyData),t.tmActor=bs.newInstance({parentProp:e}),t.tmActor.setMapper(t.tmMapper),jt.setGet(e,t,["renderable"]),jt.get(e,t,["lastSize","lastAspectRatio","axisTextStyle","tickTextStyle","tmActor","ticks"]),t.forceUpdate=!1,t.lastRedrawTime={},jt.obj(t.lastRedrawTime,{mtime:0}),t.lastRebuildTime={},jt.obj(t.lastRebuildTime,{mtime:0}),t.lastSize=[-1,-1],t.lastTickBounds=[],zu(e,t)}),"vtkCubeAxesActorHelper");function Hu(e,t){t.classHierarchy.push("vtkCubeAxesActor"),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();m(e,e);let n=!1;const r=Wi.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]&&(Vu[s]=t.dataBounds[a]-.1*r*Ou[a][s],Vu[l]=.5*(t.dataBounds[2*l]+t.dataBounds[2*l+1]),Vu[c]=.5*(t.dataBounds[2*c]+t.dataBounds[2*c+1]),Vn(Bu,Vu,e),Vu[s]=t.dataBounds[a],Vn(Nu,Vu,e),Pn(Bu,Nu,Bu),Mn(Bu,Bu),i=Bu[2]>o,t.camera.getParallelProjection()||(Mn(Nu,Nu),i=En(Nu,Bu)>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[Du[t][0]].length+2*r[Du[t][1]].length,a+=r[Du[t][0]].length+r[Du[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]=Mu[e][0],l[3*u+2]=Mu[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[Du[n][0]];for(let r=0;r<o.length;r++)s[3*c+e]=t.dataBounds[n],s[3*c+Du[n][0]]=o[r],s[3*c+Du[n][1]]=t.dataBounds[2*Du[n][1]],c++,s[3*c+e]=t.dataBounds[n],s[3*c+Du[n][0]]=o[r],s[3*c+Du[n][1]]=t.dataBounds[2*Du[n][1]+1],c++,l[3*u]=2,l[3*u+1]=c-2,l[3*u+2]=c-1,u++;o=r[Du[n][1]];for(let r=0;r<o.length;r++)s[3*c+e]=t.dataBounds[n],s[3*c+Du[n][1]]=o[r],s[3*c+Du[n][0]]=t.dataBounds[2*Du[n][0]],c++,s[3*c+e]=t.dataBounds[n],s[3*c+Du[n][1]]=o[r],s[3*c+Du[n][0]]=t.dataBounds[2*Du[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[Eu[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=Ru[a][e];if(1===n[d]){const e=Eu[d],n=3*Mu[d][0],p=3*Mu[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+Du[a][0]]=.5*(t.dataBounds[2*Du[a][0]]+t.dataBounds[2*Du[a][0]+1]),s[3*l+Du[a][1]]=.5*(t.dataBounds[2*Du[a][1]]+t.dataBounds[2*Du[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[Ru[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="bottom",t.tmContext.textAlign="left",t._tmAtlas.clear();let n=0,r=1;for(let o=0;o<3;o++){if(!t._tmAtlas.has(t.axisLabels[o])){Gu(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)}Gu(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=_o(n),r=_o(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="bottom",t.tmContext.textAlign="left",t.tmContext.clearRect(0,0,n,r),t._tmAtlas.forEach(((e,n)=>{Gu(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(),Wi.setBounds(t.bounds,t.gridActor.getBounds()),Wi.scaleAboutCenter(t.bounds,t.boundsScaleFactor,t.boundsScaleFactor,t.boundsScaleFactor),t.bounds);const n=jt.chain(e.setProperty,t.gridActor.setProperty);e.setProperty=e=>n(e)[0]}function ju(e,t,n){return{boundsScaleFactor:1.3,camera:null,dataBounds:[...Wi.INIT_BOUNDS],faceVisibilityAngle:8,gridLines:!0,axisLabels:null,axisTitlePixelOffset:35,tickLabelPixelOffset:12,generateTicks:Uu,...n,axisTextStyle:{fontColor:"white",fontStyle:"normal",fontSize:18,fontFamily:"serif",...n?.axisTextStyle},tickTextStyle:{fontColor:"white",fontStyle:"normal",fontSize:14,fontFamily:"serif",...n?.tickTextStyle}}}function Ku(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};bs.extend(e,t,ju(0,0,n)),t.lastFacesToDraw=[!1,!1,!1,!1,!1,!1],t.axisLabels=["X-Axis","Y-Axis","Z-Axis"],t.tickCounts=[],t.textValues=[],t.lastTickBounds=[],t.tmCanvas=document.createElement("canvas"),t.tmContext=t.tmCanvas.getContext("2d"),t._tmAtlas=new Map,t.tmTexture=Pu.newInstance({resizable:!0}),t.tmTexture.setInterpolate(!1),e.getProperty().setDiffuse(0),e.getProperty().setAmbient(1),t.gridMapper=uc.newInstance(),t.polyData=Cu.newInstance(),t.gridMapper.setInputData(t.polyData),t.gridActor=bs.newInstance(),t.gridActor.setMapper(t.gridMapper),t.gridActor.setProperty(e.getProperty()),t.gridActor.setParentProp(e),t.textPolyData=Cu.newInstance(),jt.setGet(e,t,["axisTitlePixelOffset","boundsScaleFactor","faceVisibilityAngle","gridLines","tickLabelPixelOffset","generateTicks"]),jt.setGetArray(e,t,["dataBounds"],6),jt.setGetArray(e,t,["axisLabels"],3),jt.get(e,t,["axisTextStyle","tickTextStyle","camera","tmTexture","textValues","textPolyData","tickCounts","gridActor"]),Hu(e,t)}var $u={newInstance:jt.newInstance(Ku,"vtkCubeAxesActor"),extend:Ku,newCubeAxesActorHelper:Wu,defaultGenerateTicks:Uu};function qu(e,t){t.classHierarchy.push("vtkOpenGLCubeAxesActor"),e.buildPass=n=>{n&&(t._openGLRenderer=e.getFirstAncestorOfType("vtkOpenGLRenderer"),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())}}}const Xu={};const Yu=Dt((function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Xu,n),Zt.extend(e,t,n),t.CubeAxesActorHelper=$u.newCubeAxesActorHelper(),qu(e,t)}),"vtkOpenGLCubeAxesActor");rn("vtkCubeAxesActor",Yu);const Zu={ARRAY_BUFFER:0,ELEMENT_ARRAY_BUFFER:1,TEXTURE_BUFFER:2};var Qu={ObjectType:Zu};const{ObjectType:Ju}=Qu;function ed(e,t){function n(e){switch(e){case Ju.ELEMENT_ARRAY_BUFFER:return t.context.ELEMENT_ARRAY_BUFFER;case Ju.TEXTURE_BUFFER:if("TEXTURE_BUFFER"in t.context)return t.context.TEXTURE_BUFFER;case Ju.ARRAY_BUFFER:default:return t.context.ARRAY_BUFFER}}t.classHierarchy.push("vtkOpenGLBufferObject");let r=null,o=null,a=!0,i="";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="Trying to upload array buffer to incompatible buffer.",!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}const td={objectType:Ju.ARRAY_BUFFER,context:null,allocatedGPUMemoryInBytes:0};function nd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,td,n),jt.obj(e,t),jt.get(e,t,["_openGLRenderWindow","allocatedGPUMemoryInBytes"]),jt.moveToProtected(e,t,["openGLRenderWindow"]),ed(e,t)}var rd={newInstance:jt.newInstance(nd),extend:nd,...Qu};const{vtkErrorMacro:od}=jt;function ad(e,t){t.classHierarchy.push("vtkOpenGLCellArrayBufferObject"),e.setType(Zu.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=rd.newInstance()),t.colorBO.setOpenGLRenderWindow(t._openGLRenderWindow)):t.colorBO=null,t.stride=4*t.blockSize;let f,g=0,m=0,h=0,v=0,y=0,T=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)=>e,linesToWireframe:(e,t)=>e>1?2*(e-1):0,polysToWireframe:(e,t)=>e>2?2*e:0,stripsToWireframe:(e,t)=>e>2?4*e-6:0,polysToSurface:(e,t)=>e>2?3*(e-2):0,stripsToSurface:(e,t,n)=>e>2?3*(e-2):0};let C=null,S=null;o===ss.POINTS||"verts"===r?(C=b.anythingToPoints,S=x.anythingToPoints):o===ss.WIREFRAME||"lines"===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 P=null;const O=new Float32Array(w*t.blockSize);u&&(P=new Uint8Array(4*w));let R=0,M=0,E=0,D=0;for(let e=0;e<3;++e){const t=a.points.getRange(e),n=t[1]-t[0];E+=n*n;const r=.5*(t[1]+t[0]);D+=r*r}const V=E>0&&(Math.abs(D)/E>1e6||Math.abs(Math.log10(E))>3||0===E&&D>1e6);if(V){const t=new Float64Array(3),n=new Float64Array(3);for(let e=0;e<3;++e){const r=a.points.getRange(e),o=r[1]-r[0];t[e]=.5*(r[1]+r[0]),n[e]=o>0?1/o:1}e.setCoordShiftAndScale(t,n)}else!0===t.coordShiftAndScaleEnabled&&e.setCoordShiftAndScale(null,null);if(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]=T+a.cellOffset),++L,g=3*e,t.coordShiftAndScaleEnabled?(O[R++]=(s[g++]-t.coordShift[0])*t.coordScale[0],O[R++]=(s[g++]-t.coordShift[1])*t.coordScale[1],O[R++]=(s[g++]-t.coordShift[2])*t.coordScale[2]):(O[R++]=s[g++],O[R++]=s[g++],O[R++]=s[g++]),null!==l&&(m=a.haveCellNormals?3*(T+a.cellOffset):3*e,O[R++]=l[m++],O[R++]=l[m++],O[R++]=l[m++]),t.customData.forEach((t=>{y=e*t.components;for(let e=0;e<t.components;++e)O[R++]=t.data[y++]})),null!==c){h=a.useTCoordsPerCell?n*p:e*p;for(let e=0;e<p;++e)O[R++]=c[h++]}null!==u&&(v=a.haveCellScalars?(T+a.cellOffset)*d:e*d,P[M++]=u[v++],P[M++]=u[v++],P[M++]=u[v++],P[M++]=4===d?u[v++]:255)};for(let e=0;e<I;e+=A[e]+1,T++)C(A[e],A,e+1,T+a.cellOffset);return t.elementCount=w,e.upload(O,Zu.ARRAY_BUFFER),t.colorBO&&(t.colorBOStride=4,t.colorBO.upload(P,Zu.ARRAY_BUFFER)),T},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&&Nn(e,t.coordShift)||(t.coordShift=e),null!==t.coordScale&&null!==n&&Nn(n,t.coordScale)||(t.coordScale=n),t.coordShiftAndScaleEnabled=function(e,t){return null!==e&&null!==t&&!(Bn(e,[0,0,0])&&Bn(t,[1,1,1]))}(t.coordShift,t.coordScale),t.coordShiftAndScaleEnabled?t.inverseShiftAndScaleMatrix=function(e,t){const n=new Float64Array(3);Rn(n,t);const r=new Float64Array(16);return _(r,ji(),e,n),r}(t.coordShift,t.coordScale):t.inverseShiftAndScaleMatrix=null):od("Wrong type for coordScale, expected vec3 or null"):od("Wrong type for coordShift, expected vec3 or null")}}const id={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 sd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,id,n),rd.extend(e,t,n),jt.setGet(e,t,["colorBO","elementCount","stride","colorBOStride","vertexOffset","normalOffset","tCoordOffset","tCoordComponents","colorOffset","colorComponents","customData"]),jt.get(e,t,["coordShift","coordScale","coordShiftAndScaleEnabled","inverseShiftAndScaleMatrix"]),ad(e,t)}var ld={newInstance:jt.newInstance(sd),extend:sd};const{vtkErrorMacro:cd}=jt;function ud(e,t){t.classHierarchy.push("vtkShader"),e.compile=()=>{let e=t.context.VERTEX_SHADER;if(!t.source||!t.source.length||"Unknown"===t.shaderType)return!1;if(0!==t.handle&&(t.context.deleteShader(t.handle),t.handle=0),e="Fragment"===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 cd(`Error compiling shader '${t.source}': ${e}`),t.context.deleteShader(t.handle),t.handle=0,!1}return!0},e.cleanup=()=>{"Unknown"!==t.shaderType&&0!==t.handle&&(t.context.deleteShader(t.handle),t.handle=0,t.dirty=!0)}}const dd={shaderType:"Unknown",source:"",error:"",handle:0,dirty:!1,context:null};function pd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,dd,n),jt.obj(e,t),jt.setGet(e,t,["shaderType","source","error","handle","context"]),ud(e,t)}var fd={newInstance:jt.newInstance(pd,"vtkShader"),extend:pd};const{vtkErrorMacro:gd}=jt;function md(e,t){t.classHierarchy.push("vtkShaderProgram"),e.compileShader=()=>t.vertexShader.compile()?t.fragmentShader.compile()?e.attachShader(t.vertexShader)&&e.attachShader(t.fragmentShader)?e.link()?(e.setCompiled(!0),1):(gd(`Links failed: ${t.error}`),0):(gd(t.error),0):(gd(t.fragmentShader.getSource().split("\n").map(((e,t)=>`${t}: ${e}`)).join("\n")),gd(t.fragmentShader.getError()),0):(gd(t.vertexShader.getSource().split("\n").map(((e,t)=>`${t}: ${e}`)).join("\n")),gd(t.vertexShader.getError()),0),e.cleanup=()=>{"Unknown"!==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="Program has not been initialized, and/or does not have shaders.",!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 gd(`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("Invalid number of values for array");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("Invalid number of values for array");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("Invalid number of values for array");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("Invalid number of values for array");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("Invalid number of values for array");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("Invalid number of values for array");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("Invalid number of values for array");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):(gd("attempt to find uniform when the shader program is not linked"),!1)},e.isAttributeUsed=e=>{if(!e)return!1;if(e in t.attributeLocs)return!0;if(!t.linked)return gd("attempt to find uniform when the shader program is not linked"),!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="Shader object was not initialized, cannot attach it.",!1;if("Unknown"===n.getShaderType())return t.error="Shader object is of type Unknown and cannot be used.",!1;if(0===t.handle){const e=t.context.createProgram();if(0===e)return t.error="Could not create shader program.",!1;t.handle=e,t.linked=!1}return"Vertex"===n.getShaderType()&&(0!==t.vertexShaderHandle&&t.context.detachShader(t.handle,t.vertexShaderHandle),t.vertexShaderHandle=n.getHandle()),"Fragment"===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="shader object was not initialized, cannot attach it.",!1;if("Unknown"===e.getShaderType())return t.error="Shader object is of type Unknown and cannot be used.",!1;switch(0===t.handle&&(t.error="This shader program has not been initialized yet."),e.getShaderType()){case"Vertex":return t.vertexShaderHandle!==e.getHandle()?(t.error="The supplied shader was not attached to this program.",!1):(t.context.detachShader(t.handle,e.getHandle()),t.vertexShaderHandle=0,t.linked=!1,!0);case"Fragment":return t.fragmentShaderHandle!==e.getHandle()?(t.error="The supplied shader was not attached to this program.",!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}}const hd={vertexShaderHandle:0,fragmentShaderHandle:0,geometryShaderHandle:0,vertexShader:null,fragmentShader:null,geometryShader:null,linked:!1,bound:!1,compiled:!1,error:"",handle:0,numberOfOutputs:0,attributesLocs:null,uniformLocs:null,md5Hash:0,context:null,lastCameraMTime:null};function vd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,hd,n),t.attributesLocs={},t.uniformLocs={},t.vertexShader=fd.newInstance(),t.vertexShader.setShaderType("Vertex"),t.fragmentShader=fd.newInstance(),t.fragmentShader.setShaderType("Fragment"),t.geometryShader=fd.newInstance(),t.geometryShader.setShaderType("Geometry"),jt.obj(e,t),jt.get(e,t,["lastCameraMTime"]),jt.setGet(e,t,["error","handle","compiled","bound","md5Hash","vertexShader","fragmentShader","geometryShader","linked"]),md(e,t)}var yd={newInstance:jt.newInstance(vd,"vtkShaderProgram"),extend:vd,substitute:function(e,t,n,r){const o="string"==typeof n?n:n.join("\n"),a=!1===r?t:new RegExp(t,"g"),i=e.replace(a,o);return{replace:i!==o,result:i}}};function Td(e,t){t.classHierarchy.push("vtkOpenGLVertexArrayObject"),e.exposedMethod=()=>{},e.initialize=()=>{t.instancingExtension=null,t._openGLRenderWindow.getWebgl2()||(t.instancingExtension=t.context.getExtension("ANGLE_instanced_arrays")),!t.forceEmulation&&t._openGLRenderWindow&&t._openGLRenderWindow.getWebgl2()?(t.extension=null,t.supported=!0,t.handleVAO=t.context.createVertexArray()):(t.extension=t.context.getExtension("OES_vertex_array_object"),!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()!==Zu.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()))}}const bd={forceEmulation:!1,handleVAO:0,handleProgram:0,supported:!0,buffers:null,context:null};function xd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,bd,n),t.buffers=[],jt.obj(e,t),jt.get(e,t,["supported"]),jt.setGet(e,t,["forceEmulation"]),Td(e,t)}var Cd={newInstance:jt.newInstance(xd,"vtkOpenGLVertexArrayObject"),extend:xd};const Sd={Start:0,Points:0,Lines:1,Tris:2,TriStrips:3,TrisEdges:4,TriStripsEdges:5,End:6};function Ad(e,t){t.classHierarchy.push("vtkOpenGLHelper"),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===ss.POINTS||n===Sd.Points?t.context.POINTS:e===ss.WIREFRAME||n===Sd.Lines||n===Sd.TrisEdges||n===Sd.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("viewportSize",o.usize,o.vsize);const t=parseFloat(r.getProperty().getLineWidth()),n=t/2;e.getProgram().setUniformf("lineWidthStepSize",t/Math.ceil(t)),e.getProgram().setUniformf("halfLineWidth",n)}t.primitiveType===Sd.Points||r.getProperty().getRepresentation()===ss.POINTS?e.getProgram().setUniformf("pointSize",r.getProperty().getPointSize()):t.pointPicking&&e.getProgram().setUniformf("pointSize",e.getPointPickingPrimitiveSize())},e.replaceShaderPositionVC=(n,r,o)=>{let a=n.Vertex;a=yd.substitute(a,"//VTK::PositionVC::Dec",["//VTK::PositionVC::Dec","uniform float pointSize;"]).result,a=yd.substitute(a,"//VTK::PositionVC::Impl",["//VTK::PositionVC::Impl","  gl_PointSize = pointSize;"],!1).result,e.getOpenGLMode(o.getProperty().getRepresentation())===t.context.LINES&&e.haveWideLines(r,o)&&(a=yd.substitute(a,"//VTK::PositionVC::Dec",["//VTK::PositionVC::Dec","uniform vec2 viewportSize;","uniform float lineWidthStepSize;","uniform float halfLineWidth;"]).result,a=yd.substitute(a,"//VTK::PositionVC::Impl",["//VTK::PositionVC::Impl"," if (halfLineWidth > 0.0)","   {","   float offset = float(gl_InstanceID / 2) * lineWidthStepSize - halfLineWidth;","   vec4 tmpPos = gl_Position;","   vec3 tmpPos2 = tmpPos.xyz / tmpPos.w;","   tmpPos2.x = tmpPos2.x + 2.0 * mod(float(gl_InstanceID), 2.0) * offset / viewportSize[0];","   tmpPos2.y = tmpPos2.y + 2.0 * mod(float(gl_InstanceID + 1), 2.0) * offset / viewportSize[1];","   gl_Position = vec4(tmpPos2.xyz * tmpPos.w, tmpPos.w);","   }"]).result),n.Vertex=a},e.getPointPickingPrimitiveSize=()=>t.primitiveType===Sd.Points?2:t.primitiveType===Sd.Lines?4:6,e.getAllocatedGPUMemoryInBytes=()=>e.getCABO().getAllocatedGPUMemoryInBytes()}const Id={context:null,program:null,shaderSourceTime:null,VAO:null,attributeUpdateTime:null,CABO:null,primitiveType:0,pointPicking:!1};function wd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Id,n),jt.obj(e,t),t.shaderSourceTime={},jt.obj(t.shaderSourceTime),t.attributeUpdateTime={},jt.obj(t.attributeUpdateTime),jt.setGet(e,t,["program","shaderSourceTime","VAO","attributeUpdateTime","CABO","primitiveType","pointPicking"]),t.program=yd.newInstance(),t.VAO=Cd.newInstance(),t.CABO=ld.newInstance(),Ad(e,t)}var Pd={newInstance:jt.newInstance(wd),extend:wd,primTypes:Sd};const Od={CLAMP_TO_EDGE:0,REPEAT:1,MIRRORED_REPEAT:2},Rd={NEAREST:0,LINEAR:1,NEAREST_MIPMAP_NEAREST:2,NEAREST_MIPMAP_LINEAR:3,LINEAR_MIPMAP_NEAREST:4,LINEAR_MIPMAP_LINEAR:5};var Md={Wrap:Od,Filter:Rd};const Ed=new Float32Array(1),Dd=new Int32Array(Ed.buffer);var Vd={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){Ed[0]=e;const t=Dd[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 Ld;const{Wrap:Bd,Filter:Nd}=Md,{VtkDataTypes:_d}=Ns,{vtkDebugMacro:Fd,vtkErrorMacro:kd,vtkWarningMacro:Gd}=Kt,{toHalf:Ud}=Vd;function zd(e,t){t.classHierarchy.push("vtkOpenGLTexture"),e.render=function(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:null;if(n?t._openGLRenderWindow=n:(t._openGLRenderer=e.getFirstAncestorOfType("vtkOpenGLRenderer"),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType("vtkOpenGLRenderWindow")),t.context=t._openGLRenderWindow.getContext(),t.renderable.getInterpolate()?(t.generateMipmap?e.setMinificationFilter(Nd.LINEAR_MIPMAP_LINEAR):e.setMinificationFilter(Nd.LINEAR),e.setMagnificationFilter(Nd.LINEAR)):(e.setMinificationFilter(Nd.NEAREST),e.setMagnificationFilter(Nd.NEAREST)),t.renderable.getRepeat()&&(e.setWrapR(Bd.REPEAT),e.setWrapS(Bd.REPEAT),e.setWrapT(Bd.REPEAT)),t.renderable.getInputData()&&t.renderable.setImage(null),!t.handle||t.renderable.getMTime()>t.textureBuildTime.getMTime()){if(null!==t.renderable.getImage()&&(t.renderable.getInterpolate()&&(t.generateMipmap=!0,e.setMinificationFilter(Nd.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(Nd.LINEAR_MIPMAP_LINEAR));const n=t.renderable.getCanvas();e.create2DFromRaw(n.width,n.height,4,_d.UNSIGNED_CHAR,n,!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(Nd.LINEAR_MIPMAP_LINEAR)),e.create2DFromRaw(n.width,n.height,4,_d.UNSIGNED_CHAR,n.data,!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(Nd.LINEAR_MIPMAP_LINEAR)),a.length%6==0?e.createCubeFromRaw(r[1]-r[0]+1,r[3]-r[2]+1,o.getNumberOfComponents(),o.getDataType(),a):e.create2DFromRaw(r[1]-r[0]+1,r[3]-r[2]+1,o.getNumberOfComponents(),o.getDataType(),o.getData()),e.activate(),e.sendParameters(),t.textureBuildTime.modified()}}t.handle&&e.activate()};const n=()=>{if(t.minificationFilter!==Nd.LINEAR&&t.magnificationFilter!==Nd.LINEAR||(void 0===Ld&&(Ld=function(){try{const e=4,t=2,n=1,r=new Int16Array([0,32767]),o=[1,1],a=document.createElement("canvas");a.width=e,a.height=e;const i=a.getContext("webgl2");if(!i)return!1;const s=i.getExtension("EXT_texture_norm16");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="#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    ",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,y=i.getExtension("WEBGL_lose_context");return y&&y.loseContext(),m===h&&h===v&&0!==m}catch(e){return!1}}()),Ld))return t.oglNorm16Ext};function r(e){if(t._openGLRenderWindow.getWebgl2())return e;const n=[],r=t.width,o=t.height,a=t.components;if(e&&(!Fo(r)||!Fo(o))){const i=t.context.getExtension("OES_texture_half_float"),s=_o(r),l=_o(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?Vd.toHalf(Vd.fromHalf(e[u][l+s+t])*h*(1-v)+Vd.fromHalf(e[u][l+p+t])*h*v+Vd.fromHalf(e[u][c+s+t])*m*(1-v)+Vd.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 o(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)&&n())||e!==_d.UNSIGNED_SHORT&&e!==_d.SHORT)))}function a(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("OES_texture_float_linear")&&i||t.openGLDataType===t.context.HALF_FLOAT;else{const e=t.context.getExtension("OES_texture_half_float");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.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.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:Gd("impossible case"),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||Fd(`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("OES_texture_float_linear")&&Gd("Failed to load OES_texture_float_linear. Texture filtering is not available for *32F internal formats."),t.internalFormat),e.getDefaultInternalFormat=(r,o)=>{let a=0;return a=t._openGLRenderWindow.getDefaultTextureInternalFormat(r,o,n(),e.useHalfFloat()),a||(a||(Fd("Unsupported internal texture type!"),Fd(`Unable to find suitable internal format for T=${r} 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.format=0,t.internalFormat=0,t._forceInternalFormat=!1,t.openGLDataType=0},e.getDefaultDataType=r=>{const o=e.useHalfFloat();if(t._openGLRenderWindow.getWebgl2())switch(r){case _d.UNSIGNED_CHAR:return t.context.UNSIGNED_BYTE;case n()&&!o&&_d.SHORT:return t.context.SHORT;case n()&&!o&&_d.UNSIGNED_SHORT:return t.context.UNSIGNED_SHORT;case o&&_d.SHORT:case o&&_d.UNSIGNED_SHORT:return t.context.HALF_FLOAT;case _d.FLOAT:case _d.VOID:default:return t.context.FLOAT}switch(r){case _d.UNSIGNED_CHAR:return t.context.UNSIGNED_BYTE;case _d.FLOAT:case _d.VOID:default:if(t.context.getExtension("OES_texture_float")&&t.context.getExtension("OES_texture_float_linear"))return t.context.FLOAT;{const e=t.context.getExtension("OES_texture_half_float");if(e&&t.context.getExtension("OES_texture_half_float_linear"))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 Nd.NEAREST:return t.context.NEAREST;case Nd.LINEAR:return t.context.LINEAR;case Nd.NEAREST_MIPMAP_NEAREST:return t.context.NEAREST_MIPMAP_NEAREST;case Nd.NEAREST_MIPMAP_LINEAR:return t.context.NEAREST_MIPMAP_LINEAR;case Nd.LINEAR_MIPMAP_NEAREST:return t.context.LINEAR_MIPMAP_NEAREST;case Nd.LINEAR_MIPMAP_LINEAR:return t.context.LINEAR_MIPMAP_LINEAR;default:return t.context.NEAREST}},e.getOpenGLWrapMode=e=>{switch(e){case Bd.CLAMP_TO_EDGE:return t.context.CLAMP_TO_EDGE;case Bd.REPEAT:return t.context.REPEAT;case Bd.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];const o=[];let a=t.width*t.height*t.components;if(r&&(a*=t.depth),e!==_d.FLOAT&&t.openGLDataType===t.context.FLOAT)for(let e=0;e<n.length;e++)if(n[e]){const t=n[e].length>a?n[e].subarray(0,a):n[e];o.push(new Float32Array(t))}else o.push(null);if(e!==_d.UNSIGNED_CHAR&&t.openGLDataType===t.context.UNSIGNED_BYTE)for(let e=0;e<n.length;e++)if(n[e]){const t=n[e].length>a?n[e].subarray(0,a):n[e];o.push(new Uint8Array(t))}else o.push(null);let i=!1;if(t._openGLRenderWindow.getWebgl2())i=t.openGLDataType===t.context.HALF_FLOAT;else{const e=t.context.getExtension("OES_texture_half_float");i=e&&t.openGLDataType===e.HALF_FLOAT_OES}if(i)for(let e=0;e<n.length;e++)if(n[e]){const t=new Uint16Array(a),r=n[e];for(let e=0;e<a;e++)t[e]=Ud(r[e]);o.push(t)}else o.push(null);if(0===o.length)for(let e=0;e<n.length;e++)o.push(n[e]);return o},e.create2DFromRaw=function(a,i,s,l,c){let u=arguments.length>5&&void 0!==arguments[5]&&arguments[5];if(e.getOpenGLDataType(l,!0),e.getInternalFormat(l,s),e.getFormat(l,s),!t.internalFormat||!t.format||!t.openGLDataType)return kd("Failed to determine texture parameters."),!1;t.target=t.context.TEXTURE_2D,t.components=s,t.width=a,t.height=i,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind();const d=[c],p=e.updateArrayDataTypeForGL(l,d),f=r(p);return t.context.pixelStorei(t.context.UNPACK_FLIP_Y_WEBGL,u),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),o(l)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),null!=f[0]&&t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,f[0])):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,f[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*s*t._openGLRenderWindow.getDefaultTextureByteSize(l,n(),e.useHalfFloat()),e.deactivate(),!0},e.createCubeFromRaw=(a,i,s,l,c)=>{if(e.getOpenGLDataType(l),e.getInternalFormat(l,s),e.getFormat(l,s),!t.internalFormat||!t.format||!t.openGLDataType)return kd("Failed to determine texture parameters."),!1;t.target=t.context.TEXTURE_CUBE_MAP,t.components=s,t.width=a,t.height=i,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),t.maxLevel=c.length/6-1,e.createTexture(),e.bind();const u=r(e.updateArrayDataTypeForGL(l,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(l,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),o(l)&&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,a=t.height;for(;r>=1&&a>=1;){let i=null;n<=t.maxLevel&&(i=d[6*n+e]),o(l)?null!=i&&t.context.texSubImage2D(t.context.TEXTURE_CUBE_MAP_POSITIVE_X+e,n,0,0,r,a,t.format,t.openGLDataType,i):t.context.texImage2D(t.context.TEXTURE_CUBE_MAP_POSITIVE_X+e,n,t.internalFormat,r,a,0,t.format,t.openGLDataType,i),n++,r/=2,a/=2}}return t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*s*t._openGLRenderWindow.getDefaultTextureByteSize(l,n(),e.useHalfFloat()),e.deactivate(),!0},e.createDepthFromRaw=(r,a,i,s)=>(e.getOpenGLDataType(i),t.format=t.context.DEPTH_COMPONENT,t._openGLRenderWindow.getWebgl2()?i===_d.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=r,t.height=a,t.depth=1,t.numberOfDimensions=2,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind(),t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),o(i)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),null!=s&&t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,s)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,s),t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(i,n(),e.useHalfFloat()),e.deactivate(),!0):(kd("Failed to determine texture parameters."),!1)),e.create2DFromImage=r=>{if(e.getOpenGLDataType(_d.UNSIGNED_CHAR),e.getInternalFormat(_d.UNSIGNED_CHAR,4),e.getFormat(_d.UNSIGNED_CHAR,4),!t.internalFormat||!t.format||!t.openGLDataType)return kd("Failed to determine texture parameters."),!1;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);const a=!(t._openGLRenderWindow.getWebgl2()||Fo(r.width)&&Fo(r.height)),i=document.createElement("canvas");i.width=a?_o(r.width):r.width,i.height=a?_o(r.height):r.height,t.width=i.width,t.height=i.height;const s=i.getContext("2d");s.translate(0,i.height),s.scale(1,-1),s.drawImage(r,0,0,r.width,r.height,0,0,i.width,i.height);const l=i;return o(_d.UNSIGNED_CHAR)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),null!=l&&t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,l)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,l),t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(_d.UNSIGNED_CHAR,n(),e.useHalfFloat()),e.deactivate(),!0},e.create2DFilterableFromRaw=function(t,n,r,o,a){let i=arguments.length>5&&void 0!==arguments[5]&&arguments[5];return e.create2DFilterableFromDataArray(t,n,Ns.newInstance({numberOfComponents:r,dataType:o,values:a}),i)},e.create2DFilterableFromDataArray=function(t,n,r){let o=arguments.length>3&&void 0!==arguments[3]&&arguments[3];const{numComps:i,dataType:s,data:l}=a(r,o);e.create2DFromRaw(t,n,i,s,l)},e.updateVolumeInfoForGL=(r,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(n()&&!i&&r===_d.SHORT){for(let e=0;e<o;++e)t.volumeInfo.scale[e]=32767;a=!0}if(n()&&!i&&r===_d.UNSIGNED_SHORT){for(let e=0;e<o;++e)t.volumeInfo.scale[e]=65535;a=!0}if(r===_d.UNSIGNED_CHAR){for(let e=0;e<o;++e)t.volumeInfo.scale[e]=255;a=!0}return(r===_d.FLOAT||i&&(r===_d.SHORT||r===_d.UNSIGNED_SHORT))&&(a=!0),a},e.create3DFromRaw=(a,i,s,l,c,u)=>{let d=c,p=u;if(!e.updateVolumeInfoForGL(d,l)&&p){const e=a*i*s,n=structuredClone(t.volumeInfo),r=new Float32Array(e*l);t.volumeInfo.offset=n.offset,t.volumeInfo.scale=n.scale;let o=0;const c=n.scale.map((e=>1/e));for(let t=0;t<e;t++)for(let e=0;e<l;e++)r[o]=(p[o]-n.offset[e])*c[e],o++;d=_d.FLOAT,p=r}if(e.getOpenGLDataType(d),e.getInternalFormat(d,l),e.getFormat(d,l),!t.internalFormat||!t.format||!t.openGLDataType)return kd("Failed to determine texture parameters."),!1;t.target=t.context.TEXTURE_3D,t.components=l,t.width=a,t.height=i,t.depth=s,t.numberOfDimensions=3,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind();const f=[p],g=r(e.updateArrayDataTypeForGL(d,f,!0));return t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),o(d)?(t.context.texStorage3D(t.target,1,t.internalFormat,t.width,t.height,t.depth),null!=g[0]&&t.context.texSubImage3D(t.target,0,0,0,0,t.width,t.height,t.depth,t.format,t.openGLDataType,g[0])):t.context.texImage3D(t.target,0,t.internalFormat,t.width,t.height,t.depth,0,t.format,t.openGLDataType,g[0]),t.generateMipmap&&t.context.generateMipmap(t.target),t.allocatedGPUMemoryInBytes=t.width*t.height*t.depth*t.components*t._openGLRenderWindow.getDefaultTextureByteSize(d,n(),e.useHalfFloat()),e.deactivate(),!0},e.create3DFilterableFromRaw=function(t,n,r,o,a,i){let s=arguments.length>6&&void 0!==arguments[6]&&arguments[6];return e.create3DFilterableFromDataArray(t,n,r,Ns.newInstance({numberOfComponents:o,dataType:a,values:i}),s)},e.create3DFilterableFromDataArray=function(n,r,i,s){let l=arguments.length>4&&void 0!==arguments[4]&&arguments[4];const{numComps:c,dataType:u,data:d,scaleOffsets:p}=a(s,l),f=[],g=[];for(let e=0;e<c;++e)f[e]=0,g[e]=1;if(t.volumeInfo={scale:g,offset:f,dataComputedScale:p.scale,dataComputedOffset:p.offset,width:n,height:r,depth:i},t._openGLRenderWindow.getWebgl2())return e.create3DFromRaw(n,r,i,c,u,d);const m=n*r*i,h=structuredClone(p);let v=(e,t,n,r,o)=>{e[t]=n},y=_d.UNSIGNED_CHAR;if(u===_d.UNSIGNED_CHAR)for(let e=0;e<c;++e)h.offset[e]=0,h.scale[e]=255;else t.context.getExtension("OES_texture_float")&&t.context.getExtension("OES_texture_float_linear")?(y=_d.FLOAT,v=(e,t,n,r,o)=>{e[t]=(n-r)/o}):(y=_d.UNSIGNED_CHAR,v=(e,t,n,r,o)=>{e[t]=255*(n-r)/o});if(e.getOpenGLDataType(y),e.getInternalFormat(y,c),e.getFormat(y,c),!t.internalFormat||!t.format||!t.openGLDataType)return kd("Failed to determine texture parameters."),!1;t.target=t.context.TEXTURE_2D,t.components=c,t.depth=1,t.numberOfDimensions=2;let T=t.context.getParameter(t.context.MAX_TEXTURE_SIZE);T>4096&&(y===_d.FLOAT||c>=3)&&(T=4096);let b=1,x=1;m>T*T&&(b=Math.ceil(Math.sqrt(m/(T*T))),x=b);let C=Math.sqrt(m)/b;C=_o(C);const S=Math.floor(C*b/n),A=Math.ceil(i/S),I=_o(r*A/x);let w;t.width=C,t.height=I,t._openGLRenderWindow.activateTexture(e),e.createTexture(),e.bind(),t.volumeInfo.xreps=S,t.volumeInfo.yreps=A,t.volumeInfo.xstride=b,t.volumeInfo.ystride=x,t.volumeInfo.offset=h.offset,t.volumeInfo.scale=h.scale;const P=C*I*c;w=y===_d.FLOAT?new Float32Array(P):new Uint8Array(P);let O=0;const R=Math.floor(n/b),M=Math.floor(r/x);for(let e=0;e<A;e++){const o=Math.min(S,i-e*S),a=c*(t.width-o*Math.floor(n/b));for(let t=0;t<M;t++){for(let a=0;a<o;a++){const o=c*((e*S+a)*n*r+x*t*n);for(let e=0;e<R;e++)for(let t=0;t<c;t++)v(w,O,d[o+b*e*c+t],h.offset[t],h.scale[t]),O++}O+=a}}return t.context.pixelStorei(t.context.UNPACK_ALIGNMENT,1),o(y)?(t.context.texStorage2D(t.target,1,t.internalFormat,t.width,t.height),null!=w&&t.context.texSubImage2D(t.target,0,0,0,t.width,t.height,t.format,t.openGLDataType,w)):t.context.texImage2D(t.target,0,t.internalFormat,t.width,t.height,0,t.format,t.openGLDataType,w),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 Wd={_openGLRenderWindow:null,_forceInternalFormat:!1,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:Bd.CLAMP_TO_EDGE,wrapT:Bd.CLAMP_TO_EDGE,wrapR:Bd.CLAMP_TO_EDGE,minificationFilter:Nd.NEAREST,magnificationFilter:Nd.NEAREST,minLOD:-1e3,maxLOD:1e3,baseLevel:0,maxLevel:1e3,generateMipmap:!1,oglNorm16Ext:null,allocatedGPUMemoryInBytes:0,enableUseHalfFloat:!0,canUseHalfFloat:!1};function Hd(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};Object.assign(t,Wd,n),Zt.extend(e,t,n),t.sendParametersTime={},yt(t.sendParametersTime,{mtime:0}),t.textureBuildTime={},yt(t.textureBuildTime,{mtime:0}),St(e,t,["format","openGLDataType"]),At(e,t,["keyMatrixTime","minificationFilter","magnificationFilter","wrapS","wrapT","wrapR","generateMipmap","oglNorm16Ext"]),bt(e,t,["width","height","volumeInfo","components","handle","target","allocatedGPUMemoryInBytes"]),Ot(0,t,["openGLRenderWindow"]),zd(e,t)}const jd=Dt(Hd,"vtkOpenGLTexture");var Kd={newInstance:jd,extend:Hd,...Md};rn("vtkTexture",jd);var $d="//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",qd="//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",Xd=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=yd.substitute(e,"//VTK::Coincident::Dec",["uniform float cfactor;","uniform float coffset;"]).result,t.context.getExtension("EXT_frag_depth")&&(0!==a.factor?(e=yd.substitute(e,"//VTK::UniformFlow::Impl",["float cscale = length(vec2(dFdx(gl_FragCoord.z),dFdy(gl_FragCoord.z)));","//VTK::UniformFlow::Impl"],!1).result,e=yd.substitute(e,"//VTK::Depth::Impl","gl_FragDepthEXT = gl_FragCoord.z + cfactor*cscale + 0.000016*coffset;").result):e=yd.substitute(e,"//VTK::Depth::Impl","gl_FragDepthEXT = gl_FragCoord.z + 0.000016*coffset;").result),t._openGLRenderWindow.getWebgl2()&&(0!==a.factor?(e=yd.substitute(e,"//VTK::UniformFlow::Impl",["float cscale = length(vec2(dFdx(gl_FragCoord.z),dFdy(gl_FragCoord.z)));","//VTK::UniformFlow::Impl"],!1).result,e=yd.substitute(e,"//VTK::Depth::Impl","gl_FragDepth = gl_FragCoord.z + cfactor*cscale + 0.000016*coffset;").result):e=yd.substitute(e,"//VTK::Depth::Impl","gl_FragDepth = gl_FragCoord.z + 0.000016*coffset;").result),n.Fragment=e}}},Yd=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=yd.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&&""!==e&&(i=e)}n.Vertex=i;let s=n.Fragment;if(a){const e=a.FragmentShaderCode;void 0!==e&&""!==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:Zd}=ll,{primTypes:Qd}=Pd,{Representation:Jd,Shading:ep}=ms,{ScalarMode:tp}=uc,{Filter:np,Wrap:rp}=Kd,{vtkErrorMacro:op}=Kt,ap={type:"StartEvent"},ip={type:"EndEvent"},{CoordinateSystem:sp}=ts;function lp(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("vtkOpenGLPolyDataMapper"),e.buildPass=n=>{n&&(t.currentRenderPass=null,t.openGLActor=e.getFirstAncestorOfType("vtkOpenGLActor"),t._openGLRenderer=t.openGLActor.getFirstAncestorOfType("vtkOpenGLRenderer"),t._openGLRenderWindow=t._openGLRenderer.getLastAncestorOfType("vtkOpenGLRenderWindow"),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=Qd.Start;e<Qd.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=$d,e.Fragment=qd,e.Geometry=""},e.replaceShaderColor=(e,n,r)=>{let o=e.Vertex,a=e.Geometry,i=e.Fragment;const s=t.lastBoundBO.getReferenceByName("lastLightComplexity");let l=["uniform float ambient;","uniform float diffuse;","uniform float specular;","uniform float opacityUniform; // the fragment opacity","uniform vec3 ambientColorUniform;","uniform vec3 diffuseColorUniform;"];s&&(l=l.concat(["uniform vec3 specularColorUniform;","uniform float specularPowerUniform;"]));let c=["vec3 ambientColor;","  vec3 diffuseColor;","  float opacity;"];s&&(c=c.concat(["  vec3 specularColor;","  float specularPower;"])),c=c.concat(["  ambientColor = ambientColorUniform;","  diffuseColor = diffuseColorUniform;","  opacity = opacityUniform;"]),s&&(c=c.concat(["  specularColor = specularColorUniform;","  specularPower = specularPowerUniform;"])),0===t.lastBoundBO.getCABO().getColorComponents()||t.drawingEdges||(l=l.concat(["varying vec4 vertexColorVSOutput;"]),o=yd.substitute(o,"//VTK::Color::Dec",["attribute vec4 scalarColor;","varying vec4 vertexColorVSOutput;"]).result,o=yd.substitute(o,"//VTK::Color::Impl",["vertexColorVSOutput =  scalarColor;"]).result,a=yd.substitute(a,"//VTK::Color::Dec",["in vec4 vertexColorVSOutput[];","out vec4 vertexColorGSOutput;"]).result,a=yd.substitute(a,"//VTK::Color::Impl",["vertexColorGSOutput = vertexColorVSOutput[i];"]).result),0===t.lastBoundBO.getCABO().getColorComponents()||t.drawingEdges?(t.renderable.getAreScalarsMappedFromCells()||t.renderable.getInterpolateScalarsBeforeMapping())&&t.renderable.getColorCoordinates()&&!t.drawingEdges?i=yd.substitute(i,"//VTK::Color::Impl",c.concat(["  vec4 texColor = texture2D(texture1, tcoordVCVSOutput.st);","  diffuseColor = texColor.rgb;","  ambientColor = texColor.rgb;","  opacity = opacity*texColor.a;"])).result:(r.getBackfaceProperty()&&!t.drawingEdges&&(l=l.concat(["uniform float opacityUniformBF; // the fragment opacity","uniform float ambientIntensityBF; // the material ambient","uniform float diffuseIntensityBF; // the material diffuse","uniform vec3 ambientColorUniformBF; // ambient material color","uniform vec3 diffuseColorUniformBF; // diffuse material color"]),s?(l=l.concat(["uniform float specularIntensityBF; // the material specular intensity","uniform vec3 specularColorUniformBF; // intensity weighted color","uniform float specularPowerUniformBF;"]),c=c.concat(["if (gl_FrontFacing == false) {","  ambientColor = ambientIntensityBF * ambientColorUniformBF;","  diffuseColor = diffuseIntensityBF * diffuseColorUniformBF;","  specularColor = specularIntensityBF * specularColorUniformBF;","  specularPower = specularPowerUniformBF;","  opacity = opacityUniformBF; }"])):c=c.concat(["if (gl_FrontFacing == false) {","  ambientColor = ambientIntensityBF * ambientColorUniformBF;","  diffuseColor = diffuseIntensityBF * diffuseColorUniformBF;","  opacity = opacityUniformBF; }"])),t.haveCellScalars&&!t.drawingEdges&&(l=l.concat(["uniform samplerBuffer texture1;"])),i=yd.substitute(i,"//VTK::Color::Impl",c).result):i=yd.substitute(i,"//VTK::Color::Impl",c.concat(["  diffuseColor = vertexColorVSOutput.rgb;","  ambientColor = vertexColorVSOutput.rgb;","  opacity = opacity*vertexColorVSOutput.a;"])).result,i=yd.substitute(i,"//VTK::Color::Dec",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("lastLightComplexity"),i=t.lastBoundBO.getReferenceByName("lastLightCount");let s=[];switch(a){case 0:o=yd.substitute(o,"//VTK::Light::Impl",["  gl_FragData[0] = vec4(ambientColor * ambient + diffuseColor * diffuse, opacity);","  //VTK::Light::Impl"],!1).result;break;case 1:o=yd.substitute(o,"//VTK::Light::Impl",["  float df = max(0.0, normalVCVSOutput.z);","  float sf = pow(df, specularPower);","  vec3 diffuseL = df * diffuseColor;","  vec3 specularL = sf * specularColor;","  gl_FragData[0] = vec4(ambientColor * ambient + diffuseL * diffuse + specularL * specular, opacity);","  //VTK::Light::Impl"],!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=yd.substitute(o,"//VTK::Light::Dec",s).result,s=["vec3 diffuseL = vec3(0,0,0);","  vec3 specularL = vec3(0,0,0);","  float df;"];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)`,"    {",`    float sf = sign(df)*pow(max(1e-5,\n                                              dot(reflect(lightDirectionVC${e},normalVCVSOutput),\n                                                  normalize(-vertexVC.xyz))),\n                                         specularPower);`,`    specularL += (sf * lightColor${e});`,"    }"]);s=s.concat(["  diffuseL = diffuseL * diffuseColor;","  specularL = specularL * specularColor;","  gl_FragData[0] = vec4(ambientColor * ambient + diffuseL * diffuse + specularL * specular, opacity);","  //VTK::Light::Impl"]),o=yd.substitute(o,"//VTK::Light::Impl",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=yd.substitute(o,"//VTK::Light::Dec",s).result,s=["vec3 diffuseL = vec3(0,0,0);","  vec3 specularL = vec3(0,0,0);","  vec3 vertLightDirectionVC;","  float attenuation;","  float df;"];for(let e=0;e<i;++e)s=s.concat(["  attenuation = 1.0;",`  if (lightPositional${e} == 0)`,"    {",`      vertLightDirectionVC = lightDirectionVC${e};`,"    }","  else","    {",`    vertLightDirectionVC = vertexVC.xyz - lightPositionVC${e};`,"    float distanceVC = length(vertLightDirectionVC);","    vertLightDirectionVC = normalize(vertLightDirectionVC);","    attenuation = 1.0 /",`      (lightAttenuation${e}.x`,`       + lightAttenuation${e}.y * distanceVC`,`       + lightAttenuation${e}.z * distanceVC * distanceVC);`,"    // per OpenGL standard cone angle is 90 or less for a spot light",`    if (lightConeAngle${e} <= 90.0)`,"      {",`      float coneDot = dot(vertLightDirectionVC, lightDirectionVC${e});`,"      // if inside the cone",`      if (coneDot >= cos(radians(lightConeAngle${e})))`,"        {",`        attenuation = attenuation * pow(coneDot, lightExponent${e});`,"        }","      else","        {","        attenuation = 0.0;","        }","      }","    }","    df = max(0.0, attenuation*dot(normalVCVSOutput, -vertLightDirectionVC));",`    diffuseL += ((df) * lightColor${e});`,"    if (dot(normalVCVSOutput, vertLightDirectionVC) < 0.0)","      {",`      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});`,"    }"]);s=s.concat(["  diffuseL = diffuseL * diffuseColor;","  specularL = specularL * specularColor;","  gl_FragData[0] = vec4(ambientColor * ambient + diffuseL * diffuse + specularL * specular, opacity);","  //VTK::Light::Impl"]),o=yd.substitute(o,"//VTK::Light::Impl",s,!1).result;break;default:op("bad light complexity")}e.Fragment=o},e.replaceShaderNormal=(e,n,r)=>{if(t.lastBoundBO.getReferenceByName("lastLightComplexity")>0){let n=e.Vertex,o=e.Geometry,a=e.Fragment;t.lastBoundBO.getCABO().getNormalOffset()?(n=yd.substitute(n,"//VTK::Normal::Dec",["attribute vec3 normalMC;","uniform mat3 normalMatrix;","varying vec3 normalVCVSOutput;"]).result,n=yd.substitute(n,"//VTK::Normal::Impl",["normalVCVSOutput = normalMatrix * normalMC;"]).result,o=yd.substitute(o,"//VTK::Normal::Dec",["in vec3 normalVCVSOutput[];","out vec3 normalVCGSOutput;"]).result,o=yd.substitute(o,"//VTK::Normal::Impl",["normalVCGSOutput = normalVCVSOutput[i];"]).result,a=yd.substitute(a,"//VTK::Normal::Dec",["varying vec3 normalVCVSOutput;"]).result,a=yd.substitute(a,"//VTK::Normal::Impl",["vec3 normalVCVSOutput = normalize(normalVCVSOutput);","  if (gl_FrontFacing == false) { normalVCVSOutput = -normalVCVSOutput; }"]).result):t.haveCellNormals?(a=yd.substitute(a,"//VTK::Normal::Dec",["uniform mat3 normalMatrix;","uniform samplerBuffer textureN;"]).result,a=yd.substitute(a,"//VTK::Normal::Impl",["vec3 normalVCVSOutput = normalize(normalMatrix *","    texelFetchBuffer(textureN, gl_PrimitiveID + PrimitiveIDOffset).xyz);","  if (gl_FrontFacing == false) { normalVCVSOutput = -normalVCVSOutput; }"]).result):t.lastBoundBO.getOpenGLMode(r.getProperty().getRepresentation())===t.context.LINES?(a=yd.substitute(a,"//VTK::UniformFlow::Impl",["  vec3 fdx = dFdx(vertexVC.xyz);","  vec3 fdy = dFdy(vertexVC.xyz);","  //VTK::UniformFlow::Impl"]).result,a=yd.substitute(a,"//VTK::Normal::Impl",["vec3 normalVCVSOutput;","  if (abs(fdx.x) > 0.0)","    { fdx = normalize(fdx); normalVCVSOutput = normalize(cross(vec3(fdx.y, -fdx.x, 0.0), fdx)); }","  else { fdy = normalize(fdy); normalVCVSOutput = normalize(cross(vec3(fdy.y, -fdy.x, 0.0), fdy));}"]).result):(a=yd.substitute(a,"//VTK::Normal::Dec",["uniform int cameraParallel;"]).result,a=yd.substitute(a,"//VTK::UniformFlow::Impl",["  vec3 fdx = dFdx(vertexVC.xyz);","  vec3 fdy = dFdy(vertexVC.xyz);","  //VTK::UniformFlow::Impl"]).result,a=yd.substitute(a,"//VTK::Normal::Impl",["  fdx = normalize(fdx);","  fdy = normalize(fdy);","  vec3 normalVCVSOutput = normalize(cross(fdx,fdy));","  if (cameraParallel == 1 && normalVCVSOutput.z < 0.0) { normalVCVSOutput = -1.0*normalVCVSOutput; }","  if (cameraParallel == 0 && dot(normalVCVSOutput,vertexVC.xyz) > 0.0) { normalVCVSOutput = -1.0*normalVCVSOutput; }"]).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("lastLightComplexity")>0?(o=yd.substitute(o,"//VTK::PositionVC::Dec",["varying vec4 vertexVCVSOutput;"]).result,o=yd.substitute(o,"//VTK::PositionVC::Impl",["vertexVCVSOutput = MCVCMatrix * vertexMC;","  gl_Position = MCPCMatrix * vertexMC;"]).result,o=yd.substitute(o,"//VTK::Camera::Dec",["uniform mat4 MCPCMatrix;","uniform mat4 MCVCMatrix;"]).result,a=yd.substitute(a,"//VTK::PositionVC::Dec",["in vec4 vertexVCVSOutput[];","out vec4 vertexVCGSOutput;"]).result,a=yd.substitute(a,"//VTK::PositionVC::Impl",["vertexVCGSOutput = vertexVCVSOutput[i];"]).result,i=yd.substitute(i,"//VTK::PositionVC::Dec",["varying vec4 vertexVCVSOutput;"]).result,i=yd.substitute(i,"//VTK::PositionVC::Impl",["vec4 vertexVC = vertexVCVSOutput;"]).result):(o=yd.substitute(o,"//VTK::Camera::Dec",["uniform mat4 MCPCMatrix;"]).result,o=yd.substitute(o,"//VTK::PositionVC::Impl",["  gl_Position = MCPCMatrix * vertexMC;"]).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=yd.substitute(n,"//VTK::TCoord::Impl","tcoordVCVSOutput = tcoordMC;").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=yd.substitute(n,"//VTK::TCoord::Dec","attribute vec2 tcoordMC; varying vec2 tcoordVCVSOutput;").result,r=yd.substitute(r,"//VTK::TCoord::Dec",["in vec2 tcoordVCVSOutput[];","out vec2 tcoordVCGSOutput;"]).result,r=yd.substitute(r,"//VTK::TCoord::Impl","tcoordVCGSOutput = tcoordVCVSOutput[i];").result,o=yd.substitute(o,"//VTK::TCoord::Dec",["varying vec2 tcoordVCVSOutput;","uniform sampler2D texture1;"]).result,a&&a.length>=1)switch(i){case 1:o=yd.substitute(o,"//VTK::TCoord::Impl",["  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);","  ambientColor = ambientColor*tcolor.r;","  diffuseColor = diffuseColor*tcolor.r;"]).result;break;case 2:o=yd.substitute(o,"//VTK::TCoord::Impl",["  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);","  ambientColor = ambientColor*tcolor.r;","  diffuseColor = diffuseColor*tcolor.r;","  opacity = opacity * tcolor.g;"]).result;break;default:o=yd.substitute(o,"//VTK::TCoord::Impl",["  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);","  ambientColor = ambientColor*tcolor.rgb;","  diffuseColor = diffuseColor*tcolor.rgb;","  opacity = opacity * tcolor.a;"]).result}}else switch(n=yd.substitute(n,"//VTK::TCoord::Dec","attribute vec3 tcoordMC; varying vec3 tcoordVCVSOutput;").result,r=yd.substitute(r,"//VTK::TCoord::Dec",["in vec3 tcoordVCVSOutput[];","out vec3 tcoordVCGSOutput;"]).result,r=yd.substitute(r,"//VTK::TCoord::Impl","tcoordVCGSOutput = tcoordVCVSOutput[i];").result,o=yd.substitute(o,"//VTK::TCoord::Dec",["varying vec3 tcoordVCVSOutput;","uniform samplerCube texture1;"]).result,i){case 1:o=yd.substitute(o,"//VTK::TCoord::Impl",["  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);","  ambientColor = ambientColor*tcolor.r;","  diffuseColor = diffuseColor*tcolor.r;"]).result;break;case 2:o=yd.substitute(o,"//VTK::TCoord::Impl",["  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);","  ambientColor = ambientColor*tcolor.r;","  diffuseColor = diffuseColor*tcolor.r;","  opacity = opacity * tcolor.g;"]).result;break;default:o=yd.substitute(o,"//VTK::TCoord::Impl",["  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);","  ambientColor = ambientColor*tcolor.rgb;","  diffuseColor = diffuseColor*tcolor.rgb;","  opacity = opacity * tcolor.a;"]).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=yd.substitute(o,"//VTK::Clip::Dec",["uniform int numClipPlanes;",`uniform vec4 clipPlanes[${e}];`,`varying float clipDistancesVSOutput[${e}];`]).result,o=yd.substitute(o,"//VTK::Clip::Impl",[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,"    {","    if (planeNum >= numClipPlanes)","        {","        break;","        }","    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], vertexMC);","    }"]).result,a=yd.substitute(a,"//VTK::Clip::Dec",["uniform int numClipPlanes;",`varying float clipDistancesVSOutput[${e}];`]).result,a=yd.substitute(a,"//VTK::Clip::Impl",[`for (int planeNum = 0; planeNum < ${e}; planeNum++)`,"    {","    if (planeNum >= numClipPlanes)","        {","        break;","        }","    if (clipDistancesVSOutput[planeNum] < 0.0) discard;","    }"]).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()==_l.PolygonOffset||o.getEdgeVisibility()&&o.getRepresentation()===Jd.SURFACE){const e=t.lastBoundBO.getPrimitiveType();e===Qd.Points||o.getRepresentation()===Jd.POINTS?r=t.renderable.getCoincidentTopologyPointOffsetParameter():e===Qd.Lines||o.getRepresentation()===Jd.WIREFRAME?r=t.renderable.getCoincidentTopologyLineOffsetParameters():e!==Qd.Tris&&e!==Qd.TriStrips||(r=t.renderable.getCoincidentTopologyPolygonOffsetParameters()),e!==Qd.TrisEdges&&e!==Qd.TriStripsEdges||(r=t.renderable.getCoincidentTopologyPolygonOffsetParameters(),r.factor/=2,r.offset/=2)}const a=t._openGLRenderer.getSelector();return a&&a.getFieldAssociation()===Zd.FIELD_ASSOCIATION_POINTS&&(r.offset-=2),r},e.replaceShaderPicking=(e,n,r)=>{let o=e.Fragment,a=e.Vertex;if(o=yd.substitute(o,"//VTK::Picking::Dec",["uniform int picking;","//VTK::Picking::Dec"]).result,t._openGLRenderer.getSelector()){switch(t.lastSelectionState!==$l.ID_LOW24&&t.lastSelectionState!==$l.ID_HIGH24||(a=yd.substitute(a,"//VTK::Picking::Dec",["flat out int vertexIDVSOutput;\n","uniform int VertexIDOffset;\n"]).result,a=yd.substitute(a,"//VTK::Picking::Impl","  vertexIDVSOutput = gl_VertexID + VertexIDOffset;\n").result,o=yd.substitute(o,"//VTK::Picking::Dec","flat in int vertexIDVSOutput;\n").result,o=yd.substitute(o,"//VTK::Picking::Impl",["  int idx = vertexIDVSOutput;","//VTK::Picking::Impl"]).result),t.lastSelectionState){case $l.ID_LOW24:o=yd.substitute(o,"//VTK::Picking::Impl","  gl_FragData[0] = vec4(float(idx%256)/255.0, float((idx/256)%256)/255.0, float((idx/65536)%256)/255.0, 1.0);").result;break;case $l.ID_HIGH24:o=yd.substitute(o,"//VTK::Picking::Impl","  gl_FragData[0] = vec4(float((idx/16777216)%256)/255.0, 0.0, 0.0, 1.0);").result;break;default:o=yd.substitute(o,"//VTK::Picking::Dec","uniform vec3 mapperIndex;").result,o=yd.substitute(o,"//VTK::Picking::Impl","  gl_FragData[0] = picking != 0 ? vec4(mapperIndex,1.0) : gl_FragData[0];").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=yd.substitute(e,"//VTK::ZBuffer::Dec","uniform int depthRequest;").result,e=yd.substitute(e,"//VTK::ZBuffer::Impl",["if (depthRequest == 1) {","float iz = floor(gl_FragCoord.z*65535.0 + 0.1);","float rf = floor(iz/256.0)/255.0;","float gf = mod(iz,256.0)/255.0;","gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }"]).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()===ep.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("lastLightComplexity"),h=t.lastBoundBO.getReferenceByName("lastLightCount");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("PrimitiveIDOffset")&&n.getProgram().setUniformi("PrimitiveIDOffset",t.primitiveIDOffset),n.getProgram().isUniformUsed("VertexIDOffset")&&n.getProgram().setUniformi("VertexIDOffset",t.vertexIDOffset),n.getCABO().getElementCount()&&(t.VBOBuildTime.getMTime()>n.getAttributeUpdateTime().getMTime()||n.getShaderSourceTime().getMTime()>n.getAttributeUpdateTime().getMTime())){const e=t.lastBoundBO.getReferenceByName("lastLightComplexity");n.getProgram().isAttributeUsed("vertexMC")&&(n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),"vertexMC",n.getCABO().getVertexOffset(),n.getCABO().getStride(),t.context.FLOAT,3,!1)||op("Error setting vertexMC in shader VAO.")),n.getProgram().isAttributeUsed("normalMC")&&n.getCABO().getNormalOffset()&&e>0?n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),"normalMC",n.getCABO().getNormalOffset(),n.getCABO().getStride(),t.context.FLOAT,3,!1)||op("Error setting normalMC in shader VAO."):n.getVAO().removeAttributeArray("normalMC"),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)||op(`Error setting ${e}MC in shader VAO.`))})),n.getProgram().isAttributeUsed("tcoordMC")&&n.getCABO().getTCoordOffset()?n.getVAO().addAttributeArray(n.getProgram(),n.getCABO(),"tcoordMC",n.getCABO().getTCoordOffset(),n.getCABO().getStride(),t.context.FLOAT,n.getCABO().getTCoordComponents(),!1)||op("Error setting tcoordMC in shader VAO."):n.getVAO().removeAttributeArray("tcoordMC"),n.getProgram().isAttributeUsed("scalarColor")&&n.getCABO().getColorComponents()?n.getVAO().addAttributeArray(n.getProgram(),n.getCABO().getColorBO(),"scalarColor",n.getCABO().getColorOffset(),n.getCABO().getColorBOStride(),t.context.UNSIGNED_BYTE,4,!0)||op("Error setting scalarColor in shader VAO."):n.getVAO().removeAttributeArray("scalarColor"),n.getAttributeUpdateTime().modified()}if(t.renderable.getNumberOfClippingPlanes()){const e=t.renderable.getNumberOfClippingPlanes(),r=[],a=n.getCABO().getCoordShiftAndScaleEnabled()?n.getCABO().getInverseShiftAndScaleMatrix():null,i=a?d(t.tmpMat4,o.getMatrix()):o.getMatrix();a&&(m(i,i),T(i,i,a),m(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("numClipPlanes",e),n.getProgram().setUniform4fv("clipPlanes",r)}t.internalColorTexture&&n.getProgram().isUniformUsed("texture1")&&n.getProgram().setUniformi("texture1",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("depthRequest",t.renderDepth?1:0),n.getProgram().isUniformUsed("coffset")){const t=e.getCoincidentParameters(r,o);n.getProgram().setUniformf("coffset",t.offset),n.getProgram().isUniformUsed("cfactor")&&n.getProgram().setUniformf("cfactor",t.factor)}n.setMapperShaderParameters(r,o,t._openGLRenderer.getTiledSizeAndOrigin());const i=t._openGLRenderer.getSelector();n.getProgram().setUniform3fArray("mapperIndex",i?i.getPropColorValue():[0,0,0]),n.getProgram().setUniformi("picking",i?i.getCurrentPass()+1:0)},e.setLightingShaderParameters=(e,n,r)=>{const o=t.lastBoundBO.getReferenceByName("lastLightComplexity");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],qo(c)),t.lightDirection[0]=c[0],t.lightDirection[1]=c[1],t.lightDirection[2]=c[2],qo(t.lightDirection),a.setUniform3fArray(`lightColor${i}`,t.lightColor),a.setUniform3fArray(`lightDirectionVC${i}`,t.lightDirection),i++}}if(o<3)return;const l=n.getActiveCamera().getViewMatrix();m(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);Vn(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(),m=f?{mcwc:null,normalMatrix:null}:t.openGLActor.getKeyMatrices();if(i.getCoordinateSystem()===sp.DISPLAY){const e=t._openGLRenderer.getTiledSizeAndOrigin();g(t.tmpMat4),t.tmpMat4[0]=2/e.usize,t.tmpMat4[12]=-1,t.tmpMat4[5]=2/e.vsize,t.tmpMat4[13]=-1,T(t.tmpMat4,t.tmpMat4,p),s.setUniformMatrix("MCPCMatrix",t.tmpMat4)}else s.setUniformMatrix("MCPCMatrix",n([l.wcpc,m.mcwc,p],r,t.tmpMat4));s.isUniformUsed("MCVCMatrix")&&s.setUniformMatrix("MCVCMatrix",n([l.wcvc,m.mcwc,p],r,t.tmpMat4)),s.isUniformUsed("normalMatrix")&&s.setUniformMatrix3x3("normalMatrix",n([l.normalMatrix,m.normalMatrix],o,t.tmpMat3)),d!==u&&(s.isUniformUsed("cameraParallel")&&s.setUniformi("cameraParallel",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("opacityUniform",i),o.setUniform3fArray("ambientColorUniform",s),o.setUniform3fArray("diffuseColorUniform",l),o.setUniformf("ambient",c),o.setUniformf("diffuse",u);const f=t.lastBoundBO.getReferenceByName("lastLightComplexity");if(f<1)return;let g=a.getSpecularColorByReference();if(o.setUniform3fArray("specularColorUniform",g),o.setUniformf("specularPowerUniform",p),o.setUniformf("specular",d),o.isUniformUsed("ambientIntensityBF")){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("ambientIntensityBF",c),o.setUniformf("diffuseIntensityBF",u),o.setUniformf("opacityUniformBF",i),o.setUniform3fArray("ambientColorUniformBF",s),o.setUniform3fArray("diffuseColorUniformBF",l),f<1)return;o.setUniformf("specularIntensityBF",d),o.setUniform3fArray("specularColorUniformBF",g),o.setUniformf("specularPowerUniformBF",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()===Zd.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():$l.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===Jd.SURFACE,i=t._openGLRenderer.getSelector(),s=i&&i.getFieldAssociation()===Zd.FIELD_ASSOCIATION_POINTS&&(t.lastSelectionState===$l.ID_LOW24||t.lastSelectionState===$l.ID_HIGH24);for(let i=Qd.Start;i<Qd.End;i++)t.primitives[i].setPointPicking(s),t.primitives[i].getCABO().getElementCount()&&(t.drawingEdges=a&&(i===Qd.TrisEdges||i===Qd.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(ap),t.renderable.getStatic()||t.renderable.update(),t.currentInput=t.renderable.getInputData(),e.invokeEvent(ip),!t.currentInput)return void op("No input!");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.computeBounds=(n,r)=>{e.getInput()?t.bounds=e.getInput().getBounds():Oa(t.bounds)},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!==tp.USE_CELL_DATA&&a!==tp.USE_CELL_FIELD_DATA&&a!==tp.USE_FIELD_DATA&&r.getPointData().getScalars()||a===tp.USE_POINT_FIELD_DATA||!o||(t.haveCellScalars=!0));let i=n.getProperty().getInterpolation()!==ep.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=Kd.newInstance({resizable:!0}));const e=t.internalColorTexture;e.setMinificationFilter(np.NEAREST),e.setMagnificationFilter(np.NEAREST),e.setWrapS(rp.CLAMP_TO_EDGE),e.setWrapT(rp.CLAMP_TO_EDGE),e.setOpenGLRenderWindow(t._openGLRenderWindow);const n=t.renderable.getColorTextureMap(),r=n.getExtent(),o=n.getPointData().getScalars();e.create2DFromRaw(r[1]-r[0]+1,r[3]-r[2]+1,o.getNumberOfComponents(),o.getDataType(),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
diff --git a/points.html b/points.html
No results found