mtlearn 1.2.0__tar.gz → 1.2.1__tar.gz

{mtlearn-1.2.0 → mtlearn-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mtlearn
-Version: 1.2.0
+Version: 1.2.1
 Summary: Morphological tree learning utilities with a stable morphology facade
 Author-Email: Wonder Alexandre Luz Alves <worderalexandre@gmail.com>
 License-Expression: GPL-3.0-only

{mtlearn-1.2.0 → mtlearn-1.2.1}/docs/source/concepts/attributes.md

@@ -2,7 +2,7 @@
 
 This catalog lists the scalar attributes exposed through
 `mtlearn.morphology.AttributeType` and the groups exposed through
-`mtlearn.morphology.AttributeGroup`: 132 scalar attributes and nine groups.
+`mtlearn.morphology.AttributeGroup`: 133 scalar attributes and nine groups.
 Names, groups, and definitions follow the
 [mmcfilters v5.2.0 attribute catalog](https://github.com/wonderalexandre/mmcfilters/blob/v5.2.0/docs/attribute-catalog.md).
 
@@ -49,7 +49,7 @@ below, with its group memberships. `ALL` includes every listed scalar.
 
 | Group | Meaning |
 | --- | --- |
-| `GRAY_LEVEL` | Gray-level mass, contrast, height, mean, and variance. |
+| `GRAY_LEVEL` | Node valuation, gray-level mass, contrast, height, mean, and variance. |
 | `SHAPE` | Size, bounding box, moment, bitquad, contour, and selected shape descriptors. |
 | `MOMENTS` | Central moments, Hu invariants, and moment-derived descriptors. |
 | `BOUNDARY` | Bitquad and contour descriptors. |
@@ -75,16 +75,11 @@ The catalog uses three contracts:
 | Topology/support | Uses node support, pixel coordinates, contours, or adjacency information. |
 | Tree topology | Reads only parent/child relations in the hierarchy. |
 
-Distance-transform attributes require a regular 2D image domain. They support
-max-trees, min-trees, and trees of shapes without requiring node altitudes or
-construction-adjacency metadata. Bitquad and filled-shape attributes require
-canonical 4- or 8-connectivity; trees of shapes also use node altitudes to
-select the applicable directional connectivity.
-
 ## Gray-Level Attributes
 
 | Attribute | Groups | Contract | Use |
 | --- | --- | --- | --- |
+| `GRAY_LEVEL` | `GRAY_LEVEL` | Altitude-aware | Node valuation: the gray level associated with the node. |
 | `VOLUME` | `GRAY_LEVEL` | Altitude-aware | Sum of altitude-weighted support contributions over the node subtree. |
 | `RELATIVE_VOLUME` | `GRAY_LEVEL` | Altitude-aware | Recursive contrast volume `R(n) = area(n) + sum_c [R(c) + area(c) * abs(altitude(c) - altitude(n))]` over the direct children `c`. |
 | `GRAY_LEVEL_HEIGHT` | `GRAY_LEVEL` | Altitude-aware | Maximum absolute altitude difference between the node and any node in its subtree. |
@@ -99,23 +94,16 @@ contrast, intensity, or altitude differences rather than pure geometry.
 | Attribute | Groups | Contract | Use |
 | --- | --- | --- | --- |
 | `AREA` | `SHAPE` | Topology/support | Number of pixels in the full node support. |
-| `BOX_WIDTH` | `SHAPE` | Topology/support | Width, in columns, of the smallest axis-aligned bounding box enclosing the node support. |
+| `BOUNDING_BOX_WIDTH` | `SHAPE` | Topology/support | Width, in columns, of the smallest axis-aligned bounding box enclosing the node support. |
 | `BOUNDING_BOX_HEIGHT` | `SHAPE` | Topology/support | Height, in rows, of the smallest axis-aligned bounding box enclosing the node support. |
 | `DIAGONAL_LENGTH` | `SHAPE` | Topology/support | Euclidean diagonal length of the bounding box, `sqrt(width^2 + height^2)`. |
-| `RECTANGULARITY` | `SHAPE` | Topology/support | Ratio `AREA / (BOX_WIDTH * BOUNDING_BOX_HEIGHT)`. |
+| `RECTANGULARITY` | `SHAPE` | Topology/support | Ratio `AREA / (BOUNDING_BOX_WIDTH * BOUNDING_BOX_HEIGHT)`. |
 | `RATIO_WH` | `SHAPE` | Topology/support | Bounding-box aspect ratio, `max(width, height) / min(width, height)` for non-degenerate boxes. |
 | `BOX_COLUMN_MIN` | `SHAPE` | Topology/support | Minimum image column index covered by the node support. |
 | `BOX_COLUMN_MAX` | `SHAPE` | Topology/support | Maximum image column index covered by the node support. |
 | `BOX_ROW_MIN` | `SHAPE` | Topology/support | Minimum image row index covered by the node support. |
 | `BOX_ROW_MAX` | `SHAPE` | Topology/support | Maximum image row index covered by the node support. |
 
-`AREA` is the usual attribute for size filtering. A high `AREA` value means
-that the component represented by the node covers many pixels in the original
-image domain; it is not the number of children in the tree.
-
-These attributes are the most direct tools for area openings, size priors, and
-filters that should keep or remove elongated connected components.
-
 ## Distance-Transform Attributes
 
 These attributes describe distances from support pixels to the foreground

{mtlearn-1.2.0 → mtlearn-1.2.1}/docs/source/guides/custom-attributes-filter-specs.md

@@ -10,10 +10,11 @@ For the full attribute list, see {doc}`../concepts/attributes`.
 
 | Intent | Candidate attributes |
 | --- | --- |
+| Use the gray level associated with each node | `GRAY_LEVEL` |
 | Remove small components | `AREA`, `VOLUME` |
 | Prefer contrast in the tree | `GRAY_LEVEL_HEIGHT`, `RELATIVE_VOLUME` |
 | Prefer elongated or compact shapes | `COMPACTNESS`, `ECCENTRICITY`, `RATIO_WH` |
-| Use bounding-box geometry | `BOX_WIDTH`, `BOUNDING_BOX_HEIGHT`, `RECTANGULARITY` |
+| Use bounding-box geometry | `BOUNDING_BOX_WIDTH`, `BOUNDING_BOX_HEIGHT`, `RECTANGULARITY` |
 | Use tree position | `DEPTH_NODE`, `SUBTREE_HEIGHT`, `NUM_CHILDREN_NODE` |
 | Use contours | `CONTOUR_PERIMETER`, `CONTOUR_PIXELS` |
 

{mtlearn-1.2.0 → mtlearn-1.2.1}/mtlearn/bindings/morphology/AttributeBinding.hpp

@@ -38,7 +38,7 @@ inline const std::vector<morphology::Attribute>& allAttributes()
         morphology::Attribute::GrayLevelHeight,
         morphology::Attribute::MeanGrayLevel,
         morphology::Attribute::GrayLevelVariance,
-        morphology::Attribute::BoxWidth,
+        morphology::Attribute::BoundingBoxWidth,
         morphology::Attribute::BoundingBoxHeight,
         morphology::Attribute::DiagonalLength,
         morphology::Attribute::Rectangularity,
@@ -164,6 +164,7 @@ inline const std::vector<morphology::Attribute>& allAttributes()
         morphology::Attribute::FilledCentroidDisplacementNormalized,
         morphology::Attribute::FilledCompactness,
         morphology::Attribute::FilledCircularity,
+        morphology::Attribute::GrayLevel,
     };
     return attributes;
 }
@@ -173,18 +174,29 @@ inline const std::vector<morphology::Attribute>& allAttributes()
 // facade is introduced.
 inline std::string describeAttribute(morphology::Attribute attribute)
 {
+    if (attribute == morphology::Attribute::GrayLevel) {
+        return "Gray level: Node valuation (the gray level associated with the node).";
+    }
     return mmcfilters::AttributeNames::describe(toBackend(attribute));
 }
 
+inline std::string attributeName(mmcfilters::Attribute attribute)
+{
+    if (fromBackend(attribute) == morphology::Attribute::BoundingBoxWidth) {
+        return "BOUNDING_BOX_WIDTH";
+    }
+    return mmcfilters::AttributeNames::toString(attribute);
+}
+
 // Return all descriptions keyed by backend/public attribute name. Keeping the
 // names aligned with enum values makes the Python API easy to inspect.
 inline py::dict describeAllAttributes()
 {
     py::dict descriptions;
     for (const auto attribute : allAttributes()) {
-        const auto backendAttribute = toBackend(attribute);
-        descriptions[py::str(mmcfilters::AttributeNames::toString(backendAttribute))] =
-            py::str(mmcfilters::AttributeNames::describe(backendAttribute));
+        const auto name = attribute == morphology::Attribute::GrayLevel
+            ? std::string("GRAY_LEVEL") : attributeName(toBackend(attribute));
+        descriptions[py::str(name)] = py::str(describeAttribute(attribute));
     }
     return descriptions;
 }
@@ -203,6 +215,9 @@ inline std::vector<morphology::Attribute> expandAttributeGroup(morphology::Attri
     for (const auto attribute : it->second) {
         attributes.push_back(fromBackend(attribute));
     }
+    if (group == morphology::AttributeGroup::All || group == morphology::AttributeGroup::GrayLevel) {
+        attributes.push_back(morphology::Attribute::GrayLevel);
+    }
     return attributes;
 }
 
@@ -211,7 +226,11 @@ inline std::vector<morphology::Attribute> expandAttributeGroup(morphology::Attri
 // row count for the selected node-id space.
 inline int outputSize(const morphology::WeightedTree& tree, morphology::NodeIdSpace outputSpace)
 {
-    return morphology::detail::topology(tree).getNodeIdSpaceSize(toBackend(outputSpace));
+    const auto& topology = morphology::detail::topology(tree);
+    if (outputSpace == morphology::NodeIdSpace::Higra) {
+        return topology.numPixels() + topology.numNodes();
+    }
+    return topology.getNodeIdSpaceSize(toBackend(outputSpace));
 }
 
 // mmcfilters returns an attribute-name map that is not guaranteed to iterate in
@@ -225,7 +244,7 @@ inline py::dict sortedAttributeIndex(const mmcfilters::AttributeNames& attribute
     values.reserve(attributeNames.indexMap.size());
 
     for (const auto& item : attributeNames.indexMap) {
-        keys.push_back(attributeNames.toString(item.first));
+        keys.push_back(attributeName(item.first));
         values.push_back(item.second);
     }
 
@@ -242,6 +261,25 @@ inline py::dict sortedAttributeIndex(const mmcfilters::AttributeNames& attribute
     return result;
 }
 
+template <std::floating_point Real>
+std::vector<Real> computeGrayLevel(const morphology::WeightedTree& tree, morphology::NodeIdSpace outputSpace)
+{
+    const auto& valuedTree = morphology::detail::backend(tree);
+    if (outputSpace == morphology::NodeIdSpace::Higra) {
+        const auto [parents, altitudes] = valuedTree.exportHigraHierarchy();
+        return std::vector<Real>(altitudes.begin(), altitudes.end());
+    }
+    if (outputSpace != morphology::NodeIdSpace::MorphologicalTree) {
+        throw std::invalid_argument("unknown NodeIdSpace");
+    }
+    const auto& topology = morphology::detail::topology(tree);
+    std::vector<Real> values(topology.numInternalNodeSlots(), Real{0});
+    for (const auto node : topology.aliveNodeIds()) {
+        values[node] = static_cast<Real>(valuedTree.nodeAltitude(node));
+    }
+    return values;
+}
+
 template <std::floating_point Real>
 std::pair<py::dict, py::array> computeAttributesTyped(
     morphology::WeightedTreePtr tree,
@@ -252,16 +290,57 @@ std::pair<py::dict, py::array> computeAttributesTyped(
         throw py::value_error("invalid ValuedMorphologicalTree");
     }
 
-    const auto backendAttributes = toBackend(attributes);
-    auto [attributeNames, buffer] =
-        mmcfilters::AttributeComputation::computeAttributes<Real>(
-            morphology::detail::backend(*tree),
-            backendAttributes,
-            toBackend(outputSpace));
+    bool includeGrayLevel = false;
+    std::vector<mmcfilters::AttributeOrGroup> backendAttributes;
+    backendAttributes.reserve(attributes.size());
+    for (const auto& request : attributes) {
+        if (const auto* scalar = std::get_if<morphology::Attribute>(&request)) {
+            if (*scalar == morphology::Attribute::GrayLevel) {
+                includeGrayLevel = true;
+                continue;
+            }
+        } else {
+            const auto group = std::get<morphology::AttributeGroup>(request);
+            includeGrayLevel = includeGrayLevel || group == morphology::AttributeGroup::All
+                || group == morphology::AttributeGroup::GrayLevel;
+        }
+        backendAttributes.push_back(toBackend(request));
+    }
 
-    return {
-        sortedAttributeIndex(attributeNames),
-        vectorToNumpyOwned(std::move(buffer), outputSize(*tree, outputSpace), attributeNames.NUM_ATTRIBUTES)};
+    const int rows = outputSize(*tree, outputSpace);
+    py::dict layout;
+    std::vector<Real> buffer;
+    int columns = 0;
+    if (!backendAttributes.empty() || !includeGrayLevel) {
+        auto [attributeNames, values] =
+            mmcfilters::AttributeComputation::computeAttributes<Real>(
+                morphology::detail::backend(*tree), backendAttributes);
+        if (outputSpace == morphology::NodeIdSpace::Higra) {
+            values = mmcfilters::AttributeComputation::projectNodeValuesToExportedHigra<Real>(
+                morphology::detail::backend(*tree), attributeNames, values);
+        }
+        layout = sortedAttributeIndex(attributeNames);
+        columns = attributeNames.NUM_ATTRIBUTES;
+        buffer = std::move(values);
+    }
+    if (includeGrayLevel) {
+        auto grayLevel = computeGrayLevel<Real>(*tree, outputSpace);
+        layout["GRAY_LEVEL"] = columns;
+        if (columns == 0) {
+            buffer = std::move(grayLevel);
+        } else {
+            std::vector<Real> values(static_cast<std::size_t>(rows) * (columns + 1));
+            for (int row = 0; row < rows; ++row) {
+                const auto source = static_cast<std::size_t>(row) * columns;
+                const auto destination = static_cast<std::size_t>(row) * (columns + 1);
+                std::copy_n(buffer.begin() + source, columns, values.begin() + destination);
+                values[destination + columns] = grayLevel[row];
+            }
+            buffer = std::move(values);
+        }
+        ++columns;
+    }
+    return {std::move(layout), vectorToNumpyOwned(std::move(buffer), rows, columns)};
 }
 
 // Compute several attributes or attribute groups and return the pair used by
@@ -289,12 +368,18 @@ py::array computeSingleAttributeTyped(
         throw py::value_error("invalid ValuedMorphologicalTree");
     }
 
+    if (attribute == morphology::Attribute::GrayLevel) {
+        return vectorToNumpyOwned(computeGrayLevel<Real>(*tree, outputSpace), outputSize(*tree, outputSpace));
+    }
+
     auto [attributeNames, buffer] =
         mmcfilters::AttributeComputation::computeSingleAttribute<Real>(
             morphology::detail::backend(*tree),
-            toBackend(attribute),
-            toBackend(outputSpace));
-    (void)attributeNames;
+            toBackend(attribute));
+    if (outputSpace == morphology::NodeIdSpace::Higra) {
+        buffer = mmcfilters::AttributeComputation::projectNodeValuesToExportedHigra<Real>(
+            morphology::detail::backend(*tree), attributeNames, buffer);
+    }
 
     return vectorToNumpyOwned(std::move(buffer), outputSize(*tree, outputSpace));
 }
@@ -385,14 +470,14 @@ Returns:
         attribute,
         "Type",
         py::module_local(),
-        "Scalar morphology attributes supported by the current backend.")
+        "Scalar morphology attributes supported by mtlearn.")
         .value("AREA", morphology::Attribute::Area)
         .value("VOLUME", morphology::Attribute::Volume)
         .value("RELATIVE_VOLUME", morphology::Attribute::RelativeVolume)
         .value("GRAY_LEVEL_HEIGHT", morphology::Attribute::GrayLevelHeight)
         .value("MEAN_GRAY_LEVEL", morphology::Attribute::MeanGrayLevel)
         .value("GRAY_LEVEL_VARIANCE", morphology::Attribute::GrayLevelVariance)
-        .value("BOX_WIDTH", morphology::Attribute::BoxWidth)
+        .value("BOUNDING_BOX_WIDTH", morphology::Attribute::BoundingBoxWidth)
         .value("BOUNDING_BOX_HEIGHT", morphology::Attribute::BoundingBoxHeight)
         .value("RECTANGULARITY", morphology::Attribute::Rectangularity)
         .value("DIAGONAL_LENGTH", morphology::Attribute::DiagonalLength)
@@ -518,7 +603,13 @@ Returns:
         .value("FILLED_CENTROID_DISPLACEMENT_NORMALIZED", morphology::Attribute::FilledCentroidDisplacementNormalized)
         .value("FILLED_COMPACTNESS", morphology::Attribute::FilledCompactness)
         .value("FILLED_CIRCULARITY", morphology::Attribute::FilledCircularity)
+        .value("GRAY_LEVEL", morphology::Attribute::GrayLevel)
         .export_values();
+
+    attribute.attr("GRAY_LEVEL") = attribute.attr("Group").attr("GRAY_LEVEL");
+
+    attribute.attr("Type").attr("BOX_WIDTH") = attribute.attr("Type").attr("BOUNDING_BOX_WIDTH");
+    attribute.attr("BOX_WIDTH") = attribute.attr("BOUNDING_BOX_WIDTH");
 }
 
 } // namespace morphology_pybind

{mtlearn-1.2.0 → mtlearn-1.2.1}/mtlearn/bindings/morphology/BindingSupport.hpp

@@ -266,21 +266,21 @@ inline mmcfilters::AttributeGroup toBackend(morphology::AttributeGroup group)
 inline mmcfilters::Attribute toBackend(morphology::Attribute attribute)
 {
     switch (attribute) {
+    case morphology::Attribute::GrayLevel:
+        throw std::invalid_argument("GRAY_LEVEL is computed from the node valuation by mtlearn");
     case morphology::Attribute::Area:
         return mmcfilters::Attribute::Area;
     case morphology::Attribute::Volume:
         return mmcfilters::Attribute::Volume;
     case morphology::Attribute::RelativeVolume:
         return mmcfilters::Attribute::RelativeVolume;
-    // The backend dropped the plain node-altitude attribute, so the facade no
-    // longer publishes LEVEL/ALTITUDE either.
     case morphology::Attribute::GrayLevelHeight:
         return mmcfilters::Attribute::GrayLevelHeight;
     case morphology::Attribute::MeanGrayLevel:
         return mmcfilters::Attribute::MeanGrayLevel;
     case morphology::Attribute::GrayLevelVariance:
         return mmcfilters::Attribute::GrayLevelVariance;
-    case morphology::Attribute::BoxWidth:
+    case morphology::Attribute::BoundingBoxWidth:
         return mmcfilters::Attribute::BoxWidth;
     case morphology::Attribute::BoundingBoxHeight:
         return mmcfilters::Attribute::BoundingBoxHeight;
@@ -551,7 +551,7 @@ inline morphology::Attribute fromBackend(mmcfilters::Attribute attribute)
     MTLEARN_FROM_BACKEND_ATTRIBUTE(GrayLevelHeight, GrayLevelHeight);
     MTLEARN_FROM_BACKEND_ATTRIBUTE(MeanGrayLevel, MeanGrayLevel);
     MTLEARN_FROM_BACKEND_ATTRIBUTE(GrayLevelVariance, GrayLevelVariance);
-    MTLEARN_FROM_BACKEND_ATTRIBUTE(BoxWidth, BoxWidth);
+    MTLEARN_FROM_BACKEND_ATTRIBUTE(BoxWidth, BoundingBoxWidth);
     MTLEARN_FROM_BACKEND_ATTRIBUTE(BoundingBoxHeight, BoundingBoxHeight);
     MTLEARN_FROM_BACKEND_ATTRIBUTE(DiagonalLength, DiagonalLength);
     MTLEARN_FROM_BACKEND_ATTRIBUTE(Rectangularity, Rectangularity);

{mtlearn-1.2.0 → mtlearn-1.2.1}/mtlearn/include/mtlearn/morphology.hpp

@@ -61,7 +61,7 @@ enum class NodeIdSpace {
     Higra,              ///< Rows are indexed by exported Higra hierarchy ids.
 };
 
-/// Public attribute identifiers supported by the current morphology backend.
+/// Public attribute identifiers supported by the morphology facade.
 ///
 /// Keep this enum synchronized with the conversion table in
 /// `bindings/morphology/BindingSupport.hpp` and the Python exposure in
@@ -73,7 +73,8 @@ enum class Attribute {
     GrayLevelHeight,                  ///< Gray-level height.
     MeanGrayLevel,                   ///< Mean gray-level value.
     GrayLevelVariance,               ///< Gray-level variance.
-    BoxWidth,                    ///< Bounding-box width.
+    BoundingBoxWidth,            ///< Bounding-box width.
+    BoxWidth = BoundingBoxWidth,
     BoundingBoxHeight,                   ///< Bounding-box height.
     DiagonalLength,              ///< Bounding-box diagonal length.
     Rectangularity,               ///< Component rectangularity.
@@ -199,14 +200,15 @@ enum class Attribute {
     FilledCentroidDisplacementNormalized,
     FilledCompactness,
     FilledCircularity,
+    GrayLevel,                  ///< Node valuation (gray level).
 };
 
-/// Attribute groups expanded by the backend attribute computer.
+/// Attribute groups expanded by the morphology facade.
 ///
 /// Groups are part of the facade because Python notebooks and future C++
 /// consumers should not depend on backend attribute-group types directly.
 enum class AttributeGroup {
-    All,           ///< All public scalar attributes supported by the backend.
+    All,           ///< All public scalar attributes supported by the facade.
     GrayLevel,    ///< Gray-level attributes.
     Shape,         ///< Shape attributes.
     Moments,       ///< Moment-based attributes.

{mtlearn-1.2.0 → mtlearn-1.2.1}/mtlearn/python/mtlearn/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.0'
-__version_tuple__ = version_tuple = (1, 2, 0)
+__version__ = version = '1.2.1'
+__version_tuple__ = version_tuple = (1, 2, 1)
 
-__commit_id__ = commit_id = 'g1ddf531d3'
+__commit_id__ = commit_id = 'g1d6f21bf0'

{mtlearn-1.2.0 → mtlearn-1.2.1}/mtlearn/python/mtlearn/layers/cfp/normalization/stats_serializer.py

@@ -30,10 +30,15 @@ class StatsSerializer:
     ) -> dict[str, dict[str, Any]]:
         """Move serialized statistics to ``device`` for a CFP layer."""
         device = torch.device(device)
-        return {
-            str(key): {
+        result = {}
+        for key, stats in serialized.items():
+            key = str(key)
+            if key.endswith("::BOX_WIDTH"):
+                key = key.removesuffix("::BOX_WIDTH") + "::BOUNDING_BOX_WIDTH"
+            if key in result:
+                raise ValueError(f"duplicate dataset statistics for {key}")
+            result[key] = {
                 name: value.to(device) if torch.is_tensor(value) else value
                 for name, value in stats.items()
             }
-            for key, stats in serialized.items()
-        }
+        return result

mtlearn-1.2.1/mtlearn/tests/python/cfp_reference_names.py

@@ -0,0 +1,12 @@
+import re
+
+
+def canonical_reference_names(value):
+    if isinstance(value, str):
+        return re.sub(r"(?<![A-Z0-9_])BOX_WIDTH(?![A-Z0-9_])", "BOUNDING_BOX_WIDTH", value)
+    if isinstance(value, dict):
+        return {canonical_reference_names(key): canonical_reference_names(item)
+                for key, item in value.items()}
+    if isinstance(value, (tuple, list)):
+        return type(value)(canonical_reference_names(item) for item in value)
+    return value

{mtlearn-1.2.0 → mtlearn-1.2.1}/mtlearn/tests/python/test_cfp_cache_baseline.py

@@ -11,6 +11,8 @@ from pathlib import Path
 import pytest
 import torch
 
+from cfp_reference_names import canonical_reference_names
+
 import mtlearn
 from mtlearn.layers import ConnectedFilterPreprocessingLayer, load_checkpoint
 
@@ -25,7 +27,7 @@ CASE_NAMES = MANIFEST['cases']
 
 @pytest.fixture(scope='module')
 def reference():
-    return torch.load(FIXTURES / 'baseline.pt', map_location='cpu', weights_only=True)
+    return canonical_reference_names(torch.load(FIXTURES / 'baseline.pt', map_location='cpu', weights_only=True))
 
 
 def assert_nested_close(actual, expected):

{mtlearn-1.2.0 → mtlearn-1.2.1}/mtlearn/tests/python/test_cfp_disk_cache.py

@@ -11,6 +11,8 @@ import weakref
 import numpy as np
 import pytest
 import torch
+
+from cfp_reference_names import canonical_reference_names
 from torch.utils.data import DataLoader, Subset, TensorDataset
 
 import mtlearn
@@ -32,7 +34,7 @@ QUOTA = 32 * 1024**2
 
 @pytest.fixture(scope="module")
 def baseline():
-    return torch.load(FIXTURES / "baseline.pt", map_location="cpu", weights_only=True)
+    return canonical_reference_names(torch.load(FIXTURES / "baseline.pt", map_location="cpu", weights_only=True))
 
 
 def model(*, mode="dataset_clipped_zscore01", scoring="linear_sigmoid", attrs=(AREA, HEIGHT), dtype=np.float32):

{mtlearn-1.2.0 → mtlearn-1.2.1}/mtlearn/tests/python/test_cfp_preparation.py

@@ -7,6 +7,8 @@ import weakref
 
 import pytest
 import torch
+
+from cfp_reference_names import canonical_reference_names
 from torch.utils.data import DataLoader, TensorDataset
 
 import mtlearn
@@ -27,7 +29,7 @@ MANIFEST = json.loads((FIXTURES / "manifest.json").read_text())
 
 @pytest.fixture(scope="module")
 def baseline():
-    return torch.load(FIXTURES / "baseline.pt", weights_only=True, map_location="cpu")
+    return canonical_reference_names(torch.load(FIXTURES / "baseline.pt", weights_only=True, map_location="cpu"))
 
 
 def loader(images, *, batch_size=2, **kwargs):

{mtlearn-1.2.0 → mtlearn-1.2.1}/mtlearn/tests/python/test_cfp_prepared_runtime.py

@@ -10,6 +10,8 @@ import numpy as np
 import pytest
 import torch
 
+from cfp_reference_names import canonical_reference_names
+
 import mtlearn
 from mtlearn import morphology
 from mtlearn.layers import ConnectedFilterPreprocessingLayer as Layer, load_checkpoint
@@ -27,7 +29,7 @@ AREA, HEIGHT = morphology.AttributeType.AREA, morphology.AttributeType.GRAY_LEVE
 
 @pytest.fixture(scope="module")
 def baseline():
-    return torch.load(FIXTURES / "baseline.pt", weights_only=True, map_location="cpu")
+    return canonical_reference_names(torch.load(FIXTURES / "baseline.pt", weights_only=True, map_location="cpu"))
 
 
 def model(*, channels=1, scoring="linear_sigmoid", mode="none", attrs=(AREA, HEIGHT), tree="max-tree", **kwargs):

{mtlearn-1.2.0 → mtlearn-1.2.1}/mtlearn/tests/python/test_morphology_api.py

@@ -468,7 +468,7 @@ def test_attribute_enum_names_match_the_catalog_without_aliases():
     descriptions = morphology.describe_all_attributes()
     members = morphology.AttributeType.__members__
 
-    assert len(members) == len(descriptions) == 132
+    assert len(members) == len(descriptions) == 133
     assert set(members) == set(descriptions)
     for name, value in members.items():
         assert value.name == name

{mtlearn-1.2.0 → mtlearn-1.2.1}/mtlearn/tests/python/test_morphology_attribute_groups.py

@@ -45,7 +45,7 @@ def test_distance_and_filled_shape_groups_match_scalar_attributes(
 def test_attribute_catalog_contains_all_distance_and_filled_shape_attributes():
     descriptions = morphology.describe_all_attributes()
     attributes = morphology.expand_attribute_group(morphology.AttributeGroup.ALL)
-    assert len(attributes) == len(set(attributes)) == len(descriptions) == 132
+    assert len(attributes) == len(set(attributes)) == len(descriptions) == 133
     names = set()
     for group_name, _ in GROUPS:
         names.update(attribute.name for attribute in morphology.expand_attribute_group(

mtlearn-1.2.1/mtlearn/tests/python/test_morphology_bounding_box_width.py

@@ -0,0 +1,64 @@
+import pickle
+import re
+
+import numpy as np
+import pytest
+
+from mtlearn import morphology
+
+
+def test_bounding_box_width_alias_uses_canonical_name():
+    attribute = morphology.AttributeType.BOUNDING_BOX_WIDTH
+    assert morphology.AttributeType.BOX_WIDTH is attribute
+    assert morphology.Attribute.BOX_WIDTH is attribute
+    assert attribute.name == "BOUNDING_BOX_WIDTH"
+    assert int(attribute) == 6
+    assert pickle.loads(pickle.dumps(morphology.AttributeType.BOX_WIDTH)) == attribute
+    assert "BOX_WIDTH" not in morphology.AttributeType.__members__
+    assert not re.search(r"\bBOX_WIDTH\b", morphology.AttributeType.__doc__)
+    descriptions = morphology.describe_all_attributes()
+    assert "BOX_WIDTH" not in descriptions
+    assert descriptions[attribute.name] == morphology.describe_attribute(attribute)
+    attributes = morphology.expand_attribute_group(morphology.AttributeGroup.SHAPE)
+    assert attributes.count(attribute) == 1
+    assert "BOX_WIDTH" not in {value.name for value in attributes}
+
+
+@pytest.mark.parametrize("tree_type", ["max-tree", "min-tree"])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_bounding_box_width_alias_computes_canonical_columns(tree_type, dtype):
+    image = np.zeros((5, 7), dtype=np.uint8)
+    image[1:4, 1:6] = 200
+    if tree_type == "min-tree":
+        image = 255 - image
+    tree = morphology.build_tree(image, tree_type)
+    node = tree.smallest_node(2 * 7 + 3)
+    attribute = morphology.AttributeType.BOUNDING_BOX_WIDTH
+    expected = morphology.compute_single_attribute(tree, attribute, dtype=dtype)
+    assert expected[node] == 5
+    for requested in [attribute, morphology.AttributeType.BOX_WIDTH]:
+        values = morphology.compute_single_attribute(tree, requested, dtype=dtype)
+        np.testing.assert_array_equal(values, expected)
+        layout, values = morphology.compute_attributes(tree, [requested], dtype=dtype)
+        assert layout == {"BOUNDING_BOX_WIDTH": 0}
+        np.testing.assert_array_equal(values[:, 0], expected)
+    layout, values = morphology.compute_attributes(
+        tree, [morphology.AttributeGroup.SHAPE], dtype=dtype
+    )
+    assert "BOX_WIDTH" not in layout
+    np.testing.assert_array_equal(values[:, layout[attribute.name]], expected)
+
+
+def test_bounding_box_width_legacy_statistics_are_canonicalized():
+    import torch
+    from mtlearn.layers.cfp.normalization.stats_serializer import StatsSerializer
+
+    key = "max-tree|None|0|0"
+    stats = {"amin": torch.tensor(1.0), "amax": torch.tensor(7.0)}
+    restored = StatsSerializer.deserialize({key + "::BOX_WIDTH": stats}, device="cpu")
+    assert set(restored) == {key + "::BOUNDING_BOX_WIDTH"}
+    for name, value in stats.items():
+        torch.testing.assert_close(restored[key + "::BOUNDING_BOX_WIDTH"][name], value)
+    with pytest.raises(ValueError, match="duplicate dataset statistics"):
+        StatsSerializer.deserialize({key + "::BOX_WIDTH": stats,
+                                     key + "::BOUNDING_BOX_WIDTH": stats}, device="cpu")