Subversion Repositories seema-scanner

// The number of periods in the primary and secondary frequencies can be chosen freely, but small changes can have a considerable impact on quality.

// The number of periods in the First and Second frequencies can be chosen freely, but small changes can have a considerable impact on quality.

// The number of phase shifts can be chosen freely (min. 3), and higher values reduce the effects of image noise. They also allow us to filter bad points based on energy at non-primary frequencies.

// The number of phase shifts can be chosen freely (min. 3), and higher values reduce the effects of image noise. They also allow us to filter bad points based on energy at non-First frequencies.

static unsigned int nStepsPrimary = 8; // number of shifts/steps in primary

static unsigned int nStepsFirst = 8; // number of shifts/steps in First

static unsigned int nStepsSecondary = 8; // number of shifts/steps in secondary

static unsigned int nStepsSecond = 8; // number of shifts/steps in Second

static unsigned int nStepsTertiary = 8; // number of shifts/steps in tertiary

static unsigned int nStepsThird = 8; // number of shifts/steps in Third

static float nPeriodsPrimary = 24; // primary period

static float nPeriodsFirst = 24; // First period

static float nPeriodsSecondary = 30; // primary period

static float nPeriodsSecond = 30; // First period

    N = 2+nStepsPrimary+nStepsSecondary+nStepsTertiary;

    N = 2+nStepsFirst+nStepsSecond+nStepsThird;

    // Determine the tertiary period to fulfill the heterodyne condition

    // Determine the Third period to fulfill the heterodyne condition

    float nPeriodsTertiary = (screenCols*nPeriodsPrimary*nPeriodsSecondary)/(nPeriodsPrimary*nPeriodsSecondary+2*screenCols*nPeriodsPrimary-screenCols*nPeriodsSecondary);

    float nPeriodsThird = 1 + 2*nPeriodsSecond - nPeriodsFirst;

    // Primary encoding patterns

    // First encoding patterns

    for(unsigned int i=0; i<nStepsPrimary; i++){

    for(unsigned int i=0; i<nStepsFirst; i++){

        float phase = 2.0*pi/nStepsPrimary * i;

        float phase = 2.0*pi/nStepsFirst * i;

        float pitch = screenCols/nPeriodsPrimary;

        float pitch = screenCols/nPeriodsFirst;

    // Secondary encoding patterns

    // Second encoding patterns

    for(unsigned int i=0; i<nStepsSecondary; i++){

    for(unsigned int i=0; i<nStepsSecond; i++){

        float phase = 2.0*pi/nStepsSecondary * i;

        float phase = 2.0*pi/nStepsSecond * i;

        float pitch = screenCols/nPeriodsSecondary;

        float pitch = screenCols/nPeriodsSecond;

    // Tertiary encoding patterns

    // Third encoding patterns

    for(unsigned int i=0; i<nStepsTertiary; i++){

    for(unsigned int i=0; i<nStepsThird; i++){

        float phase = 2.0*pi/nStepsTertiary * i;

        float phase = 2.0*pi/nStepsThird * i;

        float pitch = screenCols/nPeriodsTertiary;

        float pitch = screenCols/nPeriodsThird;

    std::vector<cv::Mat> frames0Primary(frames0Rect.begin()+2, frames0Rect.begin()+2+nStepsPrimary);

    std::vector<cv::Mat> frames0First(frames0Rect.begin()+2, frames0Rect.begin()+2+nStepsFirst);

    std::vector<cv::Mat> frames0Secondary(frames0Rect.begin()+2+nStepsPrimary, frames0Rect.end()-nStepsTertiary);

    std::vector<cv::Mat> frames0Second(frames0Rect.begin()+2+nStepsFirst, frames0Rect.end()-nStepsThird);

    std::vector<cv::Mat> frames0Tertiary(frames0Rect.end()-nStepsTertiary, frames0Rect.end());

    std::vector<cv::Mat> frames0Third(frames0Rect.end()-nStepsThird, frames0Rect.end());

    std::vector<cv::Mat> F0Primary = getDFTComponents(frames0Primary);

    std::vector<cv::Mat> F0First = getDFTComponents(frames0First);

    cv::Mat up0Primary;

    cv::Mat up0First;

    cv::phase(F0Primary[2], -F0Primary[3], up0Primary);

    cv::phase(F0First[2], -F0First[3], up0First);

    std::vector<cv::Mat> F0Secondary = getDFTComponents(frames0Secondary);

    std::vector<cv::Mat> F0Second = getDFTComponents(frames0Second);

    cv::Mat up0Secondary;

    cv::Mat up0Second;

    cv::phase(F0Secondary[2], -F0Secondary[3], up0Secondary);

    cv::phase(F0Second[2], -F0Second[3], up0Second);

    std::vector<cv::Mat> F0Tertiary = getDFTComponents(frames0Tertiary);

    std::vector<cv::Mat> F0Third = getDFTComponents(frames0Third);

    cv::Mat up0Tertiary;

    cv::Mat up0Third;

    cv::phase(F0Tertiary[2], -F0Tertiary[3], up0Tertiary);

    cv::phase(F0Third[2], -F0Third[3], up0Third);

    cv::Mat up0EquivalentPS = up0Primary - up0Secondary;

    cv::Mat up0EquivalentPS = up0First - up0Second;

    cv::Mat up0EquivalentPT = up0Primary - up0Tertiary;

    cv::Mat up0EquivalentPT = up0First - up0Third;

    cv::Mat up0Equivalent = up0EquivalentPS - up0EquivalentPT;

    cv::Mat up0EquivalentPST = up0EquivalentPS - up0EquivalentPT;

    up0Equivalent = cvtools::modulo(up0Equivalent, 2.0*pi);

    up0EquivalentPST = cvtools::modulo(up0EquivalentPST, 2.0*pi);

    cv::Mat up0 = unwrapWithCue(up0Primary, up0Equivalent, (float)screenCols/nPeriodsPrimary);

    cv::Mat up0 = unwrapWithCue(up0First, up0EquivalentPST, (float)screenCols/nPeriodsFirst);

    cv::magnitude(F0Primary[2], -F0Primary[3], amplitude0);

    cv::magnitude(F0First[2], -F0First[3], amplitude0);

    std::vector<cv::Mat> frames1Primary(frames1Rect.begin()+2, frames1Rect.begin()+2+nStepsPrimary);

    std::vector<cv::Mat> frames1First(frames1Rect.begin()+2, frames1Rect.begin()+2+nStepsFirst);

    std::vector<cv::Mat> frames1Secondary(frames1Rect.begin()+2+nStepsPrimary, frames1Rect.end()-nStepsTertiary);

    std::vector<cv::Mat> frames1Second(frames1Rect.begin()+2+nStepsFirst, frames1Rect.end()-nStepsThird);

    std::vector<cv::Mat> frames1Tertiary(frames1Rect.end()-nStepsTertiary, frames1Rect.end());

    std::vector<cv::Mat> frames1Third(frames1Rect.end()-nStepsThird, frames1Rect.end());

    std::vector<cv::Mat> F1Primary = getDFTComponents(frames1Primary);

    std::vector<cv::Mat> F1First = getDFTComponents(frames1First);

    cv::Mat up1Primary;

    cv::Mat up1First;

    cv::phase(F1Primary[2], -F1Primary[3], up1Primary);

    cv::phase(F1First[2], -F1First[3], up1First);

    std::vector<cv::Mat> F1Secondary = getDFTComponents(frames1Secondary);

    std::vector<cv::Mat> F1Second = getDFTComponents(frames1Second);

    cv::Mat up1Secondary;

    cv::Mat up1Second;

    cv::phase(F1Secondary[2], -F1Secondary[3], up1Secondary);

    cv::phase(F1Second[2], -F1Second[3], up1Second);

    std::vector<cv::Mat> F1Tertiary = getDFTComponents(frames1Tertiary);

    std::vector<cv::Mat> F1Third = getDFTComponents(frames1Third);

    cv::Mat up1Tertiary;

    cv::Mat up1Third;

    cv::phase(F1Tertiary[2], -F1Tertiary[3], up1Tertiary);

    cv::phase(F1Third[2], -F1Third[3], up1Third);

    cv::Mat up1EquivalentPS = up1Primary - up1Secondary;

    cv::Mat up1EquivalentPS = up1First - up1Second;

    cv::Mat up1EquivalentST = up1Secondary - up1Tertiary;

    cv::Mat up1EquivalentST = up1Second - up1Third;

    cv::Mat up1Equivalent = up1EquivalentPS - up1EquivalentST;

    cv::Mat up1EquivalentPST = up1EquivalentPS - up1EquivalentST;

    up1Equivalent = cvtools::modulo(up1Equivalent, 2.0*pi);

    up1EquivalentPST = cvtools::modulo(up1EquivalentPST, 2.0*pi);

    cv::Mat up1 = unwrapWithCue(up1Primary, up1Equivalent, (float)screenCols/nPeriodsPrimary);

    cv::Mat up1 = unwrapWithCue(up1First, up1EquivalentPST, (float)screenCols/nPeriodsFirst);

    cv::magnitude(F1Primary[2], -F1Primary[3], amplitude1);

    cv::magnitude(F1First[2], -F1First[3], amplitude1);

        cvtools::writeMat(up0Primary, "up0Primary.mat", "up0Primary");

        cvtools::writeMat(up0First, "up0First.mat", "up0First");

        cvtools::writeMat(up0Secondary, "up0Secondary.mat", "up0Secondary");

        cvtools::writeMat(up0Second, "up0Second.mat", "up0Second");

        cvtools::writeMat(up0Tertiary, "up0Tertiary.mat", "up0Tertiary");

        cvtools::writeMat(up0Third, "up0Third.mat", "up0Third");

        cvtools::writeMat(up0Equivalent, "up0Equivalent.mat", "up0Equivalent");

        cvtools::writeMat(up0EquivalentPST, "up0EquivalentPST.mat", "up0EquivalentPST");