neurongraph.h

Go to the documentation of this file.

 
#ifndef NEURONGRAPH_H
#define NEURONGRAPH_H
 
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <cmath>
#include <numeric>
#include <limits>
#include <iomanip>
#include <algorithm>
#include <filesystem>
 
struct SWCNode {
    int id;
    
    int pid;
    
    int type;
    
    double x;
    
    double y;
    
    double z;
    
    double radius;
};
 
class NeuronGraph {
    private:
        std::map<int,SWCNode> nodes;
        
        std::map<int, std::vector<int>> edges;
 
        std::map<int, std::vector<int>> getNeighborMap(const std::map<int, SWCNode>& nodeSet) const;
    public:
        NeuronGraph() {nodes.clear(); edges.clear();};
        
        NeuronGraph(std::string filename) {this->readFromFileUGXorSWC(filename);};
        
        NeuronGraph(const std::map<int, SWCNode>& nodeSet);
 
        void addNode(const SWCNode &node);
 
        void setNodes(const std::map<int,SWCNode>& nodeSet);
 
        bool isTopologicallySorted(const std::map<int, SWCNode>& nodeSet) const;
 
        bool isTopologicallySorted() const {return this->isTopologicallySorted(this->nodes);};
 
        std::map<int, SWCNode> topologicalSort(const std::map<int, SWCNode>& nodeSet) const;
 
        std::map<int, SWCNode> topologicalSort() const {return this->topologicalSort(this->nodes);};
 
        bool hasSomaSegment(const std::map<int, SWCNode>& nodeSet) const;
 
        bool hasSomaSegment() const {return this->hasSomaSegment(this->nodes);};
 
        bool isSomaMissing(const std::map<int, SWCNode>& nodeSet) const;
 
        bool isSomaMissing() const {return this->isSomaMissing(this->nodes);};
 
        std::map<int, SWCNode> removeSomaSegment(const std::map<int, SWCNode>& inputNodes) const;
 
        std::map<int, SWCNode> removeSomaSegment() const {return this->removeSomaSegment(this->nodes);};
 
        std::map<int, SWCNode> setSoma(const std::map<int, SWCNode>& nodeSet) const;
 
        std::map<int, SWCNode> setSoma() const {return this->setSoma(this->nodes);};
 
        std::map<int, SWCNode> preprocess(const std::map<int, SWCNode> & nodeSet) const;
 
        void readFromFile(const std::string& filename);
 
        void writeToFile(const std::map<int,SWCNode> & nodeSet,
                 const std::string& filename);
 
        void writeToFile(const std::string& filename) {this->writeToFile(this->nodes, filename);};
 
        void readFromFileUGX(const std::string& filename);
 
        void readFromFileUGXorSWC(const std::string& filename);
 
        void writeToFileUGX(const std::map<int,SWCNode> & nodeSet,
                const std::string& filename);
 
        void writeToFileUGX(const std::string& filename) {this->writeToFileUGX(this->nodes, filename);};
 
        void swc2ugx(const std::string& inputfile, const std::string& outputfile);
 
        void ugx2swc(const std::string& inputfile, const std::string& outputfile);
 
        int numberOfNodes() {return this->nodes.size();};
 
        int numberOfEdges() {return this->edges.size();};
 
        auto getNodes() { return this->nodes; };
 
        std::map<int, SWCNode> splitEdges(const std::map<int, SWCNode>& nodeSet) const;
 
        std::map<int, SWCNode> splitEdges() const {return this->splitEdges(this->nodes);};
 
        std::vector<std::map<int, SWCNode>> splitEdgesN(const std::map<int, SWCNode>& nodeSet, int N) const;
 
        std::vector<std::map<int, SWCNode>> splitEdgesN(int N) const {return this->splitEdgesN(this->nodes, N);};
 
        std::map<int,std::map<int,SWCNode>> getTrunks(const std::map<int,SWCNode>& nodeSet, bool resetIndex = false) const;
 
        std::map<int,std::map<int,SWCNode>> getTrunks(bool resetIndex = false) const {return this->getTrunks(this->nodes, resetIndex);};
 
        std::map<int, int> getTrunkParentMap(const std::map<int, SWCNode>& nodeSet,
                                             const std::map<int, std::map<int, SWCNode>>& trunkNodeSets) const;
 
        std::map<int, SWCNode> assembleTrunks(const std::map<int, std::map<int, SWCNode>>& trunkNodeSets) const;
 
        std::map<int, SWCNode> assembleTrunks(const std::map<int, std::map<int, SWCNode>>& resampledTrunks,
                                              const std::map<int,int>& trunkParentMap);
 
        std::map<int, SWCNode> linearSplineResampleTrunk(const std::map<int, SWCNode>& trunk, double& delta) const;
 
        std::map<int, std::map<int, SWCNode>> allLinearSplineResampledTrunks(std::map<int, std::map<int, SWCNode>>& trunks, double& delta) const;
 
        std::map<int, SWCNode> cubicSplineResampleTrunk(const std::map<int, SWCNode>& trunk, double& delta) const;
 
        std::map<int, std::map<int, SWCNode>> allCubicSplineResampledTrunks(std::map<int, std::map<int, SWCNode>>& trunks, double& delta) const;
 
        std::map<int, std::map<int,SWCNode>> generateRefinements(const std::map<int,SWCNode>& nodeSet, 
                                                                 double& delta, 
                                                                 int& N, 
                                                                 std::string& method);
 
        std::map<int, std::map<int,SWCNode>> generateRefinements(double& delta, 
                                                                 int& N, 
                                                                 std::string& method) {
            return this->generateRefinements(this->nodes, delta, N, method); 
        };
};
 
#endif // NEURONGRAPH_H