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

---

mainTalk.cpp

Go to the documentation of this file.

#include <iomanip>
#include "Core/Array/Arrays.h"

#include "Core/Array/Pattern/PatNgbOp2dExtra2.h"
#include "Core/Array/Pattern/PatNgbOp2dExtra.h"
#include "Core/Array/Pattern/PatNgbOp2d.h"
#include "Core/Array/Pattern/PatRecGenConv2d.h"
#include "Core/Array/Pattern/PatGenConv2d.h"
#include "Core/Array/Pattern/PatRecGenConv2dSep.h"
#include "Core/Array/Pattern/PatGenConv2dSep.h"
#include "Core/Array/Pattern/PatBinaryPixOp.h"
#include "Core/Array/PrintData.h"
#include "Core/Array/MakeFromData.h"
#include "Core/Array/Set.h"
#include "Core/Array/Trait/TalkBpo.h"
#include "Core/Array/Trait/TalkBpoAssign.h"
#include "Core/Array/Trait/TalkNgbP1Cnum.h"
#include "Core/Array/Trait/TalkNgbP1Loop.h"
#include "Core/Array/Trait/TalkNgbP2Loop.h"
#include "Core/Array/Trait/TalkNgbPnLoop.h"
#include "Core/Array/Trait/TalkNgbExtraP1Cnum.h"
#include "Core/Array/Trait/TalkNgbExtraP1Loop.h"
#include "Core/Array/Trait/TalkNgbExtraP2Loop.h"
#include "Core/Array/Trait/TalkNgbExtraPnLoop.h"
#include "Core/Array/Trait/TalkNgbExtra2P1Cnum.h"
#include "Core/Array/Trait/TalkNgbExtra2P1Loop.h"
#include "Core/Array/Trait/TalkNgbExtra2P2Loop.h"
#include "Core/Array/Trait/TalkNgbExtra2PnLoop.h"

#include "Basis/CmdOptions.h"

namespace Impala
{
namespace Samples
{
namespace Talk
{


using namespace Impala::Core::Array;
using namespace Impala::Core::Array::Trait;
using namespace Impala::Core::Array::Pattern;

static bool gVerbose;
static bool gUniform;
static bool gSmall;
static bool gLarge;
static int  gVType;
static int  gWidth;
static int  gHeight;

void
UpdateSizeArgument()
{
    if (gSmall)
    {
        gWidth = 4;
        gHeight = 3;
    }
    else
    {
        if (gLarge)
        {
            gWidth = 13;
            gHeight = 9;
        }
        else
        {
            gWidth = 9;
            gHeight = 7;
        }
    }
}

double*
TalkUniqueImage(int width, int height, double start, double inc)
{
    int nPix = width * height;
    double* data = new double[nPix];
    for (int i=0 ; i<nPix ; i++)
    {
        data[i] = start;
        start += inc;
    }
    return data;
}

template<class ArrayT>
ArrayT*
TalkImage(std::string comment, double start, double inc, int bw, int bh)
{
    double* ptr = TalkUniqueImage(gWidth, gHeight, start, inc);
    Array2dScalarReal64* aDouble =
        MakeFromData<Array2dScalarReal64>(ptr, gWidth, gHeight, bw, bh);
    ArrayT* res = 0;
    Set(res, aDouble);
    std::cout << comment << std::endl;
    PrintData(res, false);
    delete ptr;
    return res;
}

template<class ArrayT>
ArrayT*
TalkKernel(std::string comment, int dims, int dir = 1)
{
    int width;
    int height;
    double val;
    if (dims == 1)
    {
        if (dir == 1)
        {
            width = 5;
            height = 1;
            val = 1.0 / 5;
        }
        else
        {
            width = 3;
            height = 1;
            val = 1.0 / 3;
        }
    }
    if (dims == 2)
    {
        width = 5;
        height = 3;
        val = 1.0 / (5*3);
    }
    ArrayT* ker = 0;
    double* kerData;
    if (gUniform)
    {
        int nPix = width * height;
        kerData = new double[nPix];
        for (int i=0 ; i<nPix ; i++)
            kerData[i] = val;
    }
    else
    {
        kerData = TalkUniqueImage(width, height, 1.1, 1.1);
    }
    Array2dScalarReal64* kerDouble =
        MakeFromData<Array2dScalarReal64>(kerData, width, height, 0, 0);
    Set(ker, kerDouble);
    std::cout << std::endl << comment << std::endl;
    PrintData(ker, false);
    delete kerData;
    return ker;
}

/************************************************************************/
/************************************************************************/

void
DoTalkBpo2d()
{
    std::cout << std::endl << std::endl << std::endl;
    std::cout << "=============== DoTalkBpo2d =================" << std::endl;

    typedef Array2dScalarReal64 SRC1T;
    typedef Array2dScalarReal64 SRC2T;
    typedef Array2dScalarReal64 REST;

    SRC1T* a1 = TalkImage<SRC1T>("Input image 1:", 0, 1.1, 2, 1);
    SRC2T* a2 = TalkImage<SRC2T>("Input image 2:", 101, 1.1, 1, 2);

    REST* res = 0;
    //TalkBpoPtrE1<REST, SRC1T, SRC2T> bpo(gVerbose, false);
    TalkBpoPtrEn<REST, SRC1T, SRC2T> bpo(gVerbose, false);
    PatBinaryPixOp(res, a1, a2, bpo);
    std::cout << std::endl << "result: " << std::endl;
    PrintData(res, false);

    //REST* res2 = 0;
    //TalkBpoVal<REST, SRC1T, SRC2T> bpo2(gVerbose, false);
    //PatBinaryPixOp(res2, a1, a2, bpo2);
    //std::cout << std::endl << "result val: " << std::endl;
    //PrintData(res2, false);

    //Array2dVec3Real64* res3 = 0;
    //Set(res3, a1);
    //std::cout << std::endl << "result3: " << std::endl;
    //PrintData(res3, false);

    //Array2dScalarReal64* a3 = 0;
    //Set(a3, res3);
    //std::cout << std::endl << "a3: " << std::endl;
    //PrintData(a3, false);
}

void
DoTalkGenConv2d()
{
    std::cout << std::endl << std::endl << std::endl;
    std::cout << "============== DoTalkGenConv2d =============" << std::endl;

    //typedef Array2dScalarInt32 SRCT;
    typedef Array2dScalarReal64 SRCT;
    //typedef Array2dVec3Real64 SRCT;
    typedef Array2dScalarReal64 KERT;
    //typedef Array2dVec3Real64 KERT;
    typedef Array2dScalarReal64 REST;
    //typedef Array2dVec3Real64 REST;

    SRCT* im = TalkImage<SRCT>("Input image: ", 0, 1, 3, 3);

    KERT* ker = TalkKernel<KERT>("kernel: ", 2);

    REST* res = 0;
    TalkBpoVal<KERT, KERT, KERT> bpo(gVerbose, false);
    TalkBpoAssignVal<KERT, KERT> bpoAss(gVerbose, false, 1000000);
    PatGenConv2d(res, im, ker, bpo, bpoAss);

    std::cout << std::endl << "result: " << std::endl;
    PrintData(res, false);
}

void
DoTalkGenConv2dSep()
{
    std::cout << std::endl << std::endl << std::endl;
    std::cout << "============== DoTalkGenConv2dSep =============" << std::endl;

    //typedef Array2dScalarInt32 SRCT;
    typedef Array2dScalarReal64 SRCT;
    //typedef Array2dVec3Real64 SRCT;
    typedef Array2dScalarReal64 KERT;
    //typedef Array2dVec3Real64 KERT;
    typedef Array2dScalarReal64 REST;
    //typedef Array2dVec3Real64 REST;

    SRCT* im = TalkImage<SRCT>("Input image: ", 0, 1, 3, 3);

    KERT* ker2 = TalkKernel<KERT>("k1d_3 image: ", 1, 2);
    KERT* ker1 = TalkKernel<KERT>("k1d_5 image: ", 1, 1);

    //REST* res = 0;
    //TalkBpoPtrE1<KERT, KERT, KERT> bpo(gVerbose, false);
    //TalkBpoAssignPtrE1<KERT, KERT> bpoAss(gVerbose, false, 1000000);
    //PatGenConv2dSep(res, im, ker1, ker2, bpo, bpoAss, gVType, 0);
    //std::cout << std::endl << "result: " << std::endl;
    //PrintData(res, false);

    //REST* res2 = 0;
    //TalkBpoPtrEn<KERT, KERT, KERT> bpo2(gVerbose, false);
    //TalkBpoAssignPtrEn<KERT, KERT> bpoAss2(gVerbose, false, 1000000);
    //PatGenConv2dSep(res2, im, ker1, ker2, bpo2, bpoAss2, gVType, 0);
    //std::cout << std::endl << "result: " << std::endl;
    //PrintData(res2, false);

    REST* res3 = 0;
    TalkBpoVal<KERT, KERT, KERT> bpo3(gVerbose, false);
    TalkBpoAssignVal<KERT, KERT> bpoAss3(gVerbose, false, 1000000);
    PatGenConv2dSep(res3, im, ker1, ker2, bpo3, bpoAss3, gVType, 0);
    std::cout << std::endl << "result: " << std::endl;
    PrintData(res3, false);
}

void
DoTalkRecGenConv2d()
{
    std::cout << std::endl << std::endl << std::endl;
    std::cout << "============== DoTalkRecGenConv2d =============" << std::endl;

    //typedef Array2dScalarInt32 SRCT;
    typedef Array2dScalarReal64 SRCT;
    //typedef Array2dVec3Real64 SRCT;
    typedef Array2dScalarReal64 KERT;
    //typedef Array2dVec3Real64 KERT;
    typedef Array2dScalarReal64 REST;
    //typedef Array2dVec3Real64 REST;

    SRCT* im = TalkImage<SRCT>("Input image: ", 0, 1, 3, 3);

    KERT* ker = TalkKernel<KERT>("kernel: ", 2);

    REST* res = 0;
    TalkBpoVal<KERT, KERT, KERT> bpo(gVerbose, true);
    TalkBpoAssignVal<KERT, KERT> bpoAss(gVerbose, false, 1000000);
    PatRecGenConv2d(res, im, ker, bpo, bpoAss);

    std::cout << std::endl << "result: " << std::endl;
    PrintData(res, false);
}

void
DoTalkRecGenConv2dSep()
{
    std::cout << std::endl << std::endl << std::endl;
    std::cout << "============== DoTalkRecGenConv2dSep =============" << std::endl;

    //typedef Array2dScalarInt32 SRCT;
    typedef Array2dScalarReal64 SRCT;
    //typedef Array2dVec3Real64 SRCT;
    typedef Array2dScalarReal64 KERT;
    //typedef Array2dVec3Real64 KERT;
    typedef Array2dScalarReal64 REST;
    //typedef Array2dVec3Real64 REST;

    SRCT* im = TalkImage<SRCT>("Input image: ", 0, 1, 5, 5);

    KERT* ker2 = TalkKernel<KERT>("k1d_3 image: ", 1, 2);
    KERT* ker1 = TalkKernel<KERT>("k1d_5 image: ", 1, 1);

    REST* res = 0;
    TalkBpoVal<KERT, KERT, KERT> bpo(gVerbose, true);
    TalkBpoAssignVal<KERT, KERT> bpoAss(gVerbose, false, 1000000);
    typedef KERT::ArithType KerArithT;
    KerArithT normFactor = Element::E1Cast(1, KerArithT());
    PatRecGenConv2dSep(res, im, ker1, ker2,
                         normFactor, normFactor, normFactor, normFactor,
                         bpo, bpoAss, 0);

    std::cout << std::endl << "result: " << std::endl;
    PrintData(res, false);
}


void
DoTalkNgb2d()
{
    std::cout << std::endl << std::endl << std::endl;
    std::cout << "=============== DoTalkNgb2d =================" << std::endl;

    typedef Array2dScalarInt32 SRCT;
    //typedef Array2dScalarReal64 SRCT;
    typedef Array2dScalarReal64 REST;

    SRCT* im = TalkImage<SRCT>("Input image:", 0, 1, 2, 1);

    REST* res = 0;
    TalkNgbP1Cnum<REST,SRCT> p1cnum(gVerbose);
    PatNgbOp2d(res, im, p1cnum);
    std::cout << std::endl << "result P1Cnum: " << std::endl;
    PrintData(res, false);


    TalkNgbP1Loop<REST,SRCT> p1loop(gVerbose, 5, 3);
    PatNgbOp2d(res, im, p1loop);
    std::cout << std::endl << "result P1Loop: " << std::endl;
    PrintData(res, false);

    TalkNgbP2Loop<REST,SRCT> p2loop(gVerbose, 5, 3);
    PatNgbOp2d(res, im, p2loop);
    std::cout << std::endl << "result P2Loop: " << std::endl;
    PrintData(res, false);

    TalkNgbPnLoop<REST,SRCT> pnloop(gVerbose, 5, 3);
    PatNgbOp2d(res, im, pnloop);
    std::cout << std::endl << "result PnLoop: " << std::endl;
    PrintData(res, false);
}


void
DoTalkNgb2dExtra()
{
    std::cout << std::endl << std::endl << std::endl;
    std::cout << "=============== DoTalkNgb2dExtra =================" << std::endl;

    typedef Array2dScalarInt32 SRCT;
    //typedef Array2dScalarReal64 SRCT;
    typedef Array2dScalarInt32 EXTRAT;
    typedef Array2dVec3Real64 REST;

    SRCT* im = TalkImage<SRCT>("Input image:", 0, 1, 2, 1);
    EXTRAT* extra = TalkImage<EXTRAT>("Extra image:", 100, 1, 2, 1);

    REST* res = 0;
    TalkNgbExtraP1Cnum<REST,SRCT,EXTRAT> p1cnum(gVerbose);
    PatNgbOp2dExtra(res, im, extra, p1cnum);
    std::cout << std::endl << "result P1Cnum: " << std::endl;
    PrintData(res, false);

    TalkNgbExtraP1Loop<REST,SRCT,EXTRAT> p1loop(gVerbose, 5, 3);
    PatNgbOp2dExtra(res, im, extra, p1loop);
    std::cout << std::endl << "result P1Loop: " << std::endl;
    PrintData(res, false);

    TalkNgbExtraP2Loop<REST,SRCT,EXTRAT> p2loop(gVerbose, 5, 3);
    PatNgbOp2dExtra(res, im, extra, p2loop);
    std::cout << std::endl << "result P2Loop: " << std::endl;
    PrintData(res, false);

    TalkNgbExtraPnLoop<REST,SRCT,EXTRAT> pnloop(gVerbose, 5, 3);
    PatNgbOp2dExtra(res, im, extra, pnloop);
    std::cout << std::endl << "result PnLoop: " << std::endl;
    PrintData(res, false);
}


void
DoTalkNgb2dExtra2()
{
    std::cout << std::endl << std::endl << std::endl;
    std::cout << "=============== DoTalkNgb2dExtra2 =================" << std::endl;

    typedef Array2dScalarInt32 SRCT;
    //typedef Array2dScalarReal64 SRCT;
    typedef Array2dScalarInt32 EXTRAT;
    typedef Array2dScalarInt32 EXTRA2T;
    typedef Array2dVec3Real64 REST;

    SRCT* im = TalkImage<SRCT>("Input image:", 0, 1, 2, 1);
    EXTRAT* extra = TalkImage<EXTRAT>("Extra image:", 100, 1, 2, 1);
    EXTRA2T* extra2 = TalkImage<EXTRA2T>("Extra2 image:", 1000, 1, 2, 1);

    REST* res = 0;
    TalkNgbExtra2P1Cnum<REST,SRCT,EXTRAT,EXTRA2T> p1cnum(gVerbose);
    PatNgbOp2dExtra2(res, im, extra, extra2, p1cnum);
    std::cout << std::endl << "result P1Cnum: " << std::endl;
    PrintData(res, false);

    TalkNgbExtra2P1Loop<REST,SRCT,EXTRAT,EXTRA2T> p1loop(gVerbose, 5, 3);
    PatNgbOp2dExtra2(res, im, extra, extra2, p1loop);
    std::cout << std::endl << "result P1Loop: " << std::endl;
    PrintData(res, false);

    TalkNgbExtra2P2Loop<REST,SRCT,EXTRAT,EXTRA2T> p2loop(gVerbose, 5, 3);
    PatNgbOp2dExtra2(res, im, extra, extra2, p2loop);
    std::cout << std::endl << "result P2Loop: " << std::endl;
    PrintData(res, false);

    TalkNgbExtra2PnLoop<REST,SRCT,EXTRAT,EXTRA2T> pnloop(gVerbose, 5, 3);
    PatNgbOp2dExtra2(res, im, extra, extra2, pnloop);
    std::cout << std::endl << "result PnLoop: " << std::endl;
    PrintData(res, false);
}

/************************************************************************/
/************************************************************************/

int
mainTalk(int argc, char* argv[])
{
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(false);
    options.AddOption(0, "verb", "", "0");
    options.AddOption(0, "unif", "", "0");
    options.AddOption(0, "small", "", "0");
    options.AddOption(0, "large", "", "0");
    options.AddOption(0, "log", "", "0");
    options.AddOption(0, "vType", "number", "6");
    if (! options.ParseArgs(argc, argv, "testName", 1))
        return 1;

    gVerbose = options.GetBool("verb");
    gUniform = options.GetBool("unif");
    gSmall = options.GetBool("small");
    gLarge = options.GetBool("large");
    gVType = options.GetInt("vType");
    bool log = options.GetBool("log");
    std::string tt = options.GetArg(0);

    std::cout << std::setprecision(10);
    UpdateSizeArgument();

    if (tt == "bpo2d")
        DoTalkBpo2d();
    if (tt == "genconv2d")
        DoTalkGenConv2d();
    if (tt == "genconv2dsep")
        DoTalkGenConv2dSep();
    if (tt == "recgenconv2d")
        DoTalkRecGenConv2d();
    if (tt == "recgenconv2dsep")
        DoTalkRecGenConv2dSep();

    if (tt == "ngb2d")
        DoTalkNgb2d();
    if (tt == "ngb2dextra")
        DoTalkNgb2dExtra();
    if (tt == "ngb2dextra2")
        DoTalkNgb2dExtra2();

    return 0;
}

} // namespace Talk
} // namespace Samples
} // namespace Impala

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

---