MorphologicalTreeFactory.hpp

#pragma once
 
#include "MorphologicalTree.hpp"
#include "TreeOfShapesBuilder.hpp"
#include "TreeAltitudeAlgorithms.hpp"
#include "ValuedMorphologicalTree.hpp"
#include "ComponentTreeBuilder.hpp"
#include "ExtremumResidualTreeByCTsBuilder.hpp"
#include "detail/HigraHierarchyDetail.hpp"
#include "detail/MorphologicalTreeConstructionTag.hpp"
#include "../utils/Image.hpp"
#include "../utils/Contract.hpp"
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <span>
#include <utility>
#include <vector>
 
namespace mmcfilters {
 
class MorphologicalTreeFactory {
  private:
    template <AltitudeValue T> static void validateComponentTreeImage(const ImagePtr<T>& img, const char* context) {
        MMCFILTERS_CONTRACT_REQUIRE(img != nullptr, throw std::invalid_argument(std::string(context) + " requires a non-null image."));
        MMCFILTERS_CONTRACT_REQUIRE(img->getNumRows() > 0 && img->getNumColumns() > 0 && img->getSize() > 0,
                                    throw std::invalid_argument(std::string(context) + " requires a non-empty 2D image."));
        MMCFILTERS_CONTRACT_CHECKED_ONLY(TreeAltitudeAlgorithms::validateFiniteImageAltitudes(img, context));
    }
 
    static void validateTreeOfShapesImage(const ImageUInt8Ptr& img) {
        if (!img) {
            throw std::invalid_argument("MorphologicalTreeFactory::createTreeOfShapes requires a non-null image.");
        }
        if (img->getNumRows() <= 0 || img->getNumColumns() <= 0 || img->getSize() <= 0) {
            throw std::invalid_argument("MorphologicalTreeFactory::createTreeOfShapes requires a non-empty 2D image.");
        }
    }
 
  public:
    template <AltitudeValue T> [[nodiscard]] static ValuedMorphologicalTree<T> createMaxTree(ImagePtr<T> img, double radius = 1.5) {
        validateComponentTreeImage(img, "MorphologicalTreeFactory::createMaxTree");
        RegularGridAdjacency2D adjacency(img->getNumRows(), img->getNumColumns(), radius);
        return detail::materializeNativeHierarchy<T>(
            ComponentTreeBuilder(std::move(adjacency), true).build(img), std::nullopt,
            detail::MaterializedVersionPolicy::PreserveLinkedConstruction);
    }
 
    template <AltitudeValue T> [[nodiscard]] static ValuedMorphologicalTree<T> createMaxTree(ImagePtr<T> img, RegularGridAdjacency2D adjacency) {
        validateComponentTreeImage(img, "MorphologicalTreeFactory::createMaxTree");
        MMCFILTERS_CONTRACT_REQUIRE(adjacency.getNumRows() == img->getNumRows() && adjacency.getNumColumns() == img->getNumColumns(),
                                    throw std::invalid_argument("Component-tree adjacency domain must match the input image domain."));
        return detail::materializeNativeHierarchy<T>(
            ComponentTreeBuilder(std::move(adjacency), true).build(img), std::nullopt,
            detail::MaterializedVersionPolicy::PreserveLinkedConstruction);
    }
 
    template <AltitudeValue T> [[nodiscard]] static ValuedMorphologicalTree<T> createMinTree(ImagePtr<T> img, double radius = 1.5) {
        validateComponentTreeImage(img, "MorphologicalTreeFactory::createMinTree");
        RegularGridAdjacency2D adjacency(img->getNumRows(), img->getNumColumns(), radius);
        return detail::materializeNativeHierarchy<T>(
            ComponentTreeBuilder(std::move(adjacency), false).build(img), std::nullopt,
            detail::MaterializedVersionPolicy::PreserveLinkedConstruction);
    }
 
    template <AltitudeValue T> [[nodiscard]] static ValuedMorphologicalTree<T> createMinTree(ImagePtr<T> img, RegularGridAdjacency2D adjacency) {
        validateComponentTreeImage(img, "MorphologicalTreeFactory::createMinTree");
        MMCFILTERS_CONTRACT_REQUIRE(adjacency.getNumRows() == img->getNumRows() && adjacency.getNumColumns() == img->getNumColumns(),
                                    throw std::invalid_argument("Component-tree adjacency domain must match the input image domain."));
        return detail::materializeNativeHierarchy<T>(
            ComponentTreeBuilder(std::move(adjacency), false).build(img), std::nullopt,
            detail::MaterializedVersionPolicy::PreserveLinkedConstruction);
    }
 
    template <AltitudeValue T>
    [[nodiscard]] static ValuedMorphologicalTree<T>
    createExtremumResidualTree(ImagePtr<T> img, RegularGridAdjacency2D adjacency) {
        return createExtremumResidualTreeByCTs(std::move(img), std::move(adjacency));
    }
 
    template <AltitudeValue T>
    [[nodiscard]] static ValuedMorphologicalTree<T>
    createExtremumResidualTree(ImagePtr<T> img, double radius = 1.5) {
        return createExtremumResidualTreeByCTs(std::move(img), radius);
    }
 
    template <AltitudeValue T>
    [[nodiscard]] static ValuedMorphologicalTree<T>
    createExtremumResidualTreeByCTs(ImagePtr<T> img, RegularGridAdjacency2D adjacency) {
        ExtremumResidualTreeByCTsBuilder<T> builder(std::move(adjacency));
        return detail::materializeNativeHierarchy<T>(builder.build(img));
    }
 
    template <AltitudeValue T>
    [[nodiscard]] static ValuedMorphologicalTree<T>
    createExtremumResidualTreeByCTs(ImagePtr<T> img, double radius = 1.5) {
        RegularGridAdjacency2D adjacency(img->getNumRows(), img->getNumColumns(), radius);
        return createExtremumResidualTreeByCTs(std::move(img), std::move(adjacency));
    }
 
    template <class Altitude = std::uint8_t>
    [[nodiscard]] static ValuedMorphologicalTree<Altitude> createTreeOfShapes(ImageUInt8Ptr img, TopographicConvention convention = {}) {
        validateTreeOfShapesImage(img);
        TreeOfShapesBuilder builder(std::move(convention));
        return detail::materializeNativeHierarchy<Altitude>(std::move(builder).build<Altitude>(img));
    }
 
    template <AltitudeValue T>
    [[nodiscard]] static ValuedMorphologicalTree<T> createFromHigraParent(std::span<const NodeId> parent, std::span<const T> nodeAltitudes, int rows,
                                                                            int columns, MorphologicalTreeKind kind,
                                                                            std::optional<RegularGridAdjacency2D> adjacency = std::nullopt) {
        auto imported = detail::adaptHigraHierarchy<T>(parent, nodeAltitudes, rows, columns, kind, std::move(adjacency));
        return detail::materializeNativeHierarchy<T>(std::move(imported.hierarchy), imported.internalNodeOffset,
                                                     detail::MaterializedVersionPolicy::PreserveLinkedConstruction);
    }
};
 
} // namespace mmcfilters