WebSVN – seema-scanner – Diff – /src/algorithm/AlgorithmPhaseShift.cpp


#include "AlgorithmPhaseShift.h"
#include <math.h>
 
#include "cvtools.h"
 
#ifndef M_PI
    #define M_PI 3.14159265358979323846
#endif
 
static unsigned int nPhases = 8;
 
// Algorithm
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;
}
 
AlgorithmPhaseShift::AlgorithmPhaseShift(unsigned int _screenCols, unsigned int _screenRows, CodingDir _dir) : Algorithm(_screenCols, _screenRows, _dir){
 
    // Set N
    if(dir == CodingDirBoth)
        this->N = 12;
    else
        this->N = 6;
 
    // Precompute encoded patterns
    const float pi = M_PI;
 
    if(dir & CodingDirHorizontal){
        // 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 & CodingDirVertical){
        // 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 AlgorithmPhaseShift::getEncodingPattern(unsigned int depth){
    return patterns[depth];
}
 
 
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 AlgorithmPhaseShift::get3DPoints(SMCalibrationParameters calibration, const std::vector<cv::Mat>& frames0, const std::vector<cv::Mat>& frames1, std::vector<cv::Point3f>& Q, std::vector<cv::Vec3b>& color){
 
}
 

Rev 41	Rev 42
1	`#include "AlgorithmPhaseShift.h"`	1	`#include "AlgorithmPhaseShift.h"`
2	`#include <math.h>`	2	`#include <math.h>`
3		3
4	`#include "cvtools.h"`	4	`#include "cvtools.h"`
5		5
6	`#ifndef M_PI`	6	`#ifndef M_PI`
7	`#define M_PI 3.14159265358979323846`	7	`#define M_PI 3.14159265358979323846`
8	`#endif`	8	`#endif`
9		9
10	`static unsigned int nPhases = 8;`	10	`static unsigned int nPhases = 8;`
11		11
12	`// Algorithm`	12	`// Algorithm`
13	`static cv::Mat computePhaseVector(unsigned int length, float phase, float pitch){`	13	`static cv::Mat computePhaseVector(unsigned int length, float phase, float pitch){`
14		14
15	`cv::Mat phaseVector(length, 1, CV_8UC3);`	15	`cv::Mat phaseVector(length, 1, CV_8UC3);`
16	`//phaseVector.setTo(0);`	16	`//phaseVector.setTo(0);`
17		17
18	`const float pi = M_PI;`	18	`const float pi = M_PI;`
19		19
20	`// Loop through vector`	20	`// Loop through vector`
21	`for(int i=0; i<phaseVector.rows; i++){`	21	`for(int i=0; i<phaseVector.rows; i++){`
22	`// Amplitude of channels`	22	`// Amplitude of channels`
23	`float amp = 0.5(1+cos(2pi*i/pitch + phase));`	23	`float amp = 0.5(1+cos(2pi*i/pitch + phase));`
24	`phaseVector.at<cv::Vec3b>(i, 0) = cv::Vec3b(255.0amp,255.0amp,255.0*amp);`	24	`phaseVector.at<cv::Vec3b>(i, 0) = cv::Vec3b(255.0amp,255.0amp,255.0*amp);`
25	`}`	25	`}`
26		26
27	`return phaseVector;`	27	`return phaseVector;`
28	`}`	28	`}`
29		29
30	`AlgorithmPhaseShift::AlgorithmPhaseShift(unsigned int _screenCols, unsigned int _screenRows, CodingDir _dir) : Algorithm(_screenCols, _screenRows, _dir){`	30	`AlgorithmPhaseShift::AlgorithmPhaseShift(unsigned int _screenCols, unsigned int _screenRows, CodingDir _dir) : Algorithm(_screenCols, _screenRows, _dir){`
31		31
32	`// Set N`	32	`// Set N`
33	`if(dir == CodingDirBoth)`	33	`if(dir == CodingDirBoth)`
34	`this->N = 12;`	34	`this->N = 12;`
35	`else`	35	`else`
36	`this->N = 6;`	36	`this->N = 6;`
37		37
38	`// Precompute encoded patterns`	38	`// Precompute encoded patterns`
39	`const float pi = M_PI;`	39	`const float pi = M_PI;`
40		40
41	`if(dir & CodingDirHorizontal){`	41	`if(dir & CodingDirHorizontal){`
42	`// Horizontally encoding patterns`	42	`// Horizontally encoding patterns`
43	`for(unsigned int i=0; i<3; i++){`	43	`for(unsigned int i=0; i<3; i++){`
44	`float phase = 2.0pi/3.0 (1.0 - (float)i);`	44	`float phase = 2.0pi/3.0 (1.0 - (float)i);`
45	`float pitch = (float)screenCols/(float)nPhases;`	45	`float pitch = (float)screenCols/(float)nPhases;`
46	`cv::Mat patternI(1,1,CV_8U);`	46	`cv::Mat patternI(1,1,CV_8U);`
47	`patternI = computePhaseVector(screenCols, phase, pitch);`	47	`patternI = computePhaseVector(screenCols, phase, pitch);`
48	`patternI = patternI.t();`	48	`patternI = patternI.t();`
49	`patterns.push_back(patternI);`	49	`patterns.push_back(patternI);`
50	`}`	50	`}`
51		51
52	`// Phase cue patterns`	52	`// Phase cue patterns`
53	`for(unsigned int i=0; i<3; i++){`	53	`for(unsigned int i=0; i<3; i++){`
54	`float phase = 2.0pi/3.0 (1.0 - (float)i);`	54	`float phase = 2.0pi/3.0 (1.0 - (float)i);`
55	`float pitch = screenCols;`	55	`float pitch = screenCols;`
56	`cv::Mat patternI;`	56	`cv::Mat patternI;`
57	`patternI = computePhaseVector(screenCols, phase, pitch);`	57	`patternI = computePhaseVector(screenCols, phase, pitch);`
58	`patternI = patternI.t();`	58	`patternI = patternI.t();`
59	`patterns.push_back(patternI);`	59	`patterns.push_back(patternI);`
60	`}`	60	`}`
61	`}`	61	`}`
62	`if(dir & CodingDirVertical){`	62	`if(dir & CodingDirVertical){`
63	`// Precompute vertically encoding patterns`	63	`// Precompute vertically encoding patterns`
64	`for(unsigned int i=0; i<3; i++){`	64	`for(unsigned int i=0; i<3; i++){`
65	`float phase = 2.0pi/3.0 (1.0 - (float)i);`	65	`float phase = 2.0pi/3.0 (1.0 - (float)i);`
66	`float pitch = (float)screenRows/(float)nPhases;`	66	`float pitch = (float)screenRows/(float)nPhases;`
67	`cv::Mat patternI;`	67	`cv::Mat patternI;`
68	`patternI = computePhaseVector(screenRows, phase, pitch);`	68	`patternI = computePhaseVector(screenRows, phase, pitch);`
69	`patterns.push_back(patternI);`	69	`patterns.push_back(patternI);`
70	`}`	70	`}`
71		71
72	`// Precompute vertically phase cue patterns`	72	`// Precompute vertically phase cue patterns`
73	`for(unsigned int i=0; i<3; i++){`	73	`for(unsigned int i=0; i<3; i++){`
74	`float phase = 2.0pi/3.0 (1.0 - (float)i);`	74	`float phase = 2.0pi/3.0 (1.0 - (float)i);`
75	`float pitch = screenRows;`	75	`float pitch = screenRows;`
76	`cv::Mat patternI;`	76	`cv::Mat patternI;`
77	`patternI = computePhaseVector(screenRows, phase, pitch);`	77	`patternI = computePhaseVector(screenRows, phase, pitch);`
78	`patterns.push_back(patternI);`	78	`patterns.push_back(patternI);`
79	`}`	79	`}`
80	`}`	80	`}`
81	`}`	81	`}`
82		82
83	`cv::Mat AlgorithmPhaseShift::getEncodingPattern(unsigned int depth){`	83	`cv::Mat AlgorithmPhaseShift::getEncodingPattern(unsigned int depth){`
84	`return patterns[depth];`	84	`return patterns[depth];`
85	`}`	85	`}`
86		86
87		87
88	`static cv::Mat absolutePhase(cv::Mat _I1, cv::Mat _I2, cv::Mat _I3){`	88	`static cv::Mat absolutePhase(cv::Mat _I1, cv::Mat _I2, cv::Mat _I3){`
89		89
90	`const float pi = M_PI;`	90	`const float pi = M_PI;`
91		91
92	`// Mat_ wrapper for easier indexing`	92	`// Mat_ wrapper for easier indexing`
93	`cv::Mat_<float> I1(_I1);`	93	`cv::Mat_<float> I1(_I1);`
94	`cv::Mat_<float> I2(_I2);`	94	`cv::Mat_<float> I2(_I2);`
95	`cv::Mat_<float> I3(_I3);`	95	`cv::Mat_<float> I3(_I3);`
96		96
97	`cv::Mat absPhase(I1.size(), CV_32F);`	97	`cv::Mat absPhase(I1.size(), CV_32F);`
98		98
99	`for(int i = 0; i < absPhase.rows; i++){`	99	`for(int i = 0; i < absPhase.rows; i++){`
100	`for(int j = 0; j < absPhase.cols; j++){`	100	`for(int j = 0; j < absPhase.cols; j++){`
101	`float phase = atan2(sqrt(3.0) * (I1(i,j)-I3(i,j)), I1(i,j) + I3(i,j) - 2.0*I2(i,j)) + pi;`	101	`float phase = atan2(sqrt(3.0) * (I1(i,j)-I3(i,j)), I1(i,j) + I3(i,j) - 2.0*I2(i,j)) + pi;`
102	`absPhase.at<float>(i,j) = phase;`	102	`absPhase.at<float>(i,j) = phase;`
103	`}`	103	`}`
104	`}`	104	`}`
105		105
106	`//absPhase.addref();`	106	`//absPhase.addref();`
107	`return absPhase;`	107	`return absPhase;`
108	`}`	108	`}`
109		109
110	`void AlgorithmPhaseShift::getCorrespondences(SMCalibrationParameters calibration, const std::vector<cv::Mat>& frames0, const std::vector<cv::Mat>& frames1, std::vector<cv::Point2f>& q0, std::vector<cv::Point2f>& q1, std::vector<cv::Point3f>& color){`	110	`void AlgorithmPhaseShift::get3DPoints(SMCalibrationParameters calibration, const std::vector<cv::Mat>& frames0, const std::vector<cv::Mat>& frames1, std::vector<cv::Point3f>& Q, std::vector<cv::Vec3b>& color){`
111		111
112	`}`	112	`}`
113		113

Subversion Repositories seema-scanner

(root)/src/algorithm/AlgorithmPhaseShift.cpp @ 59 – Rev 41 → 42