handling mixed slices and volumes

.github/workflows/test_and_deploy.yml

@@ -48,9 +48,17 @@ jobs:
       # setup-miniconda: https://github.com/conda-incubator/setup-miniconda
       # and
       # tox-conda: https://github.com/tox-dev/tox-conda
-      - name: Install dependencies
+      - name: Upgrade pip
         run: |
           python -m pip install --upgrade pip
+
+      - name: Limit pip for windows
+        if: runner.os == 'Windows'
+        run: |
+          python -m pip install --upgrade "pip<22"
+
+      - name: Install dependencies
+        run: |
           python -m pip install setuptools tox tox-gh-actions
 
       # this runs the platform-specific tests declared in tox.ini

src/yt_napari/_model_ingestor.py

@@ -18,12 +18,22 @@ def _le_re_to_cen_wid(
 
 class LayerDomain:
     # container for domain info for a single layer
+    # left_edge, right_edge, resolution, n_d are all self explanatory.
+    # other parameters:
+    #
+    # new_dim_value: optional unyt_quantity.
+    #   If n_d == 2, and upgrade_to_3D is subsequently called, then this value
+    #   will be used for the new
+    # new_dim_axis: optional int.
+    #   the index position to add the new_dim_position, default is last
     def __init__(
         self,
         left_edge: unyt_array,
         right_edge: unyt_array,
         resolution: tuple,
-        n_d: int = 3,
+        n_d: Optional[int] = 3,
+        new_dim_value: Optional[unyt_quantity] = None,
+        new_dim_axis: Optional[int] = 2,
     ):
 
         if len(left_edge) != len(right_edge):
@@ -33,7 +43,10 @@ def __init__(
             if len(resolution) == 1:
                 resolution = resolution * n_d  # assume same in every dim
             else:
-                raise ValueError("length of resolution does not match edge arrays")
+                msg = f"{len(resolution)}:{len(left_edge)}"
+                raise ValueError(
+                    f"length of resolution does not match edge arrays {msg}"
+                )
 
         self.left_edge = left_edge
         self.right_edge = right_edge
@@ -43,6 +56,36 @@ def __init__(
         self.aspect_ratio = self.width / self.width[0]
         self.requires_scale = np.any(self.aspect_ratio != unyt_array(1.0, ""))
         self.n_d = n_d
+        if new_dim_value is None:
+            new_dim_value = unyt_quantity(0.0, left_edge.units)
+        self.new_dim_value = new_dim_value
+        self.new_dim_axis = new_dim_axis
+
+    def upgrade_to_3D(self):
+        # note: this is not (yet) used when loading planes in 3d scenes.
+        if self.n_d == 3:
+            return  # already 3D, nothing to do
+
+        if self.n_d == 2:
+            new_l_r = self.new_dim_value
+            axid = self.new_dim_axis
+            self.left_edge = _insert_to_unyt_array(self.left_edge, new_l_r, axid)
+            self.right_edge = _insert_to_unyt_array(self.right_edge, new_l_r, axid)
+            self.resolution = _insert_to_unyt_array(self.right_edge, 1, axid)
+            self.grid_width = _insert_to_unyt_array(self.grid_width, 0, axid)
+            self.aspect_ratio = _insert_to_unyt_array(self.aspect_ratio, 1.0, axid)
+            self.n_d = 3
+
+
+def _insert_to_unyt_array(
+    x: unyt_array, new_value: Union[float, unyt_array], position: int
+) -> unyt_array:
+    # just for scalars
+    if isinstance(new_value, unyt_array):
+        # reminder: unyt_quantity is instance of unyt_array
+        new_value = new_value.to(x.units).d
+
+    return unyt_array(np.insert(x.d, position, new_value), x.units)
 
 
 # define types for the napari layer tuples
@@ -65,6 +108,9 @@ def __init__(self, ref_layer_domain: LayerDomain):
         self.grid_width = ref_layer_domain.grid_width
         self.aspect_ratio = ref_layer_domain.aspect_ratio
 
+        # and store the full domain
+        self.layer_domain = ref_layer_domain
+
     def calculate_scale(self, other_layer: LayerDomain) -> unyt_array:
         # calculate the pixel scale for a layer relative to the reference
 
@@ -73,6 +119,7 @@ def calculate_scale(self, other_layer: LayerDomain) -> unyt_array:
         # layers. scale > 1 will take a small number of pixels and stretch them
         # to cover more pixels. scale < 1 will shrink them.
         sc = other_layer.grid_width / self.grid_width
+        sc[sc == 0] = 1.0
 
         # we also need to multiply by the initial reference layer aspect ratio
         # to account for any initial distortion.
@@ -96,6 +143,12 @@ def align_sanitize_layer(self, layer: SpatialLayer) -> Layer:
         # pull out the elements of the SpatialLayer tuple
         im_arr, im_kwargs, layer_type, domain = layer
 
+        # bypass if adding a 2d layer
+        if domain.n_d == 2 and self.layer_domain.n_d == 3:
+            # when mixing 2d and 3d selections, cannot guarantee alignment
+            # or scaling, simply return with no adjustment
+            return (im_arr, im_kwargs, layer_type)
+
         # calculate scale and translation
         scale = self.calculate_scale(domain)
         translate = self.calculate_translation(domain)
@@ -371,7 +424,12 @@ def _process_slice(
     )
 
     layer_domain = LayerDomain(
-        left_edge=LE, right_edge=RE, resolution=resolution, n_d=2
+        left_edge=LE,
+        right_edge=RE,
+        resolution=resolution,
+        n_d=2,
+        new_dim_axis=2,
+        new_dim_value=0.0,
     )
 
     return frb, layer_domain
@@ -428,7 +486,6 @@ def _process_validated_model(model: InputModel) -> List[SpatialLayer]:
     # return a list of layer tuples with domain information
 
     layer_list = []
-
     # our model is already validated, so we can assume the field exist with
     # their correct types. This is all the yt-specific code required to load a
     # dataset and return a plain numpy array

src/yt_napari/_tests/test_model_ingestor.py

@@ -83,16 +83,72 @@ def test_layer_domain(domains_to_test):
         assert np.all(layer_domain.width == d.width)
 
     # check some instantiation things
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="length of edge arrays must match"):
         _ = _mi.LayerDomain(d.left_edge, unyt.unyt_array([1, 2], "m"), d.resolution)
 
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="length of resolution does not"):
         _ = _mi.LayerDomain(d.left_edge, d.right_edge, (10, 12))
 
     ld = _mi.LayerDomain(d.left_edge, d.right_edge, (10,))
     assert len(ld.resolution) == 3
 
 
+def test_layer_domain_dimensionality():
+    # note: the code being tested here could be used to help orient the slices
+    # in 3D but is not currently used.
+    # sets of left_edge, right_edge, center, width, res
+    le = unyt.unyt_array([1.0, 1.0], "km")
+    re = unyt.unyt_array([2000.0, 2000.0], "m")
+    res = (10, 20)
+    ld = _mi.LayerDomain(le, re, res, n_d=2)
+    assert ld.n_d == 2
+
+    ld.upgrade_to_3D()
+    assert ld.n_d == 3
+    assert len(ld.left_edge) == 3
+    assert ld.left_edge[-1] == 0.0
+    ld.upgrade_to_3D()  # nothing should happen
+
+    ld = _mi.LayerDomain(le, re, res, n_d=2, new_dim_value=0.5)
+    ld.upgrade_to_3D()
+    assert ld.left_edge[2] == unyt.unyt_quantity(0.5, le.units)
+
+    new_val = unyt.unyt_quantity(0.5, "km")
+    ld = _mi.LayerDomain(le, re, res, n_d=2, new_dim_value=new_val)
+    ld.upgrade_to_3D()
+    assert ld.left_edge[2].to("km") == new_val
+
+    ld = _mi.LayerDomain(le, re, res, n_d=2, new_dim_value=new_val, new_dim_axis=0)
+    ld.upgrade_to_3D()
+    assert ld.left_edge[0].to("km") == new_val
+
+
+_test_cases_insert = [
+    (
+        unyt.unyt_array([1.0, 1.0], "km"),
+        unyt.unyt_array(
+            [
+                1000.0,
+            ],
+            "m",
+        ),
+        unyt.unyt_array([1.0, 1.0, 1.0], "km"),
+    ),
+    (
+        unyt.unyt_array([1.0, 1.0], "km"),
+        unyt.unyt_quantity(1000.0, "m"),
+        unyt.unyt_array([1.0, 1.0, 1.0], "km"),
+    ),
+    (unyt.unyt_array([1.0, 1.0], "km"), 0.5, unyt.unyt_array([1.0, 1.0, 0.5], "km")),
+]
+
+
+@pytest.mark.parametrize("x,x2,expected", _test_cases_insert)
+def test_insert_to_unyt_array(x, x2, expected):
+    result = _mi._insert_to_unyt_array(x, x2, 2)
+    assert np.all(result == expected)
+
+
 def test_domain_tracking(domains_to_test):
 
     full_domain = _mi.PhysicalDomainTracker()
@@ -239,3 +295,23 @@ def test_ref_layer_selection(domains_to_test):
 
     with pytest.raises(ValueError, match="method must be one of"):
         _ = _mi._choose_ref_layer(spatial_layer_list, method="not_a_method")
+
+
+def test_2d_3d_mix():
+
+    le = unyt.unyt_array([1.0, 1.0, 1.0], "km")
+    re = unyt.unyt_array([2000.0, 2000.0, 2000.0], "m")
+    res = (10, 20, 15)
+    layer_3d = _mi.LayerDomain(le, re, res)
+    ref = _mi.ReferenceLayer(layer_3d)
+
+    le = unyt.unyt_array([1, 1], "km")
+    re = unyt.unyt_array([2000.0, 2000.0], "m")
+    res = (10, 20)
+    layer_2d = _mi.LayerDomain(
+        le, re, res, n_d=2, new_dim_value=unyt.unyt_quantity(1, "km")
+    )
+
+    sp_layer = (np.random.random(res), {}, "testname", layer_2d)
+    new_layer_2d = ref.align_sanitize_layer(sp_layer)
+    assert "scale" not in new_layer_2d[1]  # no scale when it is all 1