EventEngine.hpp

#pragma once
 
#include "../trees/MorphologicalTree.hpp"
#include "../trees/detail/ProperPartEntryNode.hpp"
#include "../utils/Common.hpp"
 
#include <algorithm>
#include <cstdint>
#include <stdexcept>
#include <utility>
#include <vector>
 
namespace mmcfilters::local_events {
 
class EventEngine {
public:
    struct WindowOffset {
        int rowOffset = 0;
 
        int colOffset = 0;
    };
 
private:
    struct EntryEvent {
        NodeId node = InvalidNode;
        uint32_t mask = 0;
    };
 
public:
    static NodeId entryNode(const MorphologicalTree& tree, int anchorPixel, int samplePixel) {
        return detail::properPartEntryNode(tree, anchorPixel, samplePixel);
    }
 
    static NodeId entryNode(const MorphologicalTree& tree, int anchorPixel, WindowOffset offset) {
        const int rows = tree.getNumRowsOfImage();
        const int cols = tree.getNumColsOfImage();
        if (rows <= 0 || cols <= 0) {
            return InvalidNode;
        }
        if (anchorPixel < 0 || anchorPixel >= rows * cols) {
            return InvalidNode;
        }
 
        const auto [row, col] = ImageUtils::to2D(anchorPixel, cols);
        const int sampleRow = row + offset.rowOffset;
        const int sampleCol = col + offset.colOffset;
        if (sampleRow < 0 || sampleRow >= rows || sampleCol < 0 || sampleCol >= cols) {
            return InvalidNode;
        }
 
        return entryNode(tree, anchorPixel, ImageUtils::to1D(sampleRow, sampleCol, cols));
    }
 
    template<class Policy>
    static std::vector<typename Policy::Bucket> computeDeltasWithPolicy(
        const MorphologicalTree& tree,
        const std::vector<WindowOffset>& window,
        const Policy& policy) {
        requireValidInput(tree, window);
 
        std::vector<typename Policy::Bucket> buckets(
            static_cast<std::size_t>(tree.getNumInternalNodeSlots()));
        std::vector<EntryEvent> events;
        events.reserve(window.size());
 
        const int totalPixels = tree.getNumRowsOfImage() * tree.getNumColsOfImage();
        for (int anchorPixel = 0; anchorPixel < totalPixels; ++anchorPixel) {
            events.clear();
            for (std::size_t i = 0; i < window.size(); ++i) {
                const NodeId entry = entryNode(tree, anchorPixel, window[i]);
                if (entry != InvalidNode) {
                    events.push_back({entry, uint32_t{1} << i});
                }
            }
            if (events.empty()) {
                continue;
            }
 
            sortEventsBottomUp(tree, events);
 
            uint32_t state = 0;
            bool hasPreviousState = false;
            for (std::size_t i = 0; i < events.size();) {
                const NodeId eventNode = events[i].node;
                uint32_t eventMask = 0;
                do {
                    eventMask |= events[i].mask;
                    ++i;
                } while (i < events.size() && events[i].node == eventNode);
 
                const uint32_t oldState = state;
                state |= eventMask;
                auto& bucket = buckets[static_cast<std::size_t>(eventNode)];
                if (!hasPreviousState) {
                    policy.applyInitial(bucket, state);
                    hasPreviousState = true;
                } else {
                    policy.applyTransition(bucket, oldState, state);
                }
            }
        }
 
        return buckets;
    }
 
    template<class Policy>
    static std::vector<typename Policy::Bucket> computeWithPolicy(
        const MorphologicalTree& tree,
        const std::vector<WindowOffset>& window,
        const Policy& policy) {
        std::vector<typename Policy::Bucket> buckets =
            computeDeltasWithPolicy(tree, window, policy);
        aggregateSubtreeBuckets(tree, buckets, policy);
        return buckets;
    }
 
private:
    static void requireValidInput(const MorphologicalTree& tree, const std::vector<WindowOffset>& window) {
        if (tree.getNumRowsOfImage() <= 0 || tree.getNumColsOfImage() <= 0) {
            throw std::invalid_argument("EventEngine requires a non-empty image domain.");
        }
        if (!tree.isAlive(tree.getRoot())) {
            throw std::invalid_argument("EventEngine requires a live tree root.");
        }
        if (window.size() > 32) {
            throw std::invalid_argument("EventEngine supports at most 32 window samples.");
        }
    }
 
    static void sortEventsBottomUp(const MorphologicalTree& tree, std::vector<EntryEvent>& events) {
        std::sort(events.begin(), events.end(), [&](const EntryEvent& lhs, const EntryEvent& rhs) {
            if (lhs.node == rhs.node) {
                return false;
            }
            if (tree.isStrictAncestor(lhs.node, rhs.node)) {
                return false;
            }
            if (tree.isStrictAncestor(rhs.node, lhs.node)) {
                return true;
            }
            return lhs.node < rhs.node;
        });
    }
 
    template<class Bucket, class Policy>
    static void aggregateSubtreeBuckets(
        const MorphologicalTree& tree,
        std::vector<Bucket>& values,
        const Policy& policy) {
        std::vector<std::pair<NodeId, bool>> stack;
        stack.emplace_back(tree.getRoot(), false);
 
        while (!stack.empty()) {
            const auto [node, expanded] = stack.back();
            stack.pop_back();
            if (!expanded) {
                stack.emplace_back(node, true);
                for (NodeId child : tree.getChildren(node)) {
                    stack.emplace_back(child, false);
                }
                continue;
            }
 
            for (NodeId child : tree.getChildren(node)) {
                policy.merge(values[static_cast<std::size_t>(node)], values[static_cast<std::size_t>(child)]);
            }
        }
    }
};
 
using WindowOffset = EventEngine::WindowOffset;
 
} // namespace mmcfilters::local_events