test.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include <mrpt/gui.h>
#include <mrpt/math/CMatrix.h>
#include <mrpt/img/CImage.h>
#include <mrpt/system/CTicTac.h>
#include <mrpt/math/fourier.h>
#include <iostream>
 
using namespace mrpt;
using namespace mrpt::math;
using namespace mrpt::gui;
using namespace mrpt::system;
using namespace mrpt::img;
using namespace std;
 
#include <mrpt/examples_config.h>
string myDataDir(
        MRPT_EXAMPLES_BASE_DIRECTORY +
        string("img_correlation_example/"));  // Reuse it's images
 
// ------------------------------------------------------
//                              TestFFT_2D_real
// ------------------------------------------------------
void TestFFT_2D_real()
{
        CMatrix A, RES_R, RES_I, B, D;
        CTicTac tictac;
 
        printf("Loading matrix from file...");
        A.loadFromTextFile("dft2_test.txt");
        printf("ok\n");
 
        printf(
                "Computing 2D FFT of %ux%u...", (unsigned int)A.rows(),
                (unsigned int)A.cols());
        tictac.Tic();
        math::dft2_real(A, RES_R, RES_I);
        printf(" Done,%.06fms\n", tictac.Tac() * 1000.0f);
 
        RES_R.saveToTextFile("_out_dft2_real.txt");
        RES_I.saveToTextFile("_out_dft2_imag.txt");
 
        printf(
                "Computing 2D IFFT of %ux%u...", (unsigned int)A.rows(),
                (unsigned int)A.cols());
        tictac.Tic();
        math::idft2_real(RES_R, RES_I, B);
        printf(" Done,%.06fms\n", tictac.Tac() * 1000.0f);
 
        //      B.saveToTextFile("_out_ifft2.txt");
        D = B - A;
        //      D.saveToTextFile("_out_dft2_error_diffs.txt");
 
        float maxError;
        size_t u, v;
        D.find_index_max_value(u, v, maxError);
 
        printf("Maximum error between 'A' and 'IFFT(FFT(A))'=%e\n", maxError);
}
 
// ------------------------------------------------------
//                              TestFFT_2D_complex
// ------------------------------------------------------
void TestFFT_2D_complex()
{
        CMatrix DATA_R, DATA_I, RES_R, RES_I, B_R, B_I, D_R, D_I;
        CTicTac tictac;
 
        printf("Loading matrix from file...");
        DATA_R.loadFromTextFile("complex_dft2_test_real.txt");
        DATA_I.loadFromTextFile("complex_dft2_test_imag.txt");
        printf("ok\n");
 
        printf(
                "Computing 2D complex FFT of %ux%u...", (unsigned int)DATA_R.rows(),
                (unsigned int)DATA_R.cols());
        tictac.Tic();
        math::dft2_complex(DATA_R, DATA_I, RES_R, RES_I);
        printf(" Done,%.06fms\n", tictac.Tac() * 1000.0f);
 
        RES_R.saveToTextFile("_out_complex_dft2_real.txt");
        RES_I.saveToTextFile("_out_complex_dft2_imag.txt");
 
        printf(
                "Computing 2D complex IFFT of %ux%u...", (unsigned int)DATA_R.rows(),
                (unsigned int)DATA_R.cols());
        tictac.Tic();
        math::idft2_complex(RES_R, RES_I, B_R, B_I);
        printf(" Done,%.06fms\n", tictac.Tac() * 1000.0f);
 
        //      B.saveToTextFile("_out_ifft2.txt");
        D_R = B_R - DATA_R;
        D_I = B_I - DATA_I;
        //      D.saveToTextFile("_out_dft2_error_diffs.txt");
 
        float maxError_R, maxError_I;
        size_t u, v;
        D_R.find_index_max_value(u, v, maxError_R);
        D_I.find_index_max_value(u, v, maxError_I);
 
        printf("Maximum error between 'A' and 'IFFT(FFT(A))'=%e\n", maxError_R);
        printf("Maximum error between 'A' and 'IFFT(FFT(A))'=%e\n", maxError_I);
}
 
// ------------------------------------------------------
//                              TestImageFFT
// ------------------------------------------------------
void TestImageFFT()
{
        CTicTac tictac;
        CImage IM1, IM2;
        CMatrix imgCorr;
 
        IM1.loadFromFile(
                myDataDir + string("fft2_test_image_patch.jpg"), 0);  // "Patch"
        IM2.loadFromFile(
                myDataDir + string("fft2_test_image.jpg"), 0);  // Ref. image
 
        printf("Computing images correlation...");
        tictac.Tic();
        IM2.cross_correlation_FFT(IM1, imgCorr);
        printf(" Done,%.06fms\n", tictac.Tac() * 1000.0f);
 
        imgCorr.saveToTextFile("_out_dft2_image_test.txt");
}
 
// ------------------------------------------------------
//                              TestImageCap
// ------------------------------------------------------
void TestImage3D()
{
        /*      // Pixels -> 3D
                CMatrix         A = VisionUtils::defaultIntrinsicParamsMatrix();
                CPoint3D        p;
 
                FILE    *f=fopen("test.txt","wt");
                for (int x=0;x<320;x+=10)
                        for (int y=0;y<240;y+=10)
                                for (int d=1;d<20;d+=1)
                                {
                                        p = VisionUtils::pixelTo3D(x,y, A);
                                        fprintf(f,"%f %f %f\n",p.x,p.y,p.z);
                                }
 
                fclose(f);
 
                return;
        */
}
 
// ------------------------------------------------------
//                              TestImageCap
// ------------------------------------------------------
void TestImageConversion()
{
        // BMP -> JPEG conversion tester:
        // --------------------------------
        CImage img, img2;
        CTicTac tictac;
 
        {
                tictac.Tic();
                if (!img.loadFromFile("../img_basic_example/frame_color.bmp"))
                {
                        cerr << "Error loading ../img_basic_example/frame_color.bmp"
                                 << endl;
                        return;
                }
                printf("bmp file loaded in %.03fms\n", 1000.0f * tictac.Tac());
 
                CDisplayWindow win1("BMP file, color");
                win1.showImage(img);
                win1.waitForKey();
 
                tictac.Tic();
                img.loadFromFile("frame_gray.bmp");
                printf("bmp file loaded in %.03fms\n", 1000.0f * tictac.Tac());
 
                CDisplayWindow win2("BMP file, gray");
 
                win2.showImage(img);
                win2.waitForKey();
        }
 
        tictac.Tic();
        img.loadFromFile("frame.jpg");
        printf("jpeg file loaded in %.03fms\n", 1000.0f * tictac.Tac());
 
        CDisplayWindow win1("win1"), win2("win2"), win3("win3");
 
        CImage imgSmall(img.scaleHalf());
        CImage imgSmall2(imgSmall.scaleHalf());
        CImage imgGray(imgSmall2.grayscale());
 
        // Test some draw capabilities:
        // ---------------------------------
        imgSmall.rectangle(85, 35, 170, 170, TColor(255, 0, 0), 10);
 
        imgSmall.line(550, 75, 650, 25, TColor(0, 0, 255));
        imgSmall.line(-10, -20, 20, 30, TColor(0, 0, 255));
 
        CMatrix COV(2, 2);
        COV(0, 0) = 100;
        COV(1, 1) = 50;
        COV(0, 1) = COV(1, 0) = -30;
        imgSmall.ellipseGaussian(&COV, 600.0f, 50.0f, 2, TColor(255, 255, 0), 4);
        imgGray.ellipseGaussian(&COV, 100.0f, 100.0f, 2, TColor(0, 0, 255), 4);
 
        imgSmall.drawImage(400, 500, imgGray);
 
        // Show the windows now:
        // ------------------------------------------------------
        win1.showImage(imgSmall);
        win1.setPos(0, 0);
        win2.showImage(imgSmall2);
        win2.setPos(810, 0);
        win3.showImage(imgGray);
        win3.setPos(810, 400);
 
        os::getch();
 
        tictac.Tic();
        img2.saveToFile("frame_out.jpg");
        printf("jpeg file loaded in %.03fms\n", 1000.0f * tictac.Tac());
 
        return;
}
 
// ------------------------------------------------------
//                              TestImageCap
// ------------------------------------------------------
/*void TestImageCap()
{
        CTicTac                                                 tictac;
        bool                                                    ok = true;
 
        CImageGrabber_OpenCV            cap( 0 );
        CObservationImage                               obs;
        CDisplayWindow                                  win("Capture");
 
 
        while (ok && !_kbhit())
        {
                std::this_thread::sleep_for(10ms);
                tictac.Tic();
                        ok = cap.getObservation( obs );
                printf("Frame grabbed in %.03fms\n", 1000.0f*tictac.Tac() );
 
 
                if (ok)
                {
//                      CImageFloat             img2; img2 = obs.image;
//                      win.showImage( obs.image.grayscale() );
 
                        win.showImage( obs.image );
                }
        };
 
 
        if (_kbhit()) _getch();
}
*/
// ------------------------------------------------------
//                                              MAIN
// ------------------------------------------------------
int main()
{
        try
        {
                TestImageFFT();
 
                // TestFFT_2D_real();
                // TestFFT_2D_complex();
                // TestImageFFT();
                // TestImageCap();
                // TestImageConversion();
 
                return 0;
        }
        catch (std::exception& e)
        {
                std::cout << "MRPT exception caught: " << e.what() << std::endl;
                return -1;
        }
        catch (...)
        {
                printf("Untyped exception!!");
                return -1;
        }
}