|| || || || || || || ||

---

mainTiming.cpp

Go to the documentation of this file.

#include <vector>
#include "Basis/CmdOptions.h"
#include "Basis/Timer.h"
#include "Util/TimePlot.h"
#include "Core/Array/Arrays.h"
#include "Core/Array/Set.h"
#include "Core/Array/RGB2Intensity.h"
#include "Core/Array/GaussDerivative.h"
#include "Core/Array/RecGauss.h"
#include "Core/Array/RecGabor.h"
#include "Core/Array/ReadRaw.h"
#include "Core/Array/WriteRaw.h"
#include "Core/Array/Norm2.h"

namespace Impala
{
namespace Samples
{
namespace Timing
{


using namespace Impala::Util;
using namespace Impala::Core::Array;

void
DoOneConvSep(String machineName, String srcName, int runCount)
{
    Array2dVec3UInt8* srcData = 0;
    ReadRaw(srcData, srcName, &Util::Database::GetInstance());
    int borderSize = 39;
    Array2dScalarReal64* rData;
    rData = ArrayClone<Array2dScalarReal64>(srcData, borderSize, borderSize);
    RGB2Intensity(rData, srcData);
    delete srcData;

    int f, g, i;
    //const int numFunc = 8;
    const int numFunc = 3; // not all implemented yet
    const int numGauss = 10;
    Array2dScalarReal64* gauss[numGauss];
    gauss[0] = MakeGaussian1d(1.0, 0, 2.0, 3);   // size == 3
    gauss[1] = MakeGaussian1d(1.0, 0, 3.0, 100); // size == 7
    gauss[2] = MakeGaussian1d(1.0, 0, 5.0, 100); // size == 11
    gauss[3] = MakeGaussian1d(1.7, 0, 4.0, 100); // size == 15
    gauss[4] = MakeGaussian1d(2.3, 1, 4.0, 100); // size == 19
    gauss[5] = MakeGaussian1d(2.7, 1, 4.0, 100); // size == 23
    gauss[6] = MakeGaussian1d(3.2, 1, 4.0, 100); // size == 27
    gauss[7] = MakeGaussian1d(3.7, 1, 4.0, 100); // size == 31
    gauss[8] = MakeGaussian1d(4.2, 1, 4.0, 100); // size == 35
    gauss[9] = MakeGaussian1d(4.7, 1, 4.0, 100); // size == 39
    int gaussSize[numGauss];
    for (i=0 ; i<numGauss ; i++)
        gaussSize[i] = gauss[i]->CW();
    int nrSplitTimes = 5;
    TimePlot plotter(numFunc, numGauss, gaussSize, nrSplitTimes, runCount);

    Array2dScalarReal64* res = ArrayClone<Array2dScalarReal64>(rData);

    /*
    std::vector<Array2dScalarReal64*> resList;
    for (g=0 ; g<numGauss ; g++ ) {
        Array2dScalarReal64* r = 0;
        r = ConvKernelSeparated(r, rData, gauss[g], gauss[g]);
        resList.push_back(r);
    }
    String fName = srcName + "_g";
    // MSVC requires explicit use of template type (internal compiler error)
    WriteRawList<Array2dScalarReal64>(resList, fName, true);
    return;
    */

    for (i=0 ; i<runCount ; i++)
    {
        for (g=0 ; g<numGauss ; g++)
        {
            for (f=0 ; f<numFunc ; f++)
            {
                plotter.Start(f, g, i);
                ConvKernelSeparated(res, rData, gauss[g], gauss[g], f, &plotter);
                plotter.Stop();
            }
        }
    }

    String* funcName = new String[numFunc];
    funcName[0] = "0nai";
    funcName[1] = "1sim";
    funcName[2] = "2siminc";
    /*
    funcName[3] = "3hor";
    funcName[4] = "4horinc";
    funcName[5] = "5ver";
    funcName[6] = "6vercyc";
    funcName[7] = "7min";
    */

    String baseName = srcName.substr(0, srcName.find('.'));
    plotter.SaveData(machineName, String("convsep"), baseName, funcName);

    delete [] funcName;
    delete rData;
    delete res;
}

void
DoConvSep(int argc, char* argv[])
{
    if (argc < 3)
    {
        std::cout << "convsep requires more arguments" << std::endl;
        return;
    }
    String machineName = String(argv[2]);
    DoOneConvSep(machineName, "trui_256.raw", 10);
    DoOneConvSep(machineName, "trui_255.raw", 5);
    DoOneConvSep(machineName, "trui_257.raw", 5);
    DoOneConvSep(machineName, "trui_352x288.raw", 5);
    DoOneConvSep(machineName, "trui_512.raw", 5);
    DoOneConvSep(machineName, "trui_720x576.raw", 5);
    DoOneConvSep(machineName, "trui_1280.raw", 5);
}

void
DoOneRecConvSep(String machineName, String srcName, int runCount)
{
    Array2dVec3UInt8* srcData = 0;
    ReadRaw(srcData, srcName, &Util::Database::GetInstance());
    int borderSize = 22;
    Array2dScalarReal64* rData;
    rData = ArrayClone<Array2dScalarReal64>(srcData, borderSize, borderSize);
    RGB2Intensity(rData, srcData);
    delete srcData;

    int f, g, i;
    const int numFunc = 1;
    const int numGauss = 5;
    Array2dScalarReal64* gauss[numGauss];
    gauss[0] = MakeGaussIIR1d(5.0, 0, 1); // size == 3
    gauss[1] = MakeGaussIIR1d(5.0, 0, 2); // size == 5
    gauss[2] = MakeGaussIIR1d(5.0, 0, 3); // size == 7
    gauss[3] = MakeGaussIIR1d(5.0, 0, 4); // size == 9
    gauss[4] = MakeGaussIIR1d(5.0, 0, 5); // size == 11
    int gaussSize[numGauss];
    for (i=0 ; i<numGauss ; i++)
        gaussSize[i] = gauss[i]->CW();
    int nrSplitTimes = 4;
    TimePlot plotter(numFunc, numGauss, gaussSize, nrSplitTimes, runCount);

    Array2dScalarReal64* res = ArrayClone<Array2dScalarReal64>(rData);

    /*
    std::vector<Array2dScalarReal64*> resList;
    for (g=0 ; g<numGauss ; g++ ) {
        Array2dScalarReal64* r = 0;
        r = RecConvKernelSeparated(r, rData, gauss[g], gauss[g]);
        resList.push_back(r);
    }
    String fName = srcName + "_g";
    // MSVC requires explicit use of template type (internal compiler error)
    WriteRawList<Array2dScalarReal64>(resList, fName, true);
    return;
    */

    for (i=0 ; i<runCount ; i++)
    {
        for (g=0 ; g<numGauss ; g++)
        {
            for (f=0 ; f<numFunc ; f++)
            {
                plotter.Start(f, g, i);
                RecConvKernelSeparated(res, rData, gauss[g], gauss[g], &plotter);
                plotter.Stop();
            }
        }
    }

    String* funcName = new String[numFunc];
    funcName[0] = "only variation";

    String baseName = srcName.substr(0, srcName.find('.'));
    plotter.SaveData(machineName, String("recconvsep"), baseName, funcName);

    delete [] funcName;
    delete rData;
    delete res;
}

void
DoRecConvSep(int argc, char* argv[])
{
    if (argc < 3)
    {
        std::cout << "recconvsep requires more arguments" << std::endl;
        return;
    }
    String machineName = String(argv[2]);
    DoOneRecConvSep(machineName, "trui_256.raw", 10);
    DoOneRecConvSep(machineName, "trui_255.raw", 5);
    DoOneRecConvSep(machineName, "trui_257.raw", 5);
    DoOneRecConvSep(machineName, "trui_352x288.raw", 5);
    DoOneRecConvSep(machineName, "trui_512.raw", 5);
    DoOneRecConvSep(machineName, "trui_720x576.raw", 5);
    DoOneRecConvSep(machineName, "trui_1280.raw", 5);
}

void
DoOneRecConvSepComlex(String machineName, String srcName, int runCount)
{
    Array2dVec3UInt8* srcData = 0;
    ReadRaw(srcData, srcName, &Util::Database::GetInstance());
    int borderSize = 22;
    Array2dScalarReal64* rData;
    rData = ArrayClone<Array2dScalarReal64>(srcData, borderSize, borderSize);
    RGB2Intensity(rData, srcData);
    delete srcData;
    Array2dComplex64* comData = 0;
    Set(comData, rData);

    int f, g, i;
    const int numFunc = 2;
    const int numGabor = 1;
    Array2dComplex64* gabor;
    Complex64 leftBorder;
    Complex64 rightBorder;
    gabor = MakeGaborIIR1d(6.0, 1, leftBorder, rightBorder);
    int gaborSize = gabor->CW();
    int nrSplitTimes = 4;
    TimePlot plotter(numFunc, numGabor, &gaborSize, nrSplitTimes, runCount);

    Array2dComplex64* res = ArrayClone<Array2dComplex64>(comData);

    for (i=0 ; i<runCount ; i++)
    {
        for (g=0 ; g<numGabor ; g++)
        {
            for (f=0 ; f<numFunc ; f++)
            {
                plotter.Start(f, g, i);
                RecConvKernelSeparated(res, comData, gabor, gabor,
                                       leftBorder, rightBorder,
                                       leftBorder, rightBorder, &plotter);
                if (f == 1)
                    Norm2(rData, res);
                plotter.Stop();
            }
        }
    }

    String* funcName = new String[numFunc];
    funcName[0] = "recconvsepcomplex";
    funcName[1] = "recconvsepcomplex + norm";

    String baseName = srcName.substr(0, srcName.find('.'));
    plotter.SaveData(machineName, String("recconvsepcomplex"), baseName,
                     funcName);

    delete [] funcName;
    delete rData;
    delete comData;
    delete res;
}

void
DoRecConvSepComlex(int argc, char* argv[])
{
    if (argc < 3)
    {
        std::cout << "recconvsepcomplex requires more arguments" << std::endl;
        return;
    }
    String machineName = String(argv[2]);
    DoOneRecConvSepComlex(machineName, "trui_256.raw", 10);
    DoOneRecConvSepComlex(machineName, "trui_255.raw", 5);
    DoOneRecConvSepComlex(machineName, "trui_257.raw", 5);
    DoOneRecConvSepComlex(machineName, "trui_352x288.raw", 5);
    DoOneRecConvSepComlex(machineName, "trui_512.raw", 5);
    DoOneRecConvSepComlex(machineName, "trui_720x576.raw", 5);
    DoOneRecConvSepComlex(machineName, "trui_1280.raw", 5);
}

void
ShowUsage(char *progName)
{
    std::cout
        << "Usage : " << std::endl
        << progName << " cmd [options for cmd]" << std::endl
        << "   convsep machine" << std::endl
        << "   recconvsep machine" << std::endl
        << "   recconvsepcomplex machine" << std::endl
        ;
}

int
mainTiming(int argc, char* argv[])
{
    if (argc < 2)
    {
        ShowUsage(argv[0]);
        return 1;
    }

    String cmd = String(argv[1]);
    if (cmd == "convsep")
        DoConvSep(argc, argv);
    else if (cmd == "recconvsep")
        DoRecConvSep(argc, argv);
    else if (cmd == "recconvsepcomplex")
        DoRecConvSepComlex(argc, argv);
    else std::cout << "Unknown cmd : " << cmd << std::endl;

    return 0;
}

} // namespace Timing
} // namespace Samples
} // namespace Impala

int
main(int argc, char* argv[])
{
    return Impala::Samples::Timing::mainTiming(argc, argv);
}

---