MeanShift.cpp

Aller à la documentation de ce fichier.

/// \file 
/// Implémentation des classes pour le Meanshift
#include "MeanShift.hpp"
///////////////////////////////////////////////////////////////////////////////
/// Lattice
///////////////////////////////////////////////////////////////////////////////
Lattice::Lattice(PNG _image):
        image(_image), 
        width(_image.getWidth()),
        height(_image.getHeight()){
                size = width * height;
                visited.reserve(size);
                state.reserve(size);
                for(int i = 0; i < size; i++){
                        visited.push_back(0);
                        state.push_back(ELATTICE_NO_MODE);
                }
                input.resize(size);
                output.resize(size);            
}
int Lattice::getWidth()const{
        return width;
}
int Lattice::getHeight()const{
        return height;  
}
FVector Lattice::getFVector(int x, int y){
        int rank = (y * width) + x;
        if(visited[rank] == 0){
                Color c = image.getColor(x, y);
                FVector v(x, y, c.getHue(), c.getSaturation(), c.getValue());
                input[rank] = v;
                visited[rank]++;
        } 
        return input[rank];
}
void Lattice::setOutputFVector(const int x, const int y, const FVector v){
        int rank = (y * width) + x;
        output[rank] = v;
}
FVector Lattice::getOutputFVector(const int x, const int y)const{
        int rank = (y * width) + x;
        return output[rank];
}

ELATTICE_STATE Lattice::getState(int x, int y)const{
        int rank = (y * width) + x;
        return state[rank];     
}
void Lattice::setState(const int x, const int y, const ELATTICE_STATE _state){
        int rank = (y * width) + x;
        state[rank] = _state;
}
///////////////////////////////////////////////////////////////////////////////
/// MeanShiftWindow
///////////////////////////////////////////////////////////////////////////////
MeanShiftWindow::MeanShiftWindow(int _size, float _radius, Lattice& _lattice):
        size(_size),
        radius(_radius),
        lattice(_lattice){
        }

string MeanShiftWindow::toString()const{
        ostringstream o;
        o << "size " << size << " radius " <<  radius << " " << center.toString();
        string ret = o.str();
        return ret;
}

void MeanShiftWindow::setCenter(const int x, const int y){
        FVector point = lattice.getFVector(x, y);
        center = point;
}

void MeanShiftWindow::findPixel(){
        data.clear();
        int width = lattice.getWidth();
        int height = lattice.getHeight();
        
        int startX = ((int)(center[0])) - size;
        if(startX < 0){
                startX = 0;     
        }
        int startY = ((int)(center[1])) - size;
        if(startY < 0){
                startY = 0;     
        }
        int endX = ((int)(center[0])) + size;
        if(endX >= width){
                endX = width - 1;       
        }
        int endY = ((int)(center[1])) + size;
        if(endY >= height){
                        endY = height - 1;
        }
        float centerColor[3];
        centerColor[0] = center[2];
        centerColor[1] = center[3];
        centerColor[2] = center[4];             
        for(int i = startX; i <= endX; i++){
                for(int j = startY; j <= endY; j++){
                        FVector ta = lattice.getFVector(i, j);
                        float color[3];                 
                        color[0] = ta[2];
                        color[1] = ta[3];
                        color[2] = ta[4];               
                        if(Color::inWindow(centerColor, radius, color)){
                                data.push_back(ta);
                        }
                }
        }
}
float MeanShiftWindow::computeMean(){
        float wSize = data.size();
        FVector mean;
        for(int i = 0; i < data.size(); i++){
                FVector fv = data[i];
                mean += fv;
        }
        mean /= wSize;
        float ret = norm(center, mean);
        center = mean;  

        return ret;
}
FVector MeanShiftWindow::getCenter() const{
        return center;
}
///////////////////////////////////////////////////////////////////////////////
/// MeanShift
///////////////////////////////////////////////////////////////////////////////
MeanShift::MeanShift(int _size, float _radius, PNG _image, float _tol, int _maxIter):
        size(_size),
        radius(_radius),
        lattice(_image),
        window(_size, _radius, lattice),
        tol(_tol),
        maxIter(_maxIter){
        }
string MeanShift::toString()const{
        ostringstream o;
        o << window.toString() << "\n";
        string ret = o.str();
        return ret;
}

void MeanShift::findMode(const int i, const int j){
        if(ELATTICE_HAS_MODE == lattice.getState(i, j)){
                return; 
        }

        int count = 0;
        float norm = 0.0;
        FVector center;
        vector<FVector> lPoint;
        window.setCenter(i, j); 
        do{
                window.findPixel();
                norm = window.computeMean();
                center = window.getCenter();
                int xCandidate = (int)(center[0] + 0.5);
                int yCandidate = (int)(center[1] + 0.5);
                FVector candidate = lattice.getFVector(xCandidate, yCandidate);
                float diff = normColor(center, candidate);
                ELATTICE_STATE state = lattice.getState(xCandidate, yCandidate);                
                if(diff < 0.01){
                        switch(state){
                                case ELATTICE_NO_MODE:
                                {
                                        lPoint.push_back(candidate);
                                        lattice.setState(xCandidate, yCandidate, ELATTICE_CANDIDATE_MODE);
                                }
                                break;
                                case ELATTICE_CANDIDATE_MODE:
                                {
                                }
                                break;                          
                        }
                }
                if(state == ELATTICE_HAS_MODE){
                        break;  
                }
                count++;
        }while(count < maxIter && norm > tol);
        lattice.setOutputFVector(i, j, center);
        lattice.setState(i, j, ELATTICE_HAS_MODE);
        for(int k = 0; k < lPoint.size(); k++){
                FVector v = lPoint[k];
                int x = v.getX();
                int y = v.getY();
                lattice.setOutputFVector(x, y, v);
                lattice.setState(x, y, ELATTICE_HAS_MODE);              
        }
}
void MeanShift::doFilter(){
  Trace trace("doFilter", channelMeanShift);
        int width = lattice.getWidth();
        int height = lattice.getHeight();

        for(int i = 0; i < width; i++){
                for(int j = 0; j < height; j++){
                        findMode(i, j);
                }
        }
}

Node MeanShift::makeNode(){
        int w = lattice.getWidth();
        int h = lattice.getHeight();
        PixelMap pmap(w, h);
        for(int i = 0; i < w; i++){
                for(int j = 0; j < h; j++){
                        FVector v = lattice.getOutputFVector(i, j);
                        Color color(v[2], v[3], v[4], false);
                        Pixel pixel(i, j, color);
                        pmap.addPixel(pixel);
                }       
        }
        Node ret = pmap.makeComponent();
        return ret;
}

---