image_graph.h

Go to the documentation of this file.

#ifndef IMAGE_GRAPH_H
#define IMAGE_GRAPH_H

#include <assert.h>
#include <vector>
#include <map>
#include <algorithm>

class ImageEdge {
public:
    ImageEdge() : n(0), m(0), w(0) {};
    
    unsigned long int n;
    
    unsigned long int m;
    
    float w;
    
};

class ImageEdgeSorter {
public:
    inline bool operator()(const ImageEdge & g, const ImageEdge h) {
        return (h.w > g.w);
    }
};

class ImageNode {
public:
    ImageNode() : b(0), g(0), r(0), l(0),  n(1),  id(0), max_w(0) {
                
    };
    
    unsigned char b;
    
    unsigned char g;
    
    unsigned char r;
    
    unsigned long int l; // label, i.e. the index of the node this node belongs to
    
    unsigned long int n;
    
    unsigned long int id;
    
    float max_w;
    
};

class ImageGraph {
public:
    ImageGraph() {
        K = 0;
    };
    
    ImageGraph(int N) {
        nodes = std::vector<ImageNode>(N);
        K = N;
    }
    
    void operator=(const ImageGraph & graph) {
        nodes = graph.nodes;
        edges = graph.edges;
        K = graph.K;
    }
    
    void setNode(int n, ImageNode & node) {
        nodes[n] = node;
    }
    
    void addNode(ImageNode & node) {
        nodes.push_back(node);
        K++;
    }
    
    void addEdge(ImageEdge & edge) {
        edges.push_back(edge);
    }
    
    ImageNode & getNode(int n) {
        assert(n >= 0 && n < static_cast<int>(nodes.size()));
        return nodes[n];
    }
    
    ImageEdge & getEdge(int e) {
        assert(e >= 0 && e < static_cast<int>(edges.size()));
        return edges[e];
    }
    
    int getNumNodes() {
        return nodes.size();
    }
    
    int getNumEdges() {
        return edges.size();
    }
    int getNumComponents() {
        return K;
    }
    
    void sortEdges() {
        std::sort(edges.begin(), edges.end(), ImageEdgeSorter());
    }
    
    ImageNode & findNodeComponent(ImageNode & n) {
        
        // Get component of node n.
        int l = n.l;
        int id = n.id;
        
        while (l != id) {
            id = nodes[l].id;
            l = nodes[l].l;
        }
        
        ImageNode & S = nodes[l];
        assert(S.l == S.id);
        
        // Save latest component.
        n.l = S.id;
        
        return S;
    }
    
    void merge(ImageNode & S_n, ImageNode & S_m, ImageEdge & e) {
        S_m.l = S_n.id;
        
        // Update cound.
        S_n.n += S_m.n;
        
        // Update maximum weight.
        S_n.max_w = std::max(std::max(S_n.max_w, S_m.max_w), e.w);
        
        // Update component count.
        K--;
    }
    
private:
    
    int K;
    
    std::vector<ImageEdge> edges;
    
    std::vector<ImageNode> nodes;
    
};

#endif  /* IMAGE_GRAPH_H */