PixelMap.cpp

Aller à la documentation de ce fichier.

/// \file 
/// Implémentation de la classe PixelMap
#include "PixelMap.hpp"
///////////////////////////////////////////////////////////////////////////////
/// Labelise un tableau de pixel
///////////////////////////////////////////////////////////////////////////////
PixelMap::PixelMap(int _width, int _height):
        width(_width),
        height(_height){
        data.resize(width * height);
        parent.resize(width * height);  
        border.resize(width * height);  
}
string PixelMap::toString(){
        string ret;
        for(int i = 0; i < data.size(); i++){
                ret += data[i].toString() + "\n";
        }
        return ret;
}
void PixelMap::addPixel(Pixel pixel){
        data[pixel.getX() + pixel.getY() * width] = pixel;
}
void PixelMap::addPixel(Pixel pixel, int label){
        data[pixel.getX() + pixel.getY() * width] = pixel;
        parent[pixel.getX() + pixel.getY() * width] = label;
}
///.
/// Produit un graphe à partir d'un tableau de pixel
/// On crée le graphe en effectuant une recherche en largeur
Node PixelMap::makeComponent(){
  Trace trace("makeComponent", channelPixelMap);
  trace.print("Création des composants");
        // Valeur de retour
        Node ret = Node::CreateGraph("ROOT");
        // Labels initialisés à -1
        parent.clear();
        for(int i = 0; i < data.size(); i++){
                parent.push_back(-1);
        }
        // Les composants
        vector<Node> component;
        // Compteur
        int count = 0;
        // On parcourt les pixels
        for(int i = 0; i < data.size(); i++){
                // Si un pixel a déjà un label on continue
                if(parent[i] != -1){
                        continue;
                }
                // Label du pixel et création d'un cluster
                parent[i] = count;
                ostringstream o;
                o << "COMPONENT " << count;
                Node comp = Node::CreateGraph(o.str());
                // Association du pixel au cluster
                comp.setPixel(data[i]);
                // Liste auxiliaire
                list<Pixel> aux;
                // On ajoute le point à la liste à parcourir
                aux.push_back(data[i]);
                // On crée une feuille pour le pixel
                Node leaf = Node::CreateLeaf();
                leaf.setPixel(data[i]);
                // On l'ajoute au cluster
                comp.addNode(leaf);
                // On parcourt les voisins
                // Pour chaque voisin à explorer on regarde si sa couleure
                // est identique au point courant
                while(!aux.empty()){
                        // On récupère le point
                        Pixel current = aux.front();
                        // Et on l'élimine de la liste
                        aux.pop_front();
                        // Position dans l'image
                        int rank = (current.getX() + width * current.getY());
                        // en haut
                        if((rank / width) != 0){
                                Pixel p = data[rank - width];
                                if((parent[rank - width] == -1) && p.getColor() == current.getColor()){
                                        parent[rank - width] = count;
                                        aux.push_back(p);
                                        Node leaf = Node::CreateLeaf();
                                        leaf.setPixel(p);
                                        comp.addNode(leaf);
                                }
                        }
                        // a gauche
                        if((rank % width) != 0){
                                Pixel p = data[rank - 1];
                                if((parent[rank - 1] == -1) && p.getColor() == current.getColor()){
                                        parent[rank - 1] = count;
                                        aux.push_back(p);
                                        Node leaf = Node::CreateLeaf();
                                        leaf.setPixel(p);
                                        comp.addNode(leaf);
                                }
                        }
                        // a droite
                        if((rank % width) != width -1){
                                Pixel p = data[rank + 1];
                                if((parent[rank + 1] == -1) && p.getColor() == current.getColor()){
                                        parent[rank + 1] = count;
                                        aux.push_back(p);
                                        Node leaf = Node::CreateLeaf();
                                        leaf.setPixel(p);
                                        comp.addNode(leaf);
                                }
                        }
                        // en bas
                        if((rank / width) != height -1){
                                Pixel p = data[rank + width];
                                if((parent[rank + width] == -1) && p.getColor() == current.getColor()){
                                        parent[rank + width] = count;
                                        aux.push_back(p);
                                        Node leaf = Node::CreateLeaf();
                                        leaf.setPixel(p);
                                        comp.addNode(leaf);
                                }
                        }
                }
                // composant ajouter au graphe
                ret.addNode(comp);
                component.push_back(comp);
                count++;                
        }
        // On a les composants, maintenant on cherche les arrêtes
        // d'adjacence entre composant. Lorsqu'on ajoute une arrête
        // on MAJ des données diverses et en particulier les coordonnées
        // de départ et d'arrivée de l'arrête.
  trace.print("Création des arrêtes");  
        typedef pair<int, int> aPair;
        map< aPair , Edge> table;
        typedef map< aPair , Edge>::iterator table_iter;        
        // on cherche les noeuds frontières
        for(int i = 0; i < (height - 1); i++){
                for(int j = 0; j < (width - 1); j++){
                        // noeud (j, i)
                        Pixel p1 = data[i * width + j];
                        int parent1 = parent[i * width + j];
                        // noeud (j + 1, i)
                        Pixel p2 = data[i * width + j + 1];
                        int parent2 = parent[i * width + j + 1];
                        // noeud (j, i + 1)
                        Pixel p3 = data[(i + 1) * width + j];
                        int parent3 = parent[(i + 1) * width + j];
                        // noeud (j + 1, i + 1)
                        Pixel p4 = data[(i + 1) * width + j + 1];
                        int parent4 = parent[(i + 1) * width + j + 1];
                        if(parent1 != parent2){
                                // On regarde si l'arrête entre cluster est déjà présente
                                aPair pair1 = make_pair(parent1, parent2);
                                aPair pair2 = make_pair(parent2, parent1);
                                table_iter b1 = table.find(pair1);
                                table_iter b2 = table.find(pair2);
                                table_iter e = table.end();
                                if((table.size() == 0) || ((b1 == e) && (b2 == e)) ){
                                        // On l'insère
                                        float weight = p1.getColor().distance(p2.getColor());
                                        Edge e(component[parent1], component[parent2], weight);
                                        int x0 = p1.getX();
                                        int y0 = p1.getY();
                                        int x1 = p2.getX();
                                        int y1 = p2.getY();
                                        e.setCoord(x0, y0, x1, y1);
                                        ret.addEdge(e);
                                        table.insert(make_pair(pair1, e));
                                }
                        }
                        if(parent1 != parent3){
                                // On regarde si l'arrête entre cluster est déjà présente
                                aPair pair1 = make_pair(parent1, parent3);
                                aPair pair2 = make_pair(parent3, parent1);
                                table_iter b1 = table.find(pair1);
                                table_iter b2 = table.find(pair2);
                                table_iter e = table.end();
                                if((table.size() == 0) || ((b1 == e) && (b2 == e)) ){
                                        // On l'insère
                                        float weight = p1.getColor().distance(p3.getColor());
                                        Edge e(component[parent1], component[parent3], weight);
                                        int x0 = p1.getX();
                                        int y0 = p1.getY();
                                        int x1 = p3.getX();
                                        int y1 = p3.getY();
                                        e.setCoord(x0, y0, x1, y1);
                                        ret.addEdge(e);
                                        table.insert(make_pair(pair1, e));
                                }
                        }
                        if(parent1 != parent4){
                                // On regarde si l'arrête entre cluster est déjà présente
                                aPair pair1 = make_pair(parent1, parent4);
                                aPair pair2 = make_pair(parent4, parent1);
                                table_iter b1 = table.find(pair1);
                                table_iter b2 = table.find(pair2);
                                table_iter e = table.end();
                                if((table.size() == 0) || ((b1 == e) && (b2 == e)) ){
                                        // On l'insère
                                        float weight = p1.getColor().distance(p4.getColor());
                                        Edge e(component[parent1], component[parent4], weight);
                                        int x0 = p1.getX();
                                        int y0 = p1.getY();
                                        int x1 = p4.getX();
                                        int y1 = p4.getY();
                                        e.setCoord(x0, y0, x1, y1);
                                        ret.addEdge(e);
                                        table.insert(make_pair(pair1, e));
                                }
                        }
                        if(j > 0){
                                // On regarde si l'arrête entre cluster est déjà présente
                                // noeud (j - 1 1, i + 1)
                                Pixel p5 = data[(i + 1) * width + j - 1];
                                int parent5 = parent[(i + 1) * width + j - 1];
                                if(parent1 != parent5){
                                        // On l'insère
                                        aPair pair1 = make_pair(parent1, parent5);
                                        aPair pair2 = make_pair(parent5, parent1);
                                        table_iter b1 = table.find(pair1);
                                        table_iter b2 = table.find(pair2);
                                        table_iter e = table.end();
                                        if((table.size() == 0) || ((b1 == e) && (b2 == e)) ){
                                                float weight = p1.getColor().distance(p5.getColor());
                                                Edge e(component[parent1], component[parent5], weight);
                                                int x0 = p1.getX();
                                                int y0 = p1.getY();
                                                int x1 = p5.getX();
                                                int y1 = p5.getY();
                                                e.setCoord(x0, y0, x1, y1);
                                                ret.addEdge(e);
                                                table.insert(make_pair(pair1, e));
                                        }
                                }
                        }
                }
        }
        {
                ostringstream o;
                o << "Nombre de composants " << ret.getNodeSize() << endl;
          trace.print(o.str());
        }
        {
                ostringstream o;                
                o << "Nombre d'arrêtes " << ret.getEdgeSize() << endl;
          trace.print(o.str());
        }
        return ret;
}
void PixelMap::findBorder(){
        Trace("findBorder", channelPixelMap);
        vector<bool> visited;
        for(int i = 0; i < data.size(); i++){
                visited.push_back(false);       
        }
        border.clear();
        for(int i = 0; i < (height - 1); i++){
                for(int j = 0; j < (width - 1); j++){
                        if(visited[i * width + j]){
                                continue;       
                        }
                        visited[i * width + j] = true;
                        // noeud (j, i)
                        int parent1 = parent[i * width + j];
                        // noeud (j + 1, i)
                        int parent2 = parent[i * width + j + 1];
                        // noeud (j, i + 1)
                        int parent3 = parent[(i + 1) * width + j];
                        // noeud (j + 1, i + 1)
                        int parent4 = parent[(i + 1) * width + j + 1];
                        if(parent1 != parent2){
                                border[i * width + j + 1] = true;
                                visited[i * width + j + 1] = true;
                        }
                        if(parent1 != parent3){
                                border[(i + 1) * width + j] = true;                             
                                visited[(i + 1) * width + j] = true;                                                            
                        }
                        if(parent1 != parent4){
                                border[(i + 1) * width + j + 1] = true;                 
                                visited[(i + 1) * width + j + 1] = true;                        
                        }
                        if(j > 0){
                                int parent5 = parent[(i + 1) * width + j - 1];
                                if(parent1 != parent5){
                                        border[(i + 1) * width + j - 1] = true;
                                        visited[(i + 1) * width + j - 1] = true;
                                }
                        }
                }
        }
}
void PixelMap::drawBorderPNG(string fileName){
        Trace("drawBorder", channelPixelMap);   
        findBorder();
        PNG output(width, height, PNG_GRAY, fileName);
        Color color;
        Color black(0);
        Color gray(225);
        for(int i = 0; i < data.size(); i++){
                Pixel pix = data[i];
                if(border[i]){
                        color = black;
                } else {
                        color = gray;
                }
                output.setColor(pix.getX(), pix.getY(), color);
        }
        output.write();
        
}

void PixelMap::parentToFile(string fileName)const{
        ofstream o(fileName.c_str());
        for(int i = 0; i < parent.size(); i++){
                        o << parent[i] << endl;
        }       
        o.close();
}

---