morphoTreeAdjust 0.1__tar.gz → 0.1.2__tar.gz

{morphotreeadjust-0.1 → morphotreeadjust-0.1.2}/CMakeLists.txt

@@ -22,7 +22,7 @@ project(morphoTreeAdjust)
 include_directories("${CMAKE_SOURCE_DIR}/python")
 
 file (GLOB SOURCE_FILES "morphoTreeAdjust/src/*.cpp" "morphoTreeAdjust/pybind/*.cpp")
-file (GLOB HEADER_FILES "morphoTreeAdjust/include/*.hpp" "morphoTreeAdjust/pybind/*.hpp")
+file (GLOB HEADER_FILES "morphoTreeAdjust/include/*.hpp" "morphoTreeAdjust/include/*.tpp" "morphoTreeAdjust/pybind/*.hpp")
 file (GLOB PYTHON_FILES "morphoTreeAdjust/*.cpp" "morphoTreeAdjust/*.hpp")
 
 # Set up such that XCode organizes the files

{morphotreeadjust-0.1/morphoTreeAdjust.egg-info → morphotreeadjust-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: morphoTreeAdjust
-Version: 0.1
+Version: 0.1.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

{morphotreeadjust-0.1 → morphotreeadjust-0.1.2}/morphoTreeAdjust/CMakeLists.txt

@@ -38,15 +38,15 @@ set(PROJECT_INCLUDE_DIR "include")
 # Source files
 set(SOURCE_FILES
     ${PROJECT_INCLUDE_DIR}/NodeCT.hpp
-    ${PROJECT_SOURCE_DIR}/NodeCT.cpp
+    ${PROJECT_SOURCE_DIR}/NodeCT.tpp
     ${PROJECT_INCLUDE_DIR}/ComponentTree.hpp
-    ${PROJECT_SOURCE_DIR}/ComponentTree.cpp
+    ${PROJECT_SOURCE_DIR}/ComponentTree.tpp
     ${PROJECT_INCLUDE_DIR}/AdjacencyRelation.hpp
     ${PROJECT_SOURCE_DIR}/AdjacencyRelation.cpp
     ${PROJECT_INCLUDE_DIR}/ComponentTreeAdjustment.hpp
     ${PROJECT_SOURCE_DIR}/ComponentTreeAdjustment.cpp
     ${PROJECT_PYBIND_DIR}/PyBindComponentTree.hpp
-    ${PROJECT_PYBIND_DIR}/PyBindComponentTree.cpp
+    ${PROJECT_PYBIND_DIR}/PyBindComponentTree.tpp
     ${PROJECT_PYBIND_DIR}/PyBindComponentTreeAdjustment.hpp
     ${PROJECT_PYBIND_DIR}/PyBindComponentTreeAdjustment.cpp
     

{morphotreeadjust-0.1 → morphotreeadjust-0.1.2}/morphoTreeAdjust/include/AdjacencyRelation.hpp

@@ -1,6 +1,7 @@
 
 #include <list>
 #include <vector>
+#include "../include/Common.hpp"
 
 #ifndef ADJACENCY_H
 #define ADJACENCY_H
@@ -13,6 +14,7 @@ private:
     int col;    
     int numCols;
     int numRows;
+    int radius;
     int n;
  
     int *offsetRow;
@@ -28,11 +30,13 @@ public:
     int getSize();
     AdjacencyRelation& getAdjPixels(int row, int col);
     AdjacencyRelation& getAdjPixels(int index);
-
+    bool isAdjacent(int p, int q);
+    bool isAdjacent(int px, int py, int qx, int qy);
+    double getRadius();
     class IteratorAdjacency { 
     private:
         int index;
-        AdjacencyRelation* instance; // Agora usamos um ponteiro
+        AdjacencyRelation* instance; 
 
     public:
         using iterator_category = std::input_iterator_tag;

morphotreeadjust-0.1.2/morphoTreeAdjust/include/Common.hpp

@@ -0,0 +1,57 @@
+#ifndef COMMONS_HPP  
+#define COMMONS_HPP  
+
+
+#define NDEBUG  // Remove os asserts do código
+#include <cassert>
+#include <list>
+#include <unordered_set>
+#include <unordered_map>
+#include <queue>
+#include <memory>
+#include <limits>
+
+#define PRINT_LOG 1 
+
+#define PRINT_DEBUG 0 
+
+// Forward declaration dos templates
+template <typename T>
+class ComponentTree;
+
+template <typename T>
+class NodeCT;
+
+// Definição de tipos para CNPs
+using Pixels = std::list<int>;                 // Representa uma lista de pixels (CNPs)
+using FlatZone = std::list<int>;                 // Representa uma flatzone
+using FlatZones = std::unordered_map<int, FlatZone>;   // Representa uma lista de flatzones (CNPs ficarão separados em flatzones)
+
+//Alias em função do tipo dos CNPs
+using FlatZoneRef = std::reference_wrapper<FlatZone>;   // Representa uma flatzone
+using FlatZonesRef = std::list<FlatZoneRef>;   // Representa uma lista de flatzones
+using ComponentTreeFZ = ComponentTree<FlatZones>; //representa um component tree por flatzones
+using ComponentTreeP = ComponentTree<Pixels>; //representa um component tree sem tratamento de flatzones
+using NodeFZ = NodeCT<FlatZones>; //representa um node com separação dos cnps em flatzones
+using NodeP = NodeCT<Pixels>; //representa um node sem tratamento de flatzones
+
+using FlatzoneGraph = std::unordered_set<int>**;
+using AdjacentFlatzones = std::unordered_set<int>;
+
+
+struct FlatZoneNode {
+    NodeFZ* node = nullptr;
+    FlatZone* flatzone = nullptr;
+    int idFlatZone;
+
+    FlatZoneNode(){}
+
+    // Construtor para mover a FlatZone
+    FlatZoneNode(NodeFZ* n, FlatZone& fz) : node(n), flatzone(&fz), idFlatZone(fz.front()) {} 
+    
+
+};
+
+
+
+#endif 

morphotreeadjust-0.1.2/morphoTreeAdjust/include/ComponentTree.hpp

@@ -0,0 +1,104 @@
+#include <list>
+#include <vector>
+#include <array>
+#include <unordered_set>
+#include <utility>
+#include <optional>
+#include <functional>
+#include <variant>
+
+#include "../include/AdjacencyRelation.hpp"
+#include "../include/Common.hpp"
+
+#ifndef COMPONENT_TREE_H
+#define COMPONENT_TREE_H
+
+template <typename CNPsType>
+class NodeCT;  // Forward declaration
+
+template <typename CNPsType>
+class ComponentTree {
+protected:
+    NodeCT<CNPsType>* root;
+    NodeCT<CNPsType>** pixelToNode; //mapping from pixel to node
+    
+    int numNodes;
+    int maxIndex;
+    bool maxtreeTreeType; //maxtree is true; mintree is false
+
+    int numCols;
+    int numRows;
+    int numPixels;
+    
+    AdjacencyRelation* adj; //disk of a given ratio: ratio(1) for 4-connect and ratio(1.5) for 8-connect 
+    
+    int* countingSort(int* img);
+    int* createTreeByUnionFind(int* orderedPixels, int* img);
+    int findRoot(int* zPar, int x);
+    void reconstruction(NodeCT<CNPsType>* node, int* imgOut);
+
+public:
+
+    // Define `flatzoneGraph` apenas para `FlatZones`
+    using FlatzoneGraphType = std::conditional_t<std::is_same_v<CNPsType, FlatZones>,
+        FlatzoneGraph, 
+        std::monostate>;
+    FlatzoneGraphType flatzoneGraph;
+    
+    ComponentTree(int numRows, int numCols, bool isMaxtree, double radiusOfAdjacencyRelation);
+
+    ComponentTree(int* img, int numRows, int numCols, bool isMaxtree, double radiusOfAdjacencyRelation);
+
+    ~ComponentTree();
+
+    template<typename T = CNPsType, typename std::enable_if_t<std::is_same<T, FlatZones>::value, int> = 0>
+	std::list<int>& getFlatzoneByID(int p);
+	
+    template<typename T = CNPsType, typename std::enable_if_t<std::is_same<T, FlatZones>::value, int> = 0>
+    void updateGraphAfterPruning(std::list<FlatZone>& flatZoneList, FlatZone& unifiedFlatzone, NodeFZ* nodeStar);
+
+    template<typename T = CNPsType, typename std::enable_if_t<std::is_same<T, FlatZones>::value, int> = 0>
+    void updateGraph(std::list<FlatZoneNode>& flatZoneNodeList, FlatZone& unifiedFlatzone, NodeFZ* nodeStar);
+
+    void assignCNPs();
+
+    void build(int* img);
+
+    NodeCT<CNPsType>* getSC(int p);
+
+    NodeCT<CNPsType>* getRoot();
+
+    void setRoot(NodeCT<CNPsType>* n);
+
+    bool isMaxtree();
+
+    int getNumNodes();
+
+    void setNumNodes(int numNodes) { this->numNodes = numNodes; }
+
+    int getNumRowsOfImage();
+
+    int getNumColsOfImage();
+
+    void computerArea(NodeCT<CNPsType>* node);
+
+    int* reconstructionImage();
+
+    AdjacencyRelation* getAdjacencyRelation();
+
+    void setSC(int p, NodeCT<CNPsType>* n);
+
+    void prunning(NodeCT<CNPsType>* node);
+    
+    std::vector<NodeCT<CNPsType>*> getLeaves();
+
+    std::vector<NodeCT<CNPsType>*> getNodesThreshold(int threshold);
+    
+
+};
+
+
+#include "ComponentTree.tpp"
+
+
+#endif

morphotreeadjust-0.1.2/morphoTreeAdjust/include/ComponentTreeAdjustment.hpp

@@ -0,0 +1,281 @@
+#include <iterator>
+#include <functional>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include "../include/AdjacencyRelation.hpp"
+#include "../include/NodeCT.hpp"
+#include "../include/ComponentTree.hpp"
+#include "../include/Common.hpp"
+
+#ifndef COMPONENT_TREE_ADJUSTMENT_H
+#define COMPONENT_TREE_ADJUSTMENT_H
+
+#include <array>
+#include <vector>
+#include <unordered_set>
+class MergedNodesCollection {
+protected:
+    std::array<std::vector<NodeFZ*>, 256> collectionF;
+    bool* visited;
+    bool* visitedAdj;
+
+    int maxIndex;
+    std::vector<int> lambdaList; // Lista ordenada de lambdas (sempre crescente)
+    int currentIndex = 0; // Índice atual
+    bool isMaxtree; // Se true, percorre de forma decrescente
+    std::vector<NodeFZ*> nodesNL;
+
+public:
+    
+    // Construtor permite definir a ordem de iteração
+    MergedNodesCollection(int maxIndex): maxIndex(maxIndex) {
+        this->visited = new bool[this->maxIndex]();  // Inicializa com false
+        this->visitedAdj = new bool[this->maxIndex]();
+    }
+
+    ~MergedNodesCollection() {
+        delete[] this->visited;  // Libera memória
+        delete[] this->visitedAdj;
+    }
+
+    std::vector<NodeFZ*>& getMergedNodes(int level) {
+        return collectionF[level]; 
+    }
+
+    void computerAdjacentNodes(ComponentTreeFZ* tree, std::vector<FlatZoneRef>& flatZones) {
+        bool isMaxtree = tree->isMaxtree();
+        
+        for (FlatZoneRef flatZonePRef : flatZones) {   
+            FlatZone& flatZoneP = flatZonePRef.get();
+            int flatZoneID_P = flatZoneP.front();
+            int grayFlatZoneP = tree->getSC(flatZoneID_P)->getLevel(); //is same that: f(p)
+    
+            for (int flatZoneID_Q : *tree->flatzoneGraph[flatZoneID_P]) {
+                NodeFZ* node = tree->getSC(flatZoneID_Q);
+                if ( (isMaxtree && node->getLevel() > grayFlatZoneP) || (!isMaxtree && node->getLevel() < grayFlatZoneP) ) {
+                    if(!visitedAdj[node->getIndex()]){
+                        nodesNL.push_back(node);  
+                        visitedAdj[node->getIndex()] = true;
+                    }
+                }
+            }
+        }
+        resetAdjacentNode();
+    }
+
+    std::vector<NodeFZ*>& getAdjacentNodes(){
+        return nodesNL;
+    }
+
+
+    std::array<std::vector<NodeFZ*>, 256>& getCollectionF(){
+        return collectionF;
+    }
+
+    void resetAdjacentNode(){
+        for(NodeFZ* node: nodesNL){
+            visitedAdj[node->getIndex()] = false;
+        }
+    }
+
+    void resetCollection(bool descendingOrder) {
+        this->isMaxtree = descendingOrder;
+        for (auto& vec : collectionF) {
+            vec.clear();
+        }
+        nodesNL.clear();
+        lambdaList.clear();
+        std::fill(visited, visited + maxIndex, false);
+        currentIndex = 0;
+    }
+
+    void addNodesOfPath(NodeFZ* nodeNL, NodeFZ* nodeTauL) {
+        if(!visited[nodeNL->getIndex()])
+            for (NodeFZ* n : nodeNL->getNodesOfPathToRoot()) {
+                int index = n->getIndex();
+                if(!visited[index]) {
+                    collectionF[n->getLevel()].push_back(n);
+                    visited[index] = true;
+                }else{
+                    break;
+                }
+                
+                if (n == nodeTauL) {
+                    break;
+                }
+            }
+    }
+
+
+
+    int firstLambda() {
+        lambdaList.clear();
+        for (int i = 0; i < 256; ++i) {
+            if (!collectionF[i].empty()) {
+                lambdaList.push_back(i);
+            }
+        }
+        currentIndex = isMaxtree ? lambdaList.size() - 1 : 0;
+        return lambdaList[currentIndex];
+    }
+
+
+    int nextLambda() {
+        if (isMaxtree) {
+            return lambdaList[--currentIndex];
+        } else {
+            return lambdaList[++currentIndex];
+        }
+    }
+};
+
+class UnionNodes {
+protected:
+    bool isMaxtree; // Se true, percorre de forma decrescente
+    std::list<FlatZoneNode> flatZoneNodeList;
+    std::list<int> listFlatzoneIDs;
+    FlatZoneNode nodeTauStar; //nodeTauStar é o nó correspondente da folha da sub-arvore a ser podada com maior (ou menor, para min-tree) intensidade
+    std::unordered_set<NodeFZ*> nodesToBeRemoved; //nodes que foram removido devido ao fusão das zonas planas quando newGrayLevel = \lambda
+
+public:
+
+    // Construtor permite definir a ordem de iteração
+    UnionNodes(bool isMaxtree):  isMaxtree(isMaxtree) {}
+    
+    
+    std::list<FlatZoneNode>& getFlatzoneNodeList() {
+        return flatZoneNodeList;
+    }
+
+    std::vector<FlatZoneRef> getFlatzones() {
+        std::vector<FlatZoneRef> flatzones;
+        for(FlatZoneNode fzNode: flatZoneNodeList){
+            flatzones.push_back(*fzNode.flatzone);
+        }
+        return flatzones;
+    }
+
+    FlatZoneNode getNodeTauStar() {
+        return nodeTauStar;
+    }
+   
+    std::unordered_set<NodeFZ*>& getNodesToBeRemoved() {
+        return nodesToBeRemoved;
+    }
+
+    void addCNPsToConnectedFlatzone(NodeFZ* nodeUnion, ComponentTreeFZ* tree) {
+        if (flatZoneNodeList.size() > 1) {
+            FlatZone unifiedFlatzone;
+            tree->updateGraph(flatZoneNodeList, unifiedFlatzone, nodeTauStar.node);
+            nodeUnion->addCNPsToConnectedFlatzone(std::move(unifiedFlatzone), tree);
+        }else{
+            nodeUnion->addCNPsToConnectedFlatzone(std::move(*nodeTauStar.flatzone), tree);
+        }
+        
+    }
+
+    void removeFlatzones(ComponentTreeFZ* tree) {
+        for(FlatZoneNode fzNode: flatZoneNodeList){
+            NodeFZ* node = fzNode.node;
+            node->removeFlatzone(fzNode.idFlatZone);  
+            if(fzNode.node->getNumCNPs() == 0){
+                nodesToBeRemoved.insert(fzNode.node);
+            }
+        }
+    }
+
+    bool isRemoved(NodeFZ* node){
+        return nodesToBeRemoved.find(node) == nodesToBeRemoved.end();
+    }
+    
+    void resetCollection(bool isMaxtree) {
+        this->isMaxtree = isMaxtree;
+        this->flatZoneNodeList.clear();
+        this->listFlatzoneIDs.clear();
+        this->nodesToBeRemoved.clear();
+
+        this->nodeTauStar.node = nullptr;
+        this->nodeTauStar.flatzone = nullptr;
+        this->nodeTauStar.idFlatZone = -1;
+    }
+    
+    void addNode(NodeFZ* nodeTau, std::list<int>& fzTau) {
+        flatZoneNodeList.emplace_back(nodeTau, fzTau);
+        listFlatzoneIDs.push_back(fzTau.front());
+        
+        if (!this->nodeTauStar.node || ( (!isMaxtree && nodeTau->getLevel() > nodeTauStar.node->getLevel()) || (isMaxtree && nodeTau->getLevel() < nodeTauStar.node->getLevel()))) {
+            this->nodeTauStar.node = nodeTau;
+            this->nodeTauStar.flatzone = &fzTau;
+        }
+    }
+
+};
+
+
+class ComponentTreeAdjustment {
+
+protected:
+    ComponentTreeFZ* mintree;
+    ComponentTreeFZ* maxtree; 
+    int maxIndex; 
+    int pixelUpperBound=-1;    
+    UnionNodes unionNodeTauSubtree;
+    MergedNodesCollection F;
+    std::unordered_set<NodeFZ*> Fb;
+    std::ostringstream outputLog;
+
+    
+
+    void disconnect(NodeFZ* node, bool isFreeMemory=false) {
+        if(node->getParent() != nullptr){
+	        node->getParent()->getChildren().remove(node);
+		    node->setParent(nullptr);
+            if(isFreeMemory){
+                delete node; 
+                node = nullptr;
+            }
+        }
+    }
+
+    void mergedParentAndChildren(NodeFZ* nodeUnion, NodeFZ* n){
+        for (NodeFZ* son : n->getChildren()) {
+            son->setParent(nodeUnion);
+        }
+        nodeUnion->getChildren().splice(nodeUnion->getChildren().end(), n->getChildren());
+    }
+    
+    
+public:
+
+    ComponentTreeAdjustment(ComponentTreeFZ* maxtree, ComponentTreeFZ* mintree); 
+
+    ~ComponentTreeAdjustment(); 
+
+    std::string getOutputLog() {
+        return outputLog.str();
+    }
+
+ 
+    void buildMergedAndNestedCollections(ComponentTreeFZ* tree, std::vector<FlatZoneRef>& flatZone, int newGrayLevel, bool isMaxtree);
+    
+    void updateTree(ComponentTreeFZ* tree, NodeFZ *L_leaf);
+
+    void updateTree2(ComponentTreeFZ* tree, NodeFZ *rSubtree);
+
+    void adjustMinTree(ComponentTreeFZ* mintree, ComponentTreeFZ* maxtree, std::vector<NodeFZ*> nodesToPruning);
+    
+    void adjustMaxTree(ComponentTreeFZ* maxtree, ComponentTreeFZ* mintree, std::vector<NodeFZ*> nodesToPruning);
+
+    void adjustMinTree2(ComponentTreeFZ* mintree, ComponentTreeFZ* maxtree, std::vector<NodeFZ*> nodesToPruning);
+    
+    void adjustMaxTree2(ComponentTreeFZ* maxtree, ComponentTreeFZ* mintree, std::vector<NodeFZ*> nodesToPruning);
+
+
+
+    
+};
+
+
+#endif

{morphotreeadjust-0.1 → morphotreeadjust-0.1.2}/morphoTreeAdjust/include/ComponentTreeGeneralAdjustment.hpp

@@ -1,16 +1,17 @@
 #include <unordered_set>
 #include <map>
-#include<iterator>
+#include <iterator>
 
 #include "../include/AdjacencyRelation.hpp"
 #include "../include/NodeCT.hpp"
 #include "../include/ComponentTree.hpp"
+#include "../include/Common.hpp"
 
 #ifndef COMPONENT_TREE_GENERAL_ADJUSTMENT_H
 #define COMPONENT_TREE_GENERAL_ADJUSTMENT_H
 
 class ComponentTreeGeneralAdjustment {
-    
+    /*
     private:
         std::map <int, std::unordered_set<NodeCT*, NodeCT::NodeHashFunction>* > collectionF;
 
@@ -52,10 +53,12 @@ class ComponentTreeGeneralAdjustment {
                 }
             }
         }
+            */
     public:
 
-    void adjustMaxTree(ComponentTree &maxtree, std::list<int> flatZone, int newGrayLevel);
+    void adjustMaxTree(ComponentTree<FlatZones> &maxtree, std::list<int> flatZone, int newGrayLevel);
 
 };
 
+
 #endif