OpenGeodeWeb-Viewer 1.32.1rc1__tar.gz → 1.33.0__tar.gz

{opengeodeweb_viewer-1.32.1rc1 → opengeodeweb_viewer-1.33.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Viewer
-Version: 1.32.1rc1
+Version: 1.33.0
 Summary: OpenGeodeWeb-Viewer is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem
 Author-email: Geode-solutions <team-web@geode-solutions.com>
 Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Viewer

{opengeodeweb_viewer-1.32.1rc1 → opengeodeweb_viewer-1.33.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "OpenGeodeWeb-Viewer"
-version = "1.32.1-rc.1"
+version = "1.33.0"
 dynamic = ["dependencies"]
 authors = [{ name = "Geode-solutions", email = "team-web@geode-solutions.com" }]
 description = "OpenGeodeWeb-Viewer is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem"

{opengeodeweb_viewer-1.32.1rc1 → opengeodeweb_viewer-1.33.0}/src/OpenGeodeWeb_Viewer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Viewer
-Version: 1.32.1rc1
+Version: 1.33.0
 Summary: OpenGeodeWeb-Viewer is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem
 Author-email: Geode-solutions <team-web@geode-solutions.com>
 Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Viewer

{opengeodeweb_viewer-1.32.1rc1 → opengeodeweb_viewer-1.33.0}/src/OpenGeodeWeb_Viewer.egg-info/SOURCES.txt

@@ -197,6 +197,8 @@ src/opengeodeweb_viewer/rpc/viewer/schemas/axes.json
 src/opengeodeweb_viewer/rpc/viewer/schemas/axes.py
 src/opengeodeweb_viewer/rpc/viewer/schemas/clipping_planes.json
 src/opengeodeweb_viewer/rpc/viewer/schemas/clipping_planes.py
+src/opengeodeweb_viewer/rpc/viewer/schemas/explode.json
+src/opengeodeweb_viewer/rpc/viewer/schemas/explode.py
 src/opengeodeweb_viewer/rpc/viewer/schemas/get_point_position.json
 src/opengeodeweb_viewer/rpc/viewer/schemas/get_point_position.py
 src/opengeodeweb_viewer/rpc/viewer/schemas/grid_scale.json
@@ -238,4 +240,5 @@ src/opengeodeweb_viewer/rpc/viewer/schemas/update_data.py
 tests/test_generic_protocols.py
 tests/test_typed_rpcs.py
 tests/test_utils_protocols.py
-tests/test_viewer_protocols.py
+tests/test_viewer_protocols.py
+tests/test_vtk_pipeline.py

{opengeodeweb_viewer-1.32.1rc1 → opengeodeweb_viewer-1.33.0}/src/opengeodeweb_viewer/rpc/viewer/schemas/__init__.py

@@ -17,5 +17,6 @@ from .pick_colormap import *
 from .highlight import *
 from .grid_scale import *
 from .get_point_position import *
+from .explode import *
 from .clipping_planes import *
 from .axes import *

opengeodeweb_viewer-1.33.0/src/opengeodeweb_viewer/rpc/viewer/schemas/explode.json

@@ -0,0 +1,30 @@
+{
+  "rpc": "explode",
+  "type": "object",
+  "properties": {
+    "ids": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 32,
+        "maxLength": 32
+      }
+    },
+    "explode_factor": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1
+    }
+  },
+  "required": [
+    "ids",
+    "explode_factor"
+  ],
+  "additionalProperties": false,
+  "response": {
+    "type": "object",
+    "properties": {},
+    "required": [],
+    "additionalProperties": false
+  }
+}

opengeodeweb_viewer-1.33.0/src/opengeodeweb_viewer/rpc/viewer/schemas/explode.py

@@ -0,0 +1,31 @@
+from opengeodeweb_microservice.schemas import Route, load_schema
+from dataclasses_json import DataClassJsonMixin
+from opengeodeweb_microservice.schemas import print_dataclass
+from dataclasses import dataclass
+from typing import List
+
+
+@dataclass
+class Explode(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print_dataclass(self)
+
+    explode_factor: float
+    ids: List[str]
+
+
+@dataclass
+class ExplodeResponse(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print_dataclass(self)
+
+    pass
+
+
+explode_route = Route(
+    schema=load_schema(__file__),
+    params=Explode,
+    response=ExplodeResponse,
+)
+
+__all__ = ["Explode", "ExplodeResponse", "explode_route"]

{opengeodeweb_viewer-1.32.1rc1 → opengeodeweb_viewer-1.33.0}/src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py

@@ -334,6 +334,11 @@ class VtkViewerView(VtkView):
         self.set_shrink(params.ids, params.shrink_factor)
         return schemas.ShrinkResponse()
 
+    @typed_rpc(viewer_prefix, schemas.explode_route)
+    def setExplode(self, params: schemas.Explode) -> schemas.ExplodeResponse:
+        self.set_explode(params.ids, params.explode_factor)
+        return schemas.ExplodeResponse()
+
     @typed_rpc(viewer_prefix, schemas.slice_route)
     def setSlice(self, params: schemas.Slice) -> schemas.SliceResponse:
         return schemas.SliceResponse(

{opengeodeweb_viewer-1.32.1rc1 → opengeodeweb_viewer-1.33.0}/src/opengeodeweb_viewer/vtk_pipeline.py

@@ -23,6 +23,8 @@ from vtkmodules.vtkRenderingAnnotation import (
 from vtkmodules.vtkRenderingFreeType import vtkVectorText
 from vtkmodules.vtkFiltersSources import vtkLineSource, vtkSphereSource
 from vtkmodules.vtkCommonDataModel import (
+    vtkBoundingBox,
+    vtkCompositeDataSet,
     vtkDataObject,
     vtkDataSet,
     vtkMultiBlockDataSet,
@@ -36,7 +38,8 @@ from vtkmodules.vtkFiltersExtraction import (
     vtkExtractSelection,
 )
 from vtkmodules.vtkFiltersCore import vtkThreshold
-from vtkmodules.vtkFiltersGeneral import vtkShrinkFilter
+from vtkmodules.vtkCommonTransforms import vtkTransform
+from vtkmodules.vtkFiltersGeneral import vtkShrinkFilter, vtkTransformFilter
 from vtkmodules.vtkFiltersCore import vtkAppendFilter
 from vtkmodules.vtkFiltersGeometry import vtkGeometryFilter
 from vtkmodules.vtkIOXML import vtkXMLReader
@@ -51,6 +54,8 @@ from opengeodeweb_viewer.utils_functions import (
     create_color_transfer_function,
 )
 
+STACKING_GAP_RATIO = 0.05
+
 
 @dataclass
 class ViewerData:
@@ -216,6 +221,7 @@ class VtkPipeline:
     clipping_filter: vtkExtractGeometry | None = None
     threshold_filter: vtkThreshold | None = None
     shrink_filter: vtkShrinkFilter | None = None
+    explode_factor: float = 0.0
     highlight: HighlightPipeline = field(default_factory=HighlightPipeline)
     blockDataSets: list[vtkDataObject | None] = field(default_factory=list)
     blockGeodeIds: list[str] = field(default_factory=list)
@@ -262,6 +268,126 @@ class VtkPipeline:
                 pruned.SetBlock(index, child)
         return pruned
 
+    def source_components(self) -> dict[int, tuple[str, vtkBoundingBox]]:
+        components: dict[int, tuple[str, vtkBoundingBox]] = {}
+        component_type = ""
+        iterator = self.reader.GetOutputDataObject(0).NewTreeIterator()
+        iterator.VisitOnlyLeavesOff()
+        iterator.InitTraversal()
+        while not iterator.IsDoneWithTraversal():
+            component = iterator.GetCurrentDataObject()
+            if isinstance(component, vtkMultiBlockDataSet):
+                component_type = iterator.GetCurrentMetaData().Get(
+                    vtkCompositeDataSet.NAME()
+                )
+            elif isinstance(component, vtkDataSet):
+                bbox = vtkBoundingBox(component.GetBounds())
+                if bbox.IsValid():
+                    components[iterator.GetCurrentFlatIndex()] = (component_type, bbox)
+            iterator.GoToNextItem()
+        return components
+
+    @staticmethod
+    def overlaps_in_xy(bbox: vtkBoundingBox, other_bbox: vtkBoundingBox) -> bool:
+        return all(
+            bbox.GetBound(2 * axis) < other_bbox.GetBound(2 * axis + 1)
+            and other_bbox.GetBound(2 * axis) < bbox.GetBound(2 * axis + 1)
+            for axis in (0, 1)
+        )
+
+    @staticmethod
+    def stacking_shifts(
+        stacked_blocks: dict[int, vtkBoundingBox],
+    ) -> dict[int, float]:
+        stacked_bbox = vtkBoundingBox()
+        for bbox in stacked_blocks.values():
+            stacked_bbox.AddBox(bbox)
+        vertical_gap = STACKING_GAP_RATIO * stacked_bbox.GetLength(2)
+        shifts: dict[int, float] = {}
+        for flat_index, bbox in sorted(
+            stacked_blocks.items(), key=lambda item: item[1].GetBound(4)
+        ):
+            shifts[flat_index] = max(
+                [0.0]
+                + [
+                    placed_bbox.GetBound(5)
+                    + shifts[placed_index]
+                    + vertical_gap
+                    - bbox.GetBound(4)
+                    for placed_index, placed_bbox in stacked_blocks.items()
+                    if placed_index in shifts
+                    and VtkPipeline.overlaps_in_xy(bbox, placed_bbox)
+                ]
+            )
+        return shifts
+
+    @staticmethod
+    def followed_shift(
+        component_bbox: vtkBoundingBox,
+        stacked_blocks: dict[int, vtkBoundingBox],
+        stacked_shifts: dict[int, float],
+    ) -> float:
+        center = [0.0, 0.0, 0.0]
+        component_bbox.GetCenter(center)
+        containing_ids = [
+            flat_index
+            for flat_index, bbox in stacked_blocks.items()
+            if bbox.Contains(component_bbox)
+        ] or [
+            flat_index
+            for flat_index, bbox in stacked_blocks.items()
+            if bbox.ContainsPoint(center)
+        ]
+        if not containing_ids:
+            return 0.0
+        lowest_id = min(
+            containing_ids,
+            key=lambda flat_index: stacked_blocks[flat_index].GetBound(4),
+        )
+        return stacked_shifts[lowest_id]
+
+    def explode_blocks(self, dataset: vtkMultiBlockDataSet) -> vtkMultiBlockDataSet:
+        components = self.source_components()
+        stacked_blocks = {
+            flat_index: bbox
+            for flat_index, (component_type, bbox) in components.items()
+            if component_type == "blocks"
+        }
+        stacked_shifts = self.stacking_shifts(stacked_blocks)
+        z_shifts = {
+            flat_index: (
+                stacked_shifts[flat_index]
+                if flat_index in stacked_shifts
+                else self.followed_shift(bbox, stacked_blocks, stacked_shifts)
+            )
+            for flat_index, (_, bbox) in components.items()
+        }
+        return self.translate_blocks(dataset, z_shifts)
+
+    def translate_blocks(
+        self, dataset: vtkMultiBlockDataSet, z_shifts: dict[int, float]
+    ) -> vtkMultiBlockDataSet:
+        translated_dataset = vtkMultiBlockDataSet()
+        translated_dataset.CopyStructure(dataset)
+        iterator = dataset.NewTreeIterator()
+        iterator.InitTraversal()
+        while not iterator.IsDoneWithTraversal():
+            block = iterator.GetCurrentDataObject()
+            z_shift = z_shifts.get(iterator.GetCurrentFlatIndex(), 0.0)
+            if isinstance(block, vtkDataSet) and z_shift != 0.0:
+                translation = vtkTransform()
+                translation.Translate(0.0, 0.0, z_shift * self.explode_factor)
+                transform_filter = vtkTransformFilter()
+                transform_filter.SetInputData(block)
+                transform_filter.SetTransform(translation)
+                transform_filter.Update()
+                translated_dataset.SetDataSet(iterator, transform_filter.GetOutput())
+            elif block is not None:
+                translated_dataset.SetDataSet(iterator, block)
+            iterator.GoToNextItem()
+        translated_dataset.SetObjectName(dataset.GetObjectName())
+        return translated_dataset
+
     def get_block_style(self, block_id: int) -> BlockStyle:
         if block_id not in self.block_styles:
             style = BlockStyle(
@@ -353,22 +479,22 @@ class VtkPipeline:
     ) -> None:
         mapper = cast(vtkCompositePolyDataMapper, self.mapper)
         attributes = mapper.GetCompositeDataDisplayAttributes()
+        synced_attributes = vtkCompositeDataDisplayAttributes()
         color_rgb = [0.0, 0.0, 0.0]
         for source_block, destination_block in zip(self.blockDataSets, new_blocks):
             if source_block and destination_block:
                 if attributes.HasBlockColor(source_block):
                     attributes.GetBlockColor(source_block, color_rgb)
-                    attributes.SetBlockColor(destination_block, color_rgb)
-                else:
-                    attributes.RemoveBlockColor(destination_block)
+                    synced_attributes.SetBlockColor(destination_block, color_rgb)
                 if attributes.HasBlockVisibility(source_block):
-                    attributes.SetBlockVisibility(
+                    synced_attributes.SetBlockVisibility(
                         destination_block, attributes.GetBlockVisibility(source_block)
                     )
                 if attributes.HasBlockOpacity(source_block):
-                    attributes.SetBlockOpacity(
+                    synced_attributes.SetBlockOpacity(
                         destination_block, attributes.GetBlockOpacity(source_block)
                     )
+        mapper.SetCompositeDataDisplayAttributes(synced_attributes)
         self.blockDataSets = new_blocks
         for block_id in self.block_styles:
             self.update_block_colors(block_id)

{opengeodeweb_viewer-1.32.1rc1 → opengeodeweb_viewer-1.33.0}/src/opengeodeweb_viewer/vtk_protocol.py

@@ -21,6 +21,7 @@ from vtkmodules.vtkCommonDataModel import (
     vtkDataSet,
     vtkImplicitBoolean,
     vtkImageData,
+    vtkMultiBlockDataSet,
     vtkPlane,
     vtkSelectionNode,
 )
@@ -203,6 +204,10 @@ class VtkView(VtkTypingMixin, vtk_protocols.vtkWebProtocol):
         pipeline.filter.Update()
         filtered_dataset = pipeline.filter.GetOutputDataObject(0)
         if isinstance(pipeline.mapper, vtkCompositePolyDataMapper):
+            if pipeline.explode_factor > 0 and isinstance(
+                filtered_dataset, vtkMultiBlockDataSet
+            ):
+                filtered_dataset = pipeline.explode_blocks(filtered_dataset)
             pipeline.sync_composite_pipeline(filtered_dataset)
             return
         pipeline.mapper.SetInputConnection(pipeline.filter.GetOutputPort())
@@ -268,6 +273,14 @@ class VtkView(VtkTypingMixin, vtk_protocols.vtkWebProtocol):
                 pipeline.shrink_filter = None
             self.update_pipeline_filter(pipeline)
 
+    def set_explode(self, data_ids: list[str], explode_factor: float) -> None:
+        for data_id in data_ids:
+            pipeline = self.get_vtk_pipeline(data_id)
+            if not isinstance(pipeline.mapper, vtkCompositePolyDataMapper):
+                continue
+            pipeline.explode_factor = explode_factor
+            self.update_pipeline_filter(pipeline)
+
     def set_slice(self, data_ids: list[str], slices: list[SliceElement]) -> list[int]:
         max_indices = [0, 0, 0]
         for data_id in data_ids:

{opengeodeweb_viewer-1.32.1rc1 → opengeodeweb_viewer-1.33.0}/tests/test_viewer_protocols.py

@@ -402,6 +402,18 @@ def test_shrink(server: ServerMonitor, dataset_factory: Callable[..., str]) -> N
     assert server.compare_image("viewer/shrink.jpeg") == True
 
 
+def test_explode_mesh(
+    server: ServerMonitor, dataset_factory: Callable[..., str]
+) -> None:
+    test_register_mesh(server, dataset_factory)
+    server.call(
+        VtkViewerView.viewer_prefix
+        + VtkViewerView.viewer_schemas_dict["explode"]["rpc"],
+        [{"ids": [mesh_id], "explode_factor": 0.5}],
+    )
+    assert server.compare_image("mesh/register.jpeg") == True
+
+
 def test_clipping_then_shrink(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:

opengeodeweb_viewer-1.33.0/tests/test_vtk_pipeline.py

@@ -0,0 +1,206 @@
+# Standard library imports
+
+# Third party imports
+import pytest
+from vtkmodules.vtkCommonDataModel import (
+    vtkCompositeDataSet,
+    vtkDataSet,
+    vtkImageData,
+    vtkMultiBlockDataSet,
+    vtkPolyData,
+)
+from vtkmodules.vtkCommonExecutionModel import vtkTrivialProducer
+from vtkmodules.vtkFiltersGeneral import vtkShrinkFilter
+from vtkmodules.vtkFiltersSources import vtkCubeSource
+from vtkmodules.vtkIOXML import vtkXMLMultiBlockDataReader
+from vtkmodules.vtkRenderingCore import (
+    vtkCompositeDataDisplayAttributes,
+    vtkCompositePolyDataMapper,
+)
+
+# Local application imports
+from opengeodeweb_viewer.vtk_pipeline import STACKING_GAP_RATIO, VtkPipeline
+
+
+def test_sync_block_display_attributes_drops_replaced_blocks() -> None:
+    mapper = vtkCompositePolyDataMapper()
+    mapper.SetCompositeDataDisplayAttributes(vtkCompositeDataDisplayAttributes())
+    pipeline = VtkPipeline(vtkXMLMultiBlockDataReader(), mapper)
+    source_block = vtkPolyData()
+    destination_block = vtkPolyData()
+    pipeline.blockDataSets = [source_block]
+    attributes = mapper.GetCompositeDataDisplayAttributes()
+    attributes.SetBlockVisibility(source_block, False)
+    attributes.SetBlockOpacity(source_block, 0.5)
+    attributes.SetBlockColor(source_block, [1.0, 0.0, 0.0])
+
+    pipeline.sync_block_display_attributes([destination_block])
+
+    attributes = mapper.GetCompositeDataDisplayAttributes()
+    assert attributes.GetBlockVisibility(destination_block) == False
+    assert attributes.GetBlockOpacity(destination_block) == 0.5
+    assert attributes.HasBlockColor(destination_block)
+    assert not attributes.HasBlockVisibility(source_block)
+    assert not attributes.HasBlockOpacity(source_block)
+    assert not attributes.HasBlockColor(source_block)
+
+
+def box(bounds: list[float]) -> vtkPolyData:
+    cube = vtkCubeSource()
+    cube.SetBounds(bounds)
+    cube.Update()
+    return cube.GetOutput()
+
+
+def solid(bounds: list[float]) -> vtkImageData:
+    image = vtkImageData()
+    image.SetDimensions(2, 2, 2)
+    image.SetOrigin(bounds[0], bounds[2], bounds[4])
+    image.SetSpacing(
+        bounds[1] - bounds[0], bounds[3] - bounds[2], bounds[5] - bounds[4]
+    )
+    return image
+
+
+def component_group(
+    name: str, blocks: list[vtkPolyData] | list[vtkImageData]
+) -> vtkMultiBlockDataSet:
+    group = vtkMultiBlockDataSet()
+    for index, block in enumerate(blocks):
+        group.SetBlock(index, block)
+    group.SetObjectName(name)
+    return group
+
+
+def model_of(*groups: vtkMultiBlockDataSet) -> vtkMultiBlockDataSet:
+    model = vtkMultiBlockDataSet()
+    for index, group in enumerate(groups):
+        model.SetBlock(index, group)
+        model.GetMetaData(index).Set(vtkCompositeDataSet.NAME(), group.GetObjectName())
+    return model
+
+
+def stacked_model() -> vtkMultiBlockDataSet:
+    surfaces = component_group(
+        "surfaces",
+        [
+            box([0, 10, 0, 10, 5, 5]),
+            box([0, 10, 0, 10, 9, 9]),
+            box([0, 0, 0, 10, 3, 10]),
+        ],
+    )
+    blocks = component_group(
+        "blocks",
+        [
+            solid([0, 10, 0, 10, 0, 7]),
+            solid([0, 10, 0, 10, 3, 10]),
+            solid([20, 30, 0, 10, 0, 10]),
+        ],
+    )
+    return model_of(surfaces, blocks)
+
+
+UPPER_BLOCK_ID = 7
+STACKED_HEIGHT = 10
+GAP = STACKING_GAP_RATIO * STACKED_HEIGHT
+
+
+def explode(
+    model: vtkMultiBlockDataSet,
+    explode_factor: float,
+    shrink_factor: float = 1.0,
+    hidden_block_ids: tuple[int, ...] = (),
+) -> tuple[list[vtkDataSet], list[vtkDataSet]]:
+    model_source = vtkTrivialProducer()
+    model_source.SetOutput(model)
+    mapper = vtkCompositePolyDataMapper()
+    mapper.SetCompositeDataDisplayAttributes(vtkCompositeDataDisplayAttributes())
+    pipeline = VtkPipeline(model_source, mapper)  # type: ignore[arg-type]
+    shrink_filter = vtkShrinkFilter()
+    shrink_filter.SetShrinkFactor(shrink_factor)
+    shrink_filter.SetInputConnection(model_source.GetOutputPort())
+    pipeline.filter.SetInputConnection(shrink_filter.GetOutputPort())
+    pipeline.filter.Update()
+    filtered_model = pipeline.filter.GetOutputDataObject(0)
+    pipeline.blockDataSets = pipeline.extract_blocks(filtered_model)
+    for block_id in hidden_block_ids:
+        mapper.GetCompositeDataDisplayAttributes().SetBlockVisibility(
+            pipeline.blockDataSets[block_id], False
+        )
+    pipeline.explode_factor = explode_factor
+    exploded_model = pipeline.explode_blocks(filtered_model)
+    return (
+        [
+            block
+            for block in pipeline.extract_blocks(filtered_model)
+            if isinstance(block, vtkDataSet)
+        ],
+        [
+            block
+            for block in pipeline.extract_blocks(exploded_model)
+            if isinstance(block, vtkDataSet)
+        ],
+    )
+
+
+def z_ranges(blocks: list[vtkDataSet]) -> list[tuple[float, float]]:
+    return [(block.GetBounds()[4], block.GetBounds()[5]) for block in blocks]
+
+
+def test_explode_blocks_stacks_overlapping_blocks_along_z() -> None:
+    (
+        interface,
+        upper_surface,
+        upper_side_surface,
+        lower_block,
+        upper_block,
+        side_block,
+    ) = z_ranges(explode(stacked_model(), 1.0)[1])
+    assert lower_block == pytest.approx((0, 7))
+    assert upper_block == pytest.approx((7 + GAP, 14 + GAP))
+    assert side_block == pytest.approx((0, 10))
+    assert interface == pytest.approx((5, 5))
+    assert upper_surface == pytest.approx((13 + GAP, 13 + GAP))
+    assert upper_side_surface == pytest.approx((7 + GAP, 14 + GAP))
+
+
+def test_explode_blocks_interpolates_with_factor() -> None:
+    upper_block = z_ranges(explode(stacked_model(), 0.5)[1])[4]
+    assert upper_block == pytest.approx((3 + (4 + GAP) / 2, 10 + (4 + GAP) / 2))
+
+
+def test_explode_blocks_keeps_components_on_their_block_after_shrink() -> None:
+    filtered_blocks, exploded_blocks = explode(stacked_model(), 1.0, shrink_factor=0.8)
+    shifts = [
+        exploded[0] - filtered[0]
+        for filtered, exploded in zip(
+            z_ranges(filtered_blocks), z_ranges(exploded_blocks)
+        )
+    ]
+    upper_side_surface, upper_block = shifts[2], shifts[4]
+    assert upper_block == pytest.approx(4 + GAP)
+    assert upper_side_surface == pytest.approx(4 + GAP)
+
+
+def test_explode_blocks_stacks_hidden_blocks() -> None:
+    upper_block = z_ranges(
+        explode(stacked_model(), 1.0, hidden_block_ids=(UPPER_BLOCK_ID,))[1]
+    )[4]
+    assert upper_block == pytest.approx((7 + GAP, 14 + GAP))
+
+
+def test_explode_blocks_reuses_unshifted_blocks() -> None:
+    filtered_blocks, exploded_blocks = explode(stacked_model(), 1.0)
+    lower_block, upper_block = 3, 4
+    assert exploded_blocks[lower_block] is filtered_blocks[lower_block]
+    assert exploded_blocks[upper_block] is not filtered_blocks[upper_block]
+
+
+def test_explode_blocks_stacks_block_nested_in_another() -> None:
+    blocks = component_group(
+        "blocks",
+        [solid([0, 10, 0, 10, 0, 10]), solid([0, 10, 0, 10, 0, 4])],
+    )
+    outer_block, inner_block = z_ranges(explode(model_of(blocks), 1.0)[1])
+    assert outer_block[0] == pytest.approx(0)
+    assert inner_block[0] == pytest.approx(10 + GAP)