morphoTreeAdjust 0.1.8__tar.gz → 0.2__tar.gz

{morphotreeadjust-0.1.8 → morphotreeadjust-0.2}/CMakeLists.txt

@@ -9,6 +9,7 @@ project(MorphoTreeAdjust LANGUAGES CXX)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 # Define build padrão, se não for especificado
 if(NOT CMAKE_BUILD_TYPE)

morphotreeadjust-0.2/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md LICENSE CMakeLists.txt pybind11.cmake
+recursive-include morphoTreeAdjust *.cpp *.hpp *.tpp
+recursive-include python *.py

{morphotreeadjust-0.1.8/morphoTreeAdjust.egg-info → morphotreeadjust-0.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: morphoTreeAdjust
-Version: 0.1.8
+Version: 0.2
 Summary: MorphoTreeAdjust is a C++/Python implementation for adjusting the morpholofical trees.
 Home-page: https://github.com/wonderalexandre/ComponentTreeLearn
 Author: Wonder Alexandre Luz Alves
@@ -13,3 +13,15 @@ Classifier: Topic :: Scientific/Engineering :: Image Processing
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: C++
 License-File: LICENSE
+Provides-Extra: viz
+Requires-Dist: numpy; extra == "viz"
+Requires-Dist: matplotlib; extra == "viz"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: summary

{morphotreeadjust-0.1.8 → morphotreeadjust-0.2}/README.md

@@ -16,4 +16,4 @@ Problem:
 > [Click here and see a demo on jupyter notebook](./notebooks/morphoTreeAdjust_example_leaf.ipynb)
 
 ### Paper:
-> Alves, W. A. L., Passat, N., Silva, D. J., Morimitsu, A., & Hashimoto, R. F. (2025). *Efficient connected alternating sequential filters based on component trees*. Paper submitted to the 4th International Conference on Discrete Geometry and Mathematical Morphology (DGMM 2025).
+> Wonder Alves, Nicolas Passat, Dênnis José da Silva, Alexandre Morimitsu, Ronaldo F. Hashimoto. *Efficient connected alternating sequential filters based on component trees*. International Conference on Discrete Geometry and Mathematical Morphology (DGMM), Nov 2025, Groningen, Netherlands. ⟨[hal-05163556](https://hal.science/hal-05163556/)⟩

morphotreeadjust-0.2/morphoTreeAdjust/include/AdjacencyRelation.hpp

@@ -0,0 +1,147 @@
+
+#include <list>
+#include <vector>
+#include "../include/Common.hpp"
+
+#ifndef ADJACENCY_H
+#define ADJACENCY_H
+
+class AdjacencyRelation;  // forward declaration
+using AdjacencyRelationPtr = std::shared_ptr<AdjacencyRelation>;
+
+/**
+ * @brief Relação de adjacência em grade 2D com raio arbitrário e iteração eficiente.
+ *
+ * Define offsets de vizinhança para uma janela de raio real (ex.: 1.0 → 4-adj, 1.5 → 8-adj),
+ * provendo utilitários para listar vizinhos de um pixel e iterar por eles com um iterador leve.
+ * Também oferece uma variação "forward" que emite somente metade dos vizinhos (sem simetria),
+ * útil para varreduras assimétricas e construção de arestas únicas.
+ */
+class AdjacencyRelation {
+private:
+    int id;
+    
+    int row;
+    int col;    
+    int numCols;
+    int numRows;
+    double radius;
+    double radius2;
+    int n;
+    bool forwardOnly = false; //meia 
+
+    std::vector<int> offsetRow;
+    std::vector<int> offsetCol;
+    std::vector<uint8_t> forwardMask;// máscara “forward” por offset i: true se (dy>0) || (dy==0 && dx>0)
+
+
+public:
+    /**
+     * @brief Constrói uma relação de adjacência para imagem `numRows`×`numCols`.
+     * @param numRows Número de linhas da imagem.
+     * @param numCols Número de colunas da imagem.
+     * @param radius Raio da vizinhança (1.0 ≈ 4-conexão, 1.5 ≈ 8-conexão).
+     */
+    AdjacencyRelation(int numRows, int numCols, double radius);
+    /**
+     * @brief Avança para o próximo offset válido conforme os limites e máscara.
+     * @return Índice do próximo offset válido, ou tamanho para fim.
+     */
+    int nextValid();
+    /**
+     * @brief Retorna a quantidade de offsets no stencil atual.
+     */
+    int getSize();
+    /**
+     * @brief Configura (row,col) e prepara iteração de adjacentes sem filtro forward. Esse método incluí a origem.
+     */
+    AdjacencyRelation& getAdjPixels(int row, int col);
+    /**
+     * @brief Configura por índice linear e prepara iteração de adjacentes sem filtro. Esse método incluí a origem.
+     */
+    AdjacencyRelation& getAdjPixels(int index);
+    /**
+     * @brief Configura (row,col) e prepara iteração de vizinhos dentro dos limites. Esse método NÃO incluí a origem.
+     */
+    AdjacencyRelation& getNeighborPixels(int row, int col);
+    /**
+     * @brief Configura por índice linear e prepara iteração de vizinhos dentro dos limites. Esse método NÃO incluí a origem.
+     */
+    AdjacencyRelation& getNeighborPixels(int index);
+    /**
+     * @brief Prepara iteração apenas sobre metade dos vizinhos (forward-only) em (row,col).
+     * @note Útil para gerar pares (p,q) sem duplicação (p→q, nunca q→p).
+     */
+    AdjacencyRelation& getNeighborPixelsForward(int row, int col);
+    /**
+     * @brief Versão por índice linear de `getNeighborPixelsForward`.
+     */
+    AdjacencyRelation& getNeighborPixelsForward(int index);
+
+    /**
+     * @brief Verifica adjacência por índices lineares (p,q).
+     */
+    inline bool isAdjacent(int p, int q)const noexcept;
+    /**
+     * @brief Verifica adjacência por coordenadas (px,py) e (qx,qy).
+     */
+    inline bool isAdjacent(int px, int py, int qx, int qy) const noexcept;
+    /**
+     * @brief Retorna o raio em uso.
+     */
+    double getRadius();
+
+    int getOffsetRow(int index){
+        return offsetRow[index];
+    }
+    int getOffsetCol(int index){
+        return offsetCol[index];
+    }
+    
+    /**
+     * @brief Iterador leve para percorrer vizinhos já configurados via `get*`.
+     *
+     * Produz índices lineares de pixels vizinhos válidos, respeitando os limites e,
+     * quando configurado, a máscara forward-only.
+     */
+    class IteratorAdjacency { 
+    private:
+        int index;
+        AdjacencyRelation* instance; 
+
+    public:
+        using iterator_category = std::input_iterator_tag;
+        using value_type = int;
+
+        IteratorAdjacency(AdjacencyRelation* obj, int id) :  index(id), instance(obj) { }
+
+        AdjacencyRelation* getInstance() { return instance; } 
+
+        IteratorAdjacency& operator++() { 
+            this->index = instance->nextValid();  
+            return *this; 
+        }
+
+        bool operator==(const IteratorAdjacency& other) const { 
+            return index == other.index; 
+        }
+        bool operator!=(const IteratorAdjacency& other) const { 
+            return !(*this == other);
+        }
+
+        int operator*() const { 
+            return (instance->row + instance->offsetRow[index]) * instance->numCols + (instance->col + instance->offsetCol[index]); 
+        }
+    };
+    /**
+     * @brief Início da iteração de vizinhos conforme configuração atual.
+     */
+    IteratorAdjacency begin();
+    /**
+     * @brief Marcador de fim da iteração de vizinhos.
+     */
+   IteratorAdjacency end();	 
+};
+
+
+#endif