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

---

mainIm.cpp

Go to the documentation of this file.

#include "Core/Array/AniGauss.h"
#include "Core/Feature/Weibull.h"
#include "Core/Array/ColorSegmentation.h"
#include "Core/Array/ArrayListDelete.h"
#include "Core/Array/Rotate.h"
#include "Core/Array/WatershedMarkers2.h"
#include "Core/Array/WatershedMarkers.h"
#include "Core/Array/Watershed.h"
#include "Core/Array/Norm2.h"
#include "Core/Array/RecGabor.h"
#include "Core/Array/TestEqual.h"
#include "Core/Array/RecGauss.h"
#include "Core/Array/RGB2Intensity.h"
#include "Core/Array/GaussDerivative.h"
#include "Core/Array/ReadFile.h"
#include "Core/Array/WriteRaw.h"
#include "Core/Array/WritePng.h"
#include "Core/Array/ReadFile.h"
#include "Core/Array/Arrays.h"
#include "Core/Array/PrintData.h"
#include "Core/Array/Set.h"
#include "Core/Matrix/MatrixTem.h"
#include "Core/Matrix/MatKMeans.h"
#include "Core/Matrix/MatKLM.h"
#include "Core/Matrix/MatTranspose.h"

namespace Impala
{
namespace Application
{
namespace Im
{

using namespace Impala::Core::Array;

void
DoDump()
{
    ILOG_VAR(Impala.Application.Im.DoDump);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 2)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String fileName = options.GetArg(1);
    bool doGenesis = false;
    if (options.GetNrArg() >= 3)
        doGenesis = true;

    // todo : -rect arg

    ArrayType aType = ReadRawArrayType(fileName, db);
    switch (aType)
    {
        case ARRAY2DSCALARUINT8: {
            Array2dScalarUInt8* a = 0;
            ReadRaw(a, fileName, db);
            PrintData(a, false, 0, 0, 10, 10);
            delete a;
            break;
        }
        case ARRAY2DSCALARREAL64: {
            Array2dScalarReal64* a = 0;
            ReadRaw(a, fileName, db);
            PrintData(a, false);
            if (doGenesis)
                WriteRaw(a, "real64_b.raw", db, true);
            //
            Array2dScalarInt32* b = 0;
            Set(b, a);
            PrintData(b, false);
            if (doGenesis)
                WriteRaw(b, "int32.raw", db, false);

            Array2dVec3UInt8* c = 0;
            Set(c, b);
            PrintData(c, false);
            if (doGenesis)
                WriteRaw(c, "vec3uint8.raw", db, false);

            Array2dComplex64* d = 0;
            Set(d, a);
            PrintData(d, false);
            if (doGenesis)
                WriteRaw(d, "complex64.raw", db, false);
            //
            delete a;
            break;
        }
        case ARRAY2DVEC3UINT8: {
            Array2dVec3UInt8* a = 0;
            ReadRaw(a, fileName, db);
            PrintData(a, false);
            if (doGenesis)
                WriteRaw(a, "vec3uint8_b.raw", db, true);
            delete a;
            break;
        }
        case ARRAY2DVEC2REAL64: { // we assume this to be complex
            Array2dComplex64* a = 0;
            ReadRaw(a, fileName, db);
            PrintData(a, false);
            if (doGenesis)
                WriteRaw(a, "complex64_b.raw", db, true);
            delete a;
            break;
        }
        default:
            ILOG_ERROR("Unknown ArrayType");
    }
}

void
DoJpg2Raw()
{
    ILOG_VAR(Impala.Application.Im.DoJpg2Raw);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 3)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String jpgName = options.GetArg(1);
    String rawName = options.GetArg(2);
    int binary = 1;
    if (options.GetNrArg() >= 5)
        binary = atol(options.GetArg(4));
    Array2dVec3UInt8* data = 0;
    ReadJpg(data, jpgName, db);
    WriteRaw(data, rawName, db, (binary != 0));
    delete data;
}

void
DoPng2Raw()
{
    ILOG_VAR(Impala.Application.Im.DoPng2Raw);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 3)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String pngName = options.GetArg(1);
    String rawName = options.GetArg(2);
    int binary = 1;
    if (options.GetNrArg() >= 5)
        binary = atol(options.GetArg(4));
    Array2dVec3UInt8* data = 0;
    ReadPng(data, pngName, db);
    WriteRaw(data, rawName, db, (binary != 0));
    delete data;
}

template<class ArrayT>
void
DoTestEqualTem(ArrayT dummy, String name1, String name2, double eps)
{
    ILOG_VAR(Impala.Application.Im.DoTestEqualTem);
    Util::Database* db = &Util::Database::GetInstance();
    std::vector<ArrayT*> src1;
    std::vector<ArrayT*> src2;
    ReadRawListVar(src1, name1, db);
    ReadRawListVar(src2, name2, db);
    
    if (src1.size() != src1.size())
    {
        ILOG_INFO("Number of array's differs");
    }
    else
    {
        if (src1.size() == 0)
            ILOG_INFO("List is empty");
        for (size_t i=0 ; i<src1.size() ; i++)
        {
            Array2dScalarReal64* res = 0;
            if (! TestEqual(res, src1[i], src2[i], eps))
                ILOG_INFO("Arrays " << i << " differ");
            delete res;
        }
    }
    ArrayListDelete(&src1);
    ArrayListDelete(&src2);
}

void
DoTestEqual()
{
    ILOG_VAR(Impala.Application.Im.DoTestEqual);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 3)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String name1 = options.GetArg(1);
    String name2 = options.GetArg(2);
    double eps = 0.00001;
    if (options.GetNrArg() >= 5)
        eps = atof(options.GetArg(4));

    ArrayType type1 = ReadRawArrayType(name1, db);
    ArrayType type2 = ReadRawArrayType(name2, db);
    if (type1 != type2)
    {
        ILOG_INFO("ArrayType's differ");
        return;
    }

    switch (type1)
    {
    case ARRAY2DSCALARUINT8:
        DoTestEqualTem(Array2dScalarUInt8(), name1, name2, eps);
        break;
    case ARRAY2DSCALARINT32:
        DoTestEqualTem(Array2dScalarInt32(), name1, name2, eps);
        break;
    case ARRAY2DSCALARREAL64:
        DoTestEqualTem(Array2dScalarReal64(), name1, name2, eps);
        break;
    case ARRAY2DVEC3UINT8:
        DoTestEqualTem(Array2dVec3UInt8(), name1, name2, eps);
        break;
    default:
        ILOG_INFO("unknown array type");
    }
}

void
DoNJetVec3UInt8()
{
    ILOG_VAR(Impala.Application.Im.DoNJetVec3UInt8);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 5)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String dstName = options.GetArg(1);
    String srcName = options.GetArg(2);
    double sigma = atof(options.GetArg(3));
    double precision = atof(options.GetArg(4));

    Array2dVec3UInt8* srcData = 0;
    ReadRaw(srcData, srcName, db);
    Array2dScalarReal64* rData = 0;
    RGB2Intensity(rData, srcData);
    std::vector<Array2dScalarReal64*> resList;
    Timer timer(1);

    Array2dScalarReal64* res = 0;
    GaussDerivative(res, rData, sigma, 0, 0, precision);
    resList.push_back(res);

    res = 0;
    GaussDerivative(res, rData, sigma, 1, 0, precision);
    resList.push_back(res);

    res = 0;
    GaussDerivative(res, rData, sigma, 0, 1, precision);
    resList.push_back(res);

    res = 0;
    GaussDerivative(res, rData, sigma, 2, 0, precision);
    resList.push_back(res);

    res = 0;
    GaussDerivative(res, rData, sigma, 1, 1, precision);
    resList.push_back(res);

    res = 0;
    GaussDerivative(res, rData, sigma, 0, 2, precision);
    resList.push_back(res);

    ILOG_INFO("time: " << timer.SplitTime());
    WriteRawList(resList, dstName, db, true);
    delete srcData;
    delete rData;
    //delete res;
    ArrayListDelete(&resList);
}

void
DoGaussVec3UInt8()
{
    ILOG_VAR(Impala.Application.Im.DoGaussVec3UInt8);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 7)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String dstName = options.GetArg(1);
    String srcName = options.GetArg(2);
    double sigma = atof(options.GetArg(3));
    int derX = atol(options.GetArg(4));
    int derY = atol(options.GetArg(5));
    double precision = atof(options.GetArg(6));

    Array2dVec3UInt8* srcData = 0;
    ReadRaw(srcData, srcName, db);
    //Array2dScalarReal64* rData = 0;
    //RGB2Intensity(rData, srcData);
    Array2dVec3Real64* rData = 0;
    Set(rData, srcData);
    Timer timer(1);
    //Array2dScalarReal64* res = 0;
    Array2dVec3Real64* res = 0;
    //GaussDerivative(res, rData, sigma, derX, derY, precision);
    GaussDerivativeVec3(res, rData, sigma, derX, derY, precision);
    ILOG_INFO("time: " << timer.SplitTime());
    WriteRaw(res, dstName, db, false);
    delete srcData;
    delete rData;
    delete res;
}

void
DoRecGaussVec3UInt8()
{
    ILOG_VAR(Impala.Application.Im.DoRecGaussVec3UInt8);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 8)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String dstName = options.GetArg(1);
    String srcName = options.GetArg(2);
    double sigmaX = atof(options.GetArg(3));
    double sigmaY = atof(options.GetArg(4));
    int derX = atol(options.GetArg(5));
    int derY = atol(options.GetArg(6));
    int recOrder = atof(options.GetArg(7));

    Array2dVec3UInt8* srcData = 0;
    ReadRaw(srcData, srcName, db);
    Array2dScalarReal64* rData = 0;
    RGB2Intensity(rData, srcData);
    Array2dScalarReal64* res = 0;
    RecGauss(res, rData, sigmaX, sigmaY, derX, derY, recOrder);
    WriteRaw(res, dstName, db, true);
    delete srcData;
    delete rData;
    delete res;
}

void
DoAniGaussVec3UInt8()
{
    ILOG_VAR(Impala.Application.Im.DoAniGaussVec3UInt8);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 8)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String dstName = options.GetArg(1);
    String srcName = options.GetArg(2);
    Real64 sigmaV = atof(options.GetArg(3));
    Real64 sigmaU = atof(options.GetArg(4));
    Real64 phi = atof(options.GetArg(5));
    int derV = atol(options.GetArg(6));
    int derU = atol(options.GetArg(7));

    Array2dVec3UInt8* srcData = 0;
    ReadFile(srcData, srcName, db);
    Array2dScalarReal64* rData = 0;
    RGB2Intensity(rData, srcData);
    Array2dScalarReal64* res = 0;
    AniGauss(res, rData, sigmaV, sigmaU, phi, derV, derU);
    WriteRaw(res, dstName, db, true);
    delete srcData;
    delete rData;
    delete res;
}

void
DoRecGaborVec3UInt8()
{
    ILOG_VAR(Impala.Application.Im.DoRecGaborVec3UInt8);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 6)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String dstName = options.GetArg(1);
    String srcName = options.GetArg(2);
    double s = atof(options.GetArg(3));
    double omega0 = atof(options.GetArg(4));
    double theta = atof(options.GetArg(5));

    Array2dVec3UInt8* srcData = 0;
    ReadRaw(srcData, srcName, db);
    Array2dScalarReal64* rData = 0;
    RGB2Intensity(rData, srcData);
    Array2dComplex64* comData = 0;
    Set(comData, rData);
    Array2dComplex64* res = 0;
    RecGabor(res, comData, s, omega0, theta);
    WriteRaw(res, dstName, db, true);
    /*
    Array2dScalarReal64* norm = 0;
    norm = Norm2(norm, res);
    WriteRaw(norm, dstName+String("2"), db, false);
    */
    delete srcData;
    delete rData;
    delete res;
}

void
DoWatershedVec3UInt8()
{
    ILOG_VAR(Impala.Application.Im.DoWatershedVec3UInt8);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 4)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String dstName = options.GetArg(1);
    String srcName = options.GetArg(2);
    int conn = atol(options.GetArg(3));

    Array2dVec3UInt8* srcData = 0;
    ReadRaw(srcData, srcName, db);
    Array2dScalarReal64* rData = 0;
    RGB2Intensity(rData, srcData);
    Array2dScalarInt32* intData = 0;
    Set(intData, rData);
    Array2dScalarInt32* res = 0;
    Watershed(res, intData, conn);
    WriteRaw(res, dstName, db, true);
    delete srcData;
    delete rData;
    delete res;
}

void
DoWatershedMarkersVec3UInt8()
{
    ILOG_VAR(Impala.Application.Im.DoWatershedMarkersVec3UInt8);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 6)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String dstName = options.GetArg(1);
    String srcName = options.GetArg(2);
    String maskName = options.GetArg(3);
    int conn = atol(options.GetArg(4));
    int doLabel = atol(options.GetArg(5));

    Array2dVec3UInt8* srcData = 0;
    ReadRaw(srcData, srcName, db);
    Array2dScalarReal64* rData = 0;
    RGB2Intensity(rData, srcData);
    Array2dScalarInt32* intData = 0;
    Set(intData, rData);

    ReadRaw(srcData, maskName, db);
    RGB2Intensity(rData, srcData);
    Array2dScalarInt32* mIntData = 0;
    Set(mIntData, rData);

    Array2dScalarInt32* res = 0;
    WatershedMarkers(res, intData, mIntData, conn, doLabel != 0);
    WriteRaw(res, dstName, db, true);
    delete srcData;
    delete rData;
    delete res;
}

void
DoWatershedMarkers2Vec3UInt8()
{
    ILOG_VAR(Impala.Application.Im.DoWatershedMarkers2Vec3UInt8);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 7)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String dstName = options.GetArg(1);
    String srcName = options.GetArg(2);
    String maskName = options.GetArg(3);
    int conn = atol(options.GetArg(4));
    int doLabel = atol(options.GetArg(5));
    int costMethod = atol(options.GetArg(6));

    Array2dVec3UInt8* srcData = 0;
    ReadRaw(srcData, srcName, db);
    Array2dScalarReal64* rData = 0;
    RGB2Intensity(rData, srcData);
    Array2dScalarInt32* intData = 0;
    Set(intData, rData);

    ReadRaw(srcData, maskName, db);
    RGB2Intensity(rData, srcData);
    Array2dScalarInt32* mIntData = 0;
    Set(mIntData, rData);

    Array2dScalarInt32* res = 0;
    WatershedMarkers2(res, intData, mIntData, conn, doLabel != 0, costMethod);
    WriteRaw(res, dstName, db, true);
    delete srcData;
    delete rData;
    delete res;
}

void
DoRotateVec3UInt8()
{
    ILOG_VAR(Impala.Application.Im.DoRotateVec3UInt8);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 7)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String dstName = options.GetArg(1);
    String srcName = options.GetArg(2);
    double alpha = atof(options.GetArg(3));
    int geoInt = atol(options.GetArg(4));
    int adjustSize = atol(options.GetArg(5));
    int background = atol(options.GetArg(6));

    Array2dVec3UInt8* srcData = 0;
    ReadRaw(srcData, srcName, db);
    Array2dScalarReal64* rData = 0;
    RGB2Intensity(rData, srcData);
    Array2dScalarInt32* intData = 0;
    Set(intData, rData);

    Array2dVec3UInt8* res = 0;
    //Array2dVec3Real64* res = 0;
    Rotate(res, srcData, alpha,
           geoInt ? Core::Geometry::LINEAR : Core::Geometry::NEAREST,
           adjustSize != 0, E1Cast(background, Vec3Int32()));

    //Array2dScalarInt32* res = 0;
    //Array2dScalarReal64* res = 0;
    //Rotate(res, rData, alpha, geoInt ? LINEAR : NEAREST,
    //             adjustSize != 0, E1Cast(background, Real64()));


    WriteRaw(res, dstName, db, false);
    delete srcData;
    delete rData;
    delete intData;
    delete res;
}

void
DoWeibullW()
{
    ILOG_VAR(Impala.Application.Im.DoWeibullW);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 3)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String imName = options.GetArg(1);
    double sigma = atof(options.GetArg(2));

    Array2dVec3UInt8* im = 0;
    ReadFile(im, imName, db);
    Core::Vector::VectorSet<Array2dScalarReal64>* vs = 0;
    vs = Core::Feature::Weibull(im, sigma);
    //vs->Dump();
    for (int i=0 ; i<vs->Size() ; i++)
    {
        Core::Vector::VectorTem<Real64> v = vs->GetVector(i, true);
        for (int j=0 ; j<v.Size() ; j++)
            std::cout << v[j] << " ";
    }
    std::cout << std::endl;
    delete im;
    delete vs;
}

void
DoWeibullIRGB()
{
    ILOG_VAR(Impala.Application.Im.DoWeibullIRGB);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 3)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String imName = options.GetArg(1);
    double sigma = atof(options.GetArg(2));
    bool doMu = false;
    if (options.GetNrArg() >= 4)
        doMu = (atol(options.GetArg(3)) != 0);
    bool doAnderson = false;
    if (options.GetNrArg() >= 5)
        doAnderson = (atol(options.GetArg(4)) != 0);
    bool doArjan = false;
    if (options.GetNrArg() >= 6)
        doArjan = (atol(options.GetArg(5)) != 0);

    Array2dVec3UInt8* im = 0;
    ReadFile(im, imName, db);
    Core::Vector::VectorSet<Array2dScalarReal64>* vs = 0;
    vs = Core::Feature::WeibullIRGB(im, sigma, doMu, doAnderson, doArjan);
    //vs->Dump();
    for (int i=0 ; i<vs->Size() ; i++)
    {
        Core::Vector::VectorTem<Real64> v = vs->GetVector(i, true);
        for (int j=0 ; j<v.Size() ; j++)
            std::cout << v[j] << " ";
    }
    std::cout << std::endl;
    delete im;
    delete vs;
}

void
DoColorSegmentation()
{
    ILOG_VAR(Impala.Application.Im.DoColorSegmentation);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 3)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String dstName = options.GetArg(1);
    String srcName = options.GetArg(2);
    double minRegionFraction = 0.01;
    if (options.GetNrArg() >= 4)
        minRegionFraction = atof(options.GetArg(3));
    double threshold = 6.0;
    if (options.GetNrArg() >= 5)
        threshold = atof(options.GetArg(4));
    ILOG_INFO("minRegionFraction = " << minRegionFraction
              << ", threshold = " << threshold);

    ColorSegmentationAlgorithm segAlg = TextureAddZero;
    ColorSegmentationInvariant invariantType = C;

    Array2dVec3UInt8* srcIm = 0;
    ReadFile(srcIm, srcName, db);
    Array2dVec3Real64* srcV3R64 =
        ArrayCreate<Array2dVec3Real64>(srcIm->CW(), srcIm->CH(), 15, 15);
    //MakeFromData2<Array2dVec3Real64,Array2dVec3UInt8>(srcV3R64,
    //                                                  srcIm->DataPtr());
    Set(srcV3R64, srcIm);
    Array2dVec3UInt8* dst = 0;
    ColorSegmentation(dst, srcV3R64, segAlg, invariantType, minRegionFraction,
                      threshold, false, 0);
    WritePng(dst, dstName, db);
    delete dst;
    delete srcV3R64;
    delete srcIm;
}


typedef Impala::Core::Matrix::MatrixTem<double> MatrixDouble;
using namespace Impala::Core::Matrix;

void
PrMatrix(MatrixDouble m)
{
    for (int r=0 ; r<m.nRow() ; r++)
    {
        for (int c=0 ; c<m.nCol() ; c++)
        {
            std::cout << "m[" << r << "][" << c << "] = " << m[r][c] << ", ";
        }
        std::cout << std::endl;
    }
}

void
DoMatrix()
{
    ILOG_VAR(Impala.Application.Im.DoMatrix);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 3)
    {
        ILOG_ERROR("Need more arguments");
        return;
    }
    Util::Database* db = &Util::Database::GetInstance();

    String fileName = options.GetArg(1);
    int version = atol(options.GetArg(2));

    typedef Array2dScalarReal64 Mat;
    //typedef VecScalarReal64 Vec;

    Mat* m1 = 0;
    ReadRaw(m1, fileName, db);
    Mat* m2 = MatTranspose(m1);
    delete m1;
    MatrixDouble m(m2->mCH, m2->mCW, m2->mData);
    Timer timer(1);
    if (version == 1)
    {
        ILOG_INFO("time: " << timer.SplitTime() << " Array based ");
        //m1 = MatKLM(m2, 4);
        m1 = MatCovariance(m2, (Mat*) 0);
    }
    else
    {
        ILOG_INFO("time: " << timer.SplitTime() << " Matrix based ");
        //m = m.klm(4);
        VectorTem<double> v;
        m = m.covariance(v);
    }
ILOG_INFO("time: " << timer.SplitTime());
}

void
DoTest()
{
    ILOG_VAR(Impala.Application.Im.DoTest);
    int i;
    double* ptr = new double[12];
    for (i=0 ; i<12 ; i++)
        ptr[i] = i;
    MatrixDouble m(3, 4, ptr);
    PrMatrix(m);
    m = m.t();
    PrMatrix(m);

    ILOG_INFO("========== New version =============");
    typedef Array2dScalarReal64 Mat;

    double* ptr2 = new double[12];
    for (i=0 ; i<12 ; i++)
        ptr2[i] = i;
    Mat* mm = Core::Matrix::MatCreate<Mat>(3, 4, ptr2); 
    PrintData(mm, false);
    Mat* mm2 = MatTranspose(mm);
    PrintData(mm2, false);
}

int
mainIm(int argc, char* argv[])
{
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(false, false, true);
    String usageStr = "cmd = \n\n";
    usageStr += "  dump rawFile [-genesis]\n";
    usageStr += "  jpg2raw jpgFile rawFile [-binary {0|1}]\n";
    usageStr += "  png2raw pngFile rawFile [-binary {0|1}]\n";
    usageStr += "  testequal im1File im2File [-eps value]\n";
    usageStr += "  njetvec3uint8 dstFile srcFile sigma precision\n";
    usageStr += "  gaussvec3uint8 dstFile srcFile sigma derX derY precision\n";
    usageStr += "  recgaussvec3uint8 dstFile srcFile sigmaX sigmaY derX derY order\n";
    usageStr += "  anigaussvec3uint8 dstFile srcFile sigmaV sigmaU phi derV derU\n";
    usageStr += "  recgaborvec3uint8 dstFile srcFile s omega0 theta\n";
    usageStr += "  watershedvec3uint8 dstFile srcFile conn\n";
    usageStr += "  watershedmarkersvec3uint8 dstFile srcFile maskFile conn doLabel\n";
    usageStr += "  rotate dstFile srcFile alpha geoInt adjustSize background\n";
    usageStr += "  weibullW imFile sigma\n";
    usageStr += "  weibullIRGB imFile sigma [doMu=0] [doAnderson=0] [doArjan=0]\n";
    usageStr += "  segment dstFile srcFile [minRegionFraction=0.01] [threshold=6.0]\n";
    usageStr += "  matrix srcFile version\n";
    if (! options.ParseArgs(argc, argv, usageStr, 1))
        return 1;

    ILOG_VAR(Impala.Application.Util.mainIm);

    int verbose = options.GetInt("verb");
    ArraySystem& aSys = ArraySystem::Instance();
    aSys.MarkMemoryUsage(verbose > 0);

    String cmd = options.GetArg(0);
    if (cmd == "dump")
        DoDump();
    else if (cmd == "jpg2raw")
        DoJpg2Raw();
    else if (cmd == "png2raw")
        DoPng2Raw();
    else if (cmd == "testequal")
        DoTestEqual();
    else if (cmd == "njetvec3uint8")
        DoNJetVec3UInt8();
    else if (cmd == "gaussvec3uint8")
        DoGaussVec3UInt8();
    else if (cmd == "recgaussvec3uint8")
        DoRecGaussVec3UInt8();
    else if (cmd == "anigaussvec3uint8")
        DoAniGaussVec3UInt8();
    else if (cmd == "recgaborvec3uint8")
        DoRecGaborVec3UInt8();
    else if (cmd == "watershedvec3uint8")
        DoWatershedVec3UInt8();
    else if (cmd == "watershedmarkersvec3uint8")
        DoWatershedMarkersVec3UInt8();
    else if (cmd == "watershedmarkers2vec3uint8")
        DoWatershedMarkers2Vec3UInt8();
    else if (cmd == "rotate")
        DoRotateVec3UInt8();
    else if (cmd == "weibullW")
        DoWeibullW();
    else if (cmd == "weibullIRGB")
        DoWeibullIRGB();
    else if (cmd == "segment")
        DoColorSegmentation();
    else if (cmd == "matrix")
        DoMatrix();
    else if (cmd == "test")
        DoTest();
    else ILOG_ERROR("Unknown cmd : " << cmd);

    aSys.CheckMemoryUsageSinceMark(verbose > 0);

    return 0;
}

} // namespace Im
} // namespace Application
} // namespace Impala

int
main(int argc, char* argv[])
{
    return Impala::Application::Im::mainIm(argc, argv);
}

---