Subversion Repositories seema-scanner

#include "CodecPhaseShift2x3.h"
#include <math.h>

#include "cvtools.h"

#ifndef M_PI
    #define M_PI 3.14159265358979323846
#endif

static unsigned int nPhases = 8;

// Encoder
static cv::Mat computePhaseVector(unsigned int length, float phase, float pitch){

    cv::Mat phaseVector(length, 1, CV_8UC3);
    //phaseVector.setTo(0);

    const float pi = M_PI;

    // Loop through vector
    for(int i=0; i<phaseVector.rows; i++){
        // Amplitude of channels
        float amp = 0.5*(1+cos(2*pi*i/pitch + phase));
        phaseVector.at<cv::Vec3b>(i, 0) = cv::Vec3b(255.0*amp,255.0*amp,255.0*amp);
    }

    return phaseVector;
}

EncoderPhaseShift2x3::EncoderPhaseShift2x3(unsigned int _screenCols, unsigned int _screenRows, CodecDir _dir) : Encoder(_screenCols, _screenRows, _dir){

    // Set N
    if(dir == CodecDirBoth)
        this->N = 12;
    else
        this->N = 6;

    // Precompute encoded patterns
    const float pi = M_PI;

    if(dir & CodecDirHorizontal){
        // Horizontally encoding patterns
        for(unsigned int i=0; i<3; i++){
            float phase = 2.0*pi/3.0 * (1.0 - (float)i);
            float pitch = (float)screenCols/(float)nPhases;
            cv::Mat patternI(1,1,CV_8U);
            patternI = computePhaseVector(screenCols, phase, pitch);
            patternI = patternI.t();
            patterns.push_back(patternI);
        }

        // Phase cue patterns
        for(unsigned int i=0; i<3; i++){
            float phase = 2.0*pi/3.0 * (1.0 - (float)i);
            float pitch = screenCols;
            cv::Mat patternI;
            patternI = computePhaseVector(screenCols, phase, pitch);
            patternI = patternI.t();
            patterns.push_back(patternI);
        }
    }
    if(dir & CodecDirVertical){
        // Precompute vertically encoding patterns
        for(unsigned int i=0; i<3; i++){
            float phase = 2.0*pi/3.0 * (1.0 - (float)i);
            float pitch = (float)screenRows/(float)nPhases;
            cv::Mat patternI;
            patternI = computePhaseVector(screenRows, phase, pitch);
            patterns.push_back(patternI);
        }

        // Precompute vertically phase cue patterns
        for(unsigned int i=0; i<3; i++){
            float phase = 2.0*pi/3.0 * (1.0 - (float)i);
            float pitch = screenRows;
            cv::Mat patternI;
            patternI = computePhaseVector(screenRows, phase, pitch);
            patterns.push_back(patternI);
        }
    }
}

cv::Mat EncoderPhaseShift2x3::getEncodingPattern(unsigned int depth){
    return patterns[depth];
}

// Decoder
DecoderPhaseShift2x3::DecoderPhaseShift2x3(unsigned int _screenCols, unsigned int _screenRows, CodecDir _dir) : Decoder(_screenCols, _screenRows, _dir){

    if(dir == CodecDirBoth)
        this->N = 12;
    else
        this->N = 6;

    frames.resize(N);
}

void DecoderPhaseShift2x3::setFrame(unsigned int depth, cv::Mat frame){
    frames[depth] = frame;
}

static cv::Mat absolutePhase(cv::Mat _I1, cv::Mat _I2, cv::Mat _I3){

    const float pi = M_PI;

    // Mat_ wrapper for easier indexing
    cv::Mat_<float> I1(_I1);
    cv::Mat_<float> I2(_I2);
    cv::Mat_<float> I3(_I3);

    cv::Mat absPhase(I1.size(), CV_32F);

    for(int i = 0; i < absPhase.rows; i++){
        for(int j = 0; j < absPhase.cols; j++){
            float phase = atan2(sqrt(3.0) * (I1(i,j)-I3(i,j)), I1(i,j) + I3(i,j) - 2.0*I2(i,j)) + pi;
            absPhase.at<float>(i,j) = phase;
        }
    }

    //absPhase.addref();
    return absPhase;
}

void DecoderPhaseShift2x3::decodeFrames(cv::Mat &up, cv::Mat &vp, cv::Mat &mask, cv::Mat &shading){

    const float pi = M_PI;

    if(dir & CodecDirHorizontal){
        std::vector<cv::Mat> framesHorz(frames.begin(), frames.begin()+6);

        // Horizontal decoding
        up = absolutePhase(framesHorz[0], framesHorz[1], framesHorz[2]);

        cv::Mat upPhaseCue = absolutePhase(framesHorz[3], framesHorz[4], framesHorz[5]);
        upPhaseCue = (upPhaseCue*nPhases-up)/(2*pi);
        upPhaseCue.convertTo(upPhaseCue, CV_8U);
        upPhaseCue.convertTo(upPhaseCue, CV_32F);

        // unwrap absolute phase using phase cue
        up += upPhaseCue*2*pi;
        up *= screenCols/(2*pi*nPhases);
    }
    if(dir & CodecDirVertical){
        std::vector<cv::Mat> framesVert(frames.end()-6, frames.end());

        // Vertical decoding
        vp = absolutePhase(framesVert[0], framesVert[1], framesVert[2]);

        cv::Mat vpPhaseCue = absolutePhase(framesVert[3], framesVert[4], framesVert[5]);
        vpPhaseCue = (vpPhaseCue*nPhases-vp)/(2*pi);
        vpPhaseCue.convertTo(vpPhaseCue, CV_8U);
        vpPhaseCue.convertTo(vpPhaseCue, CV_32F);

        // unwrap absolute phase using phase cue
        vp += vpPhaseCue*2*pi;
        vp *= screenRows/(2*pi*nPhases);
    }

    // Calculate modulation
    cv::Mat I1, I2, I3;
    frames[3].convertTo(I1, CV_32F);
    frames[4].convertTo(I2, CV_32F);
    frames[5].convertTo(I3, CV_32F);
    cv::Mat modulation;
    modulation = 3.0*(I1-I3).mul(I1-I3) + (2.0*I2-I1-I3).mul(2.0*I2-I1-I3);
    cv::sqrt(modulation, modulation);
    modulation.convertTo(shading, CV_8U);
    //shading = (1.0/3.0)*(framesHorz[3]+framesHorz[4]+framesHorz[5]);

    // Threshold modulation image for mask
    mask = shading > 50;

    cv::Mat element = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(7,7));
    cv::erode(mask, mask, element);
}