Node.cpp

Aller à la documentation de ce fichier.

/// \file 
/// Implémentation de la classe Node
#include "Node.hpp"
///////////////////////////////////////////////////////////////////////////////
/// Node
///////////////////////////////////////////////////////////////////////////////
Node::Node(){ 
        p = new Node_Leaf();
}
Node::Node(Node_Leaf* node){
        p = node;
        ++p->use;       
}
Node Node::CreateLeaf(const string label){
        Node_Leaf* ret = new Node_Leaf();
        return ret; 
}
Node Node::CreateGraph(const string label){
        Node_Leaf* ret = new Node_Graph();
        return ret;
}
///.
/// Crée un grid graphe à partir d'une image
Node Node::CreateGridGraph(PNG image, string label){
        Trace trace("CreateGridNode", channelGraph);
        // Le graphe
        Node ret = Node::CreateGraph(label);
        // Les points du graphe
        vector<Node> v;
        // Dimension de l'image
        int height = image.getHeight();
        int width = image.getWidth();
        // On crée un noeud par point de l'image
        for(int j = 0; j < height; j++){
                for(int i = 0; i < width; i++){
                        ostringstream o;
                        o << "LEAF[" << i << ":" << j << "]";
                        Node n = Node::CreateLeaf(o.str());
                        ret.addNode(n);
                        n.setWeight(0);
                        // On associe le pixel au noeud
                        Pixel pix(i, j, image.getColor(i, j));
                        n.setPixel(pix);
                        v.push_back(n);
                }
        }
        // On parcourt l'image
        for(int i = 0; i < width; i++){
                for(int j = 0; j < height; j++){
                        // Noeud (i, j)
                        Node n = v[i + j * width];//.getNode(i, j);
                        // Couleur du noeud (i, j)
                        Color nColor = n.getPixel().getColor();
                        if(i + 1 < width){
                                // Noeud à droite (i + 1, j)
                                Node n1 = v[i + 1 + j * width];
                                Color n1Color = n1.getPixel().getColor();
                                float w = nColor.distance(n1Color);
                                Edge e1(n, n1, w);
                                e1.setCoord(n.getPixel().getX(), n.getPixel().getY(), 
                                        n1.getPixel().getX(), n1.getPixel().getY());
                                ret.addEdge(e1);
                        }
                        if(i > 0 && j + 1 < height){
                                // Noeud en bas à gauche (i - 1, j + 1)
                                Node n1 = v[i - 1 + (j + 1) * width];
                                Color n1Color = n1.getPixel().getColor();
                                float w = nColor.distance(n1Color);
                                Edge e1(n, n1, w);
                                e1.setCoord(n.getPixel().getX(), n.getPixel().getY(), 
                                        n1.getPixel().getX(), n1.getPixel().getY());
                                ret.addEdge(e1);
                        }
                        if(i + 1 < width && j + 1 < height){
                                // Noeud en bas à droite (i + 1, j + 1)
                                Node n1 = v[i + 1 + (j + 1) * width];
                                Color n1Color = n1.getPixel().getColor();
                                float w = nColor.distance(n1Color);
                                Edge e1(n, n1, w);
                                e1.setCoord(n.getPixel().getX(), n.getPixel().getY(), 
                                        n1.getPixel().getX(), n1.getPixel().getY());
                                ret.addEdge(e1);
                        }
                        if(j + 1 < height){
                                // Noeud en bas (i, j + 1)
                                Node n2 = v[i + (j + 1) * width];
                                Color n2Color = n2.getPixel().getColor();
                                float w = nColor.distance(n2Color);
                                Edge e2(n, n2, w);
                                e2.setCoord(n.getPixel().getX(), n.getPixel().getY(), 
                                        n2.getPixel().getX(), n2.getPixel().getY());
                                
                                ret.addEdge(e2);
                        }
                }
        }
        return ret;
}
Node::Node(const Node& node){
        p = node.p;
        ++p->use;
}
Node& Node::operator=(const Node& rhs){
        rhs.p->use++;
        if(--p->use == 0){
                delete p;
        }
        p = rhs.p;
        return *this;
}
Node::~Node(){
        if(--p->use == 0){
                delete p;
        }
}
/*
ENODE_TYPE Node::getType()const{
        return p->getType();
}
*/
void Node::setRank(int i){
        p->setRank(i);
}
int Node::getRank()const{
        return p->getRank();
}
void Node::setWeight(double weight){
        p->setWeight(weight);
}
double Node::getWeight(){
        return p->getWeight();
}
void Node::setPixel(Pixel pixel){
        p->setPixel(pixel);
}
Pixel Node::getPixel()const{
        return p->getPixel();   
}
void Node::addNode(Node node){
        p->addNode(node);
}
void Node::addEdge(Edge edge){
        p->addEdge(edge);
}
string Node::toString(int level, bool child, bool edge)const{
        return p->toString(level, child, edge);
}
///.
/// Produit une carte
PixelMap* Node::makeMap(int level)const{
        Trace trace("makeMap", channelGraph);
        int x1, y1, x2, y2;
        x1 = y1 = x2 = y2 = 0;
        p->_size(x1, y1, x2, y2);
        int width = (x2 - x1) + 1;
        int height = (y2 - y1) + 1;
        if((width > 0) && (height > 0)){
                PixelMap* ret = new PixelMap(width, height);
                p->makeMap(ret, level, 0, 1);
                return ret;
        }
        return NULL;
}


///.
/// Produit un fichier PNG
/// C'est ici qu'on démarre la récursion
void Node::drawPNG(string fileName, int level)const{
        Trace trace("Node_Graph::drawPNG()", channelGraph);
        int x1, y1, x2, y2;
        x1 = y1 = x2 = y2 = 0;
        p->_size(x1, y1, x2, y2);
        int width = (x2 - x1) + 1;
        int height = (y2 - y1) + 1;
        if((width > 0) && (height > 0)){
                PNG output(width, height, PNG_GRAY, fileName);
                Color c;
                p->drawPNG(output, level, c, 1);
                output.write();
        }
}
///.
/// Produit un fichier PNG des bords du graphe
void Node::drawBorderPNG(string fileName, int level)const{
        Trace trace("drawBorderPNG", channelGraph);
        PixelMap* map = makeMap(level);
        map->drawBorderPNG(fileName); 
        delete map;
}


///.
/// Produit un fichier PS
/// C'est ici qu'on démarre la récursion
void Node::drawEPS(string fileName, int level)const{
        Trace trace("Node_Graph::drawEPS()", channelGraph);
        int x1, y1, x2, y2;
        x1 = y1 = x2 = y2 = 0;
        p->_size(x1, y1, x2, y2);
        int width = (x2 - x1) + 1;
        int height = (y2 - y1) + 1;
        if((width > 0) && (height > 0)){
                EPSWriter output(fileName, width, height);
                Color c;                
                p->drawNodeEPS(output, level, c, 1, height);
                output.write();
        }
}
void Node::sortEdge(){
        p->sortEdge();
}
void Node::sortEdge(float& min, float& max){
        p->sortEdge(min, max);
}
int Node::getNodeSize(){
        return p->getNodeSize();
}
int Node::getLeafSize(){
        return p->getLeafSize();
}
int Node::getEdgeSize(){
        return p->getEdgeSize();
}
void Node::merge(Node node){
        p->merge(node);
}
Node_Iterator Node::getNodeIterator(){
        return p->getNodeIterator();
}
Edge_Iterator Node::getEdgeIterator(){
        return p->getEdgeIterator();
}
///////////////////////////////////////////////////////////////////////////////
/// Node_Leaf
///////////////////////////////////////////////////////////////////////////////
Node_Leaf::Node_Leaf():
        use(0),
        rank(-1),
        weight(0){
}
string Node_Leaf::toString(int l, bool, bool) const{
        std::ostringstream o;
        for(int i = 0; i < l; i++){ 
                o << "   ";
        }
        o << "LEAF USE " << use << " WEIGHT " << weight << " PIXEL " << pixel.toString();
        return o.str();
}
void Node_Leaf::_size(int& x1, int& y1, int& x2, int& y2){
        x1 = (getPixel().getX() < x1 ? getPixel().getX() : x1);
        y1 = (getPixel().getY() < y1 ? getPixel().getY() : y1);
        x2 = (getPixel().getX() > x2 ? getPixel().getX() : x2);
        y2 = (getPixel().getY() > y2 ? getPixel().getY() : y2);
}
void Node_Leaf::addNode(Node){}
void Node_Leaf::addEdge(Edge){}
void Node_Leaf::setRank(int i){
        rank = i;       
}
int Node_Leaf::getRank() const {
        return rank;
}
void Node_Leaf::setWeight(double _weight){
        weight = _weight;
}
double Node_Leaf::getWeight()const{
        return weight;
}
void Node_Leaf::setPixel(Pixel _pixel){
        pixel = _pixel; 
}
Pixel Node_Leaf::getPixel()const{
        return pixel;
}
int Node_Leaf::getNodeSize()const {
        return 1;
}
int Node_Leaf::getLeafSize()const {
        return 1;
}
int Node_Leaf::getEdgeSize()const{
        return 0;
}
// Produit une carte d'un noeud
PixelMap* Node_Leaf::makeMap(PixelMap* map, int, int label, int)const{
        map->addPixel(pixel, label);
}

///.
/// Pour un noeud feuille on produit le pixel avec la couleur
/// correspondante
void Node_Leaf::drawPNG(PNG image, int level, Color c, int){
        if(level == -1){
                image.setColor(pixel.getX(), pixel.getY(), pixel.getColor());
        } else {
                image.setColor(pixel.getX(), pixel.getY(), c);
        }               
}
///.
/// Pour un noeud feuille on produit le pixel avec la couleur
/// correspondante
void Node_Leaf::drawNodeEPS(EPSWriter& writer, int level, Color c, int, int height){
        if(level == -1){
                writer.setColor(pixel.getColor());
        } else {
                writer.setColor(c);             
        }
        writer.drawRound(pixel.getX(), (height - pixel.getY()));
}
Node_Iterator Node_Leaf::getNodeIterator()const{
        return Node_Iterator(this);
}
Edge_Iterator Node_Leaf::getEdgeIterator()const{
        return Edge_Iterator(this);
}
///////////////////////////////////////////////////////////////////////////////
/// Node_Graph
///////////////////////////////////////////////////////////////////////////////
Node_Graph::Node_Graph(){}
///.
/// asdfjasdjféasd
/// asdfljlasjdfléasd
string Node_Graph::toString(int l, bool child, bool edge)const{
        std::ostringstream o;
        for(int i = 0; i < l; i++){
                o << "   ";
        }
        o << " LEVEL " << l << " " << " USE " << use << " SIZE " << vNode.size() 
        << " PIXEL " << pixel.toString();
        if(child){
                o << "\n";
                for(Node_Iterator it = getNodeIterator(); it.hasNext(); ){
                        Node n = it.next();
                        o << n.toString(l + 1, child, edge) << "\n";    
                }
        }
        if(edge){
                for(Edge_Iterator it = getEdgeIterator(); it.hasNext();){
                        Edge e = it.next();
                        o << e.toString() << endl;
                }
        }
        return o.str();
}
void Node_Graph::_size(int& x1, int& y1, int& x2, int& y2){
        for(Node_Iterator it = getNodeIterator(); it.hasNext();){
                Node n = it.next();
                n.p->_size(x1, y1, x2, y2);
        }
}
int Node_Graph::getNodeSize()const{
        return vNode.size();
}
int Node_Graph::getLeafSize()const{
        int ret = 0;
        for(Node_Iterator it = getNodeIterator(); it.hasNext();){
                Node n = it.next();
                ret += n.getLeafSize();
        }
        return ret;
}
int Node_Graph::getEdgeSize()const{
        return vEdge.size();
}
void Node_Graph::addNode(Node node){
        vNode.push_back(node);
}
void Node_Graph::addEdge(Edge edge){
        vEdge.push_back(edge);
}
void Node_Graph::merge(Node node){
        Node_Graph* n = (Node_Graph*)node.p;
        vNode.insert(vNode.end(), n->vNode.begin(), n->vNode.end());
        vEdge.insert(vEdge.end(), n->vEdge.begin(), n->vEdge.end());
}
void Node_Graph::sortEdge(){
        sort(vEdge.begin(), vEdge.end(), compareEdge);
}
void Node_Graph::sortEdge(float& min, float& max){
        sort(vEdge.begin(), vEdge.end(), compareEdge);
        if(vEdge.size() > 0){
                min = vEdge[0].getWeight();
                max = vEdge[vEdge.size() - 1].getWeight();
        } else {
                min = max = 0.0;        
        }
}
Node_Iterator Node_Graph::getNodeIterator()const{
        return Node_Iterator(this);
}
Edge_Iterator Node_Graph::getEdgeIterator()const{
        return Edge_Iterator(this);
}
// Produit une carte d'un noeud
PixelMap* Node_Graph::makeMap(PixelMap* map, int level, int label, int depth)const{
        int i = 0;
        for(Node_Iterator it = getNodeIterator(); it.hasNext();){
                Node node = it.next();
                if(level == depth){
                        label = i;
                }
                node.p->makeMap(map, level, label, depth + 1);
                i++;
        }
}


///.
/// On poursuit la récursion et on détermine la couleur
/// du cluster
void Node_Graph::drawPNG(PNG image, int level, Color c, int depth){
        int i = 0;
        for(Node_Iterator it = getNodeIterator(); it.hasNext();){
                Node node = it.next();
                if(level == 0 && depth == 1){
                        c = node.getPixel().getColor(); 
                } else  if(level == depth){
                        c = Color::getColor(i);
                        i++;            
                }
                node.p->drawPNG(image, level, c, depth + 1);
        }
}
///.
/// On poursuit la récursion et on détermine la couleur
/// du cluster
void Node_Graph::drawNodeEPS(EPSWriter& writer, int level, Color c, int depth, int height){
        int i = 0;
        for(Node_Iterator it = getNodeIterator(); it.hasNext();){
                Node node = it.next();
                if(level == 0 && depth == 1){
                        c = node.getPixel().getColor(); 
                } else if(level == depth){
                        c = Color::getColor(i);
                        i++;            
                }
                node.p->drawNodeEPS(writer, level, c, depth + 1, height);
        }
        if(level == depth){
                drawEdgeEPS(writer, height);            
        }
        
}
///.
/// Production des arrêtes pour un fichier PS
void Node_Graph::drawEdgeEPS(EPSWriter& writer, int height){
        cout << getEdgeSize() << endl;
        for(Edge_Iterator it = getEdgeIterator(); it.hasNext();){
                Edge edge = it.next();
                Node n1 = edge.getSRC();
                Node n2 = edge.getDST();
                
                int x0 = edge.getX0();
                int y0 = edge.getY0();
                int x1 = edge.getX1();
                int y1 = edge.getY1();
                
                if((x0 == -1) || (y0 == -1) || (x1 == -1) || (y1 == -1)){
                        return; 
                }
                y0 = height - y0;
                y1 = height - y1;

                writer.drawLine(x0, y0, x1, y1);
        }
}

---