window_rgb_image_test.cpp

Go to the documentation of this file.

#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>

#include <fstream>

#include <types/MNISTTypes.hpp>
#include <types/TensorTypes.hpp>

#include <logger/Log.hpp>
#include <logger/ConsoleOutput.hpp>
using namespace mic::logger;

#include <importers/CIFARImporter.hpp>
#include <importers/BMPImporter.hpp>

#include <opengl/visualization/WindowManager.hpp>
#include <opengl/visualization/WindowRGBTensor.hpp>
using namespace mic::opengl::visualization;

WindowRGBTensor<float>* w_batch;


void test_thread_body (void) {

    // Import exemplary BMPs.
    mic::importers::BMPImporter<float> importer;
    importer.setDataFilename("../../../data/rainbow.bmp");
    /*mic::importers::CIFARImporter<float> importer;
    importer.setDataFilename("../data/cifar-10-batches-bin/data_batch_1.bin;../data/cifar-10-batches-bin/data_batch_2.bin");*/
    if (!importer.importData())
        return;

    importer.setBatchSize(4);

    // Main application loop.
    while (!APP_STATE->Quit()) {

        // If not paused.
        if (!APP_STATE->isPaused()) {

            // If single step mode - pause after the step.
            if (APP_STATE->isSingleStepModeOn())
                APP_STATE->pressPause();

            { // Enter critical section - with the use of scoped lock from AppState!
                APP_DATA_SYNCHRONIZATION_SCOPED_LOCK();

                // Select random sample/batch.
                //mic::types::TensorSample<float> sample = importer.getRandomSample();
                mic::types::TensorBatch<float> batch = importer.getRandomBatch();

                // Set sample/batch to be displayed.
                w_batch->setBatchUnsynchronized(batch.data());
                //w_batch->setSampleUnsynchronized(sample.data());
            }//: end of critical section

        }//: if

        // Sleep.
        APP_SLEEP();
    }//: while

}//: image_encoder_and_visualization_test



int main(int argc, char* argv[]) {
    // Set console output to logger.
    LOGGER->addOutput(new ConsoleOutput());
    LOG(LINFO) << "Logger initialized. Starting application";
    //LOGGER->setSeverityLevel(Debug);

    // Initialize GLUT! :]
    VGL_MANAGER->initializeGLUT(argc, argv);

    // Create two visualization windows - in the same, main thread :]
    w_batch = new WindowRGBTensor<float>("Batch", RGB::Chan_RGB, RGB::Norm_None, RGB::Grid_Batch, 0, 0, 3*512, 512);

    boost::thread test_thread(boost::bind(&test_thread_body));

    // Start visualization thread.
    VGL_MANAGER->startVisualizationLoop();

    LOG(LINFO) << "Waiting for threads to join...";
    // End test thread.
    test_thread.join();
    LOG(LINFO) << "Threads joined - ending application";
}//: main