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

---

RgbDataSrcFactory.h

Go to the documentation of this file.

#ifndef Impala_Core_Stream_RgbDataSrcFactory_h
#define Impala_Core_Stream_RgbDataSrcFactory_h

#include "Persistency/ImageArchiveRepository.h"
#include "Persistency/RgbDataSrcLocator.h"
#include "Basis/FileName.h"
#include "Util/Database.h"
#include "Core/Stream/RgbDataSrc.h"
#include "Core/Stream/RgbDataSrcWindow.h"

#ifdef DX_USED
#include "Core/Stream/RgbDataSrcDX.h"
#include "Core/Stream/RgbDataSrcAVI.h"
#include "Core/Stream/RgbDataSrcCam.h"
#endif

//#include "Core/Stream/RgbDataSrcBmp.h"
//#include "Core/Stream/RgbDataSrcJpg.h"
//#include "Core/Stream/RgbDataSrcPng.h"

#ifdef MPEG2_USED
#include "Core/Stream/RgbDataSrcMpeg2.h"
#endif

//#include "Core/Stream/RgbDataSrcAloi.h"
//#include "Core/Stream/RgbDataSrcPngList.h"

#ifdef AVC_USED
#include "Core/Stream/RgbDataSrcLavc.h"
#endif
#include "Core/Stream/RgbDataSrcInfo.h"
#include "Core/Stream/RgbDataSrcRaw.h"

namespace Impala
{
namespace Core
{
namespace Stream
{


class RgbDataSrcFactory
{
public:
    typedef Persistency::RgbDataSrcLocator RgbDataSrcLocator;

    static const int SRC_DX            = 1;
    static const int SRC_AVI           = 2;
    static const int SRC_CAM           = 3;

    //static const int SRC_BMP         = 4;
    //static const int SRC_JPG         = 5;
    //static const int SRC_PNG         = 6;

    static const int SRC_MPEG2         = 7;
    static const int SRC_MPEG2ES       = 8;

    //static const int SRC_ALOI        = 9;
    //static const int SRC_PNGLIST     = 10;

    static const int SRC_LAVC          = 11;
    static const int SRC_LAVC_NOCHECK  = 12;
    static const int SRC_LAVC_SCANONLY = 13;
    static const int SRC_LAVC_READIDX  = 14;
    static const int SRC_LAVC_WITHIDX  = 15;
    static const int SRC_LAVC_WRITEIDX = 16;
    static const int SRC_LAVC_ADHOCIDX = 17;

    static const int SRC_INFO          = 18;
    static const int SRC_INDEX         = 19;
    static const int SRC_RAW           = 20;
    

    static RgbDataSrcFactory&
    Instance()
    {
        static RgbDataSrcFactory theFactory;
        return theFactory;
    }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    RgbDataSrc*
    Construct(CString srcName, CString option,
              Util::Database* db = &Util::Database::GetInstance())
    {
#else // REPOSITORY_USED
    RgbDataSrc*
    Construct(const RgbDataSrcLocator& loc, CString option)
    {
        String srcName = loc.GetName();
#endif // REPOSITORY_USED
        int src = SuggestSrc(srcName);
        if (!option.empty())
        {
            if (option == "dx")
                src = SRC_DX;
            else if (option == "avi")
                src = SRC_AVI;
            else if (option == "mpeg2")
                src = SRC_MPEG2;
            else if (option == "mpeg2es")
                src = SRC_MPEG2ES;

            else if (option == "lavc")
                src = SRC_LAVC; // use default setting 
            else if (option == "lavcnoidx") // deprecated
            {
                ILOG_WARN("Value 'lavcnoidx' for option --src is deprecated;" <<
                    " you should choose from 'lavcnocheck' and 'lavcscanonly';" <<
                    " 'lavcnoidx' is handled as 'lavcnocheck'");
                src = SRC_LAVC_NOCHECK;
            }
            else if (option == "lavcnocheck")
                src = SRC_LAVC_NOCHECK;
            else if (option == "lavcscanonly")
                src = SRC_LAVC_SCANONLY;
            else if (option == "lavcreadidx")
                src = SRC_LAVC_READIDX;
            else if (option == "lavcwithidx")
                src = SRC_LAVC_WITHIDX;
            else if (option == "lavcwriteidx")
                src = SRC_LAVC_WRITEIDX;
            else if (option == "lavcadhocidx")
                src = SRC_LAVC_ADHOCIDX;

            else if (option == "info")
                src = SRC_INFO;
            else if (option == "index")
                src = SRC_INDEX;
            else if (option == "raw")
                src = SRC_RAW;

            else
            {
                ILOG_ERROR("Unknown option value: --src " << option);
                return 0;
            }
        }
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        return Construct(src, srcName, db);
#else // REPOSITORY_USED
        return Construct(src, loc);
#endif // REPOSITORY_USED
    }

    int
    SuggestSrc(CString srcName)
    {
        int src = SRC_AVI;
        if (srcName.compare(0, 6, "camera") == 0)
            src = SRC_CAM;
        String ext = FileNameExt(srcName, true);

#ifdef MPEG2_USED
        if (ext == "mpg")
            src = SRC_MPEG2;
        if (ext == "mpeg")
            src = SRC_MPEG2;
#endif

#ifdef DX_USED
        if (ext == "mpg")
            src = SRC_DX;
        if (ext == "mpeg")
            src = SRC_DX;
#endif

#ifdef AVC_USED
        if (ext == "mpg")
            src = SRC_LAVC;
        if (ext == "mpeg")
            src = SRC_LAVC;
        if (ext == "asf")
            src = SRC_LAVC;
#endif

        if (ext == "info")
            src = SRC_INFO;
        if (ext == "raw")
            src = SRC_RAW;

        //if (ext == "bmp")
        //    src = SRC_BMP;
        //if (ext == "jpg")
        //    src = SRC_JPG;
        //if (ext == "png")
        //    src = SRC_PNG;
        //if (ext == "pnglist")
        //    src = SRC_PNGLIST;

#ifdef unix
#ifdef MPEG2_USED
        src = SRC_MPEG2;
#endif
#ifdef AVC_USED
        src = SRC_LAVC;
#endif
#endif
        return src;
    }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    RgbDataSrc*
    Construct(int src, CString srcName, Util::Database* db = 0)
    {
#else // REPOSITORY_USED
    RgbDataSrc*
    Construct(int src, const RgbDataSrcLocator& loc)
    {
        String srcName = loc.GetName();
#endif // REPOSITORY_USED
        ILOG_INFO("Construct: srcName=" << srcName);
#ifdef DX_USED
        if (src == SRC_DX)
            return new RgbDataSrcDX(src, srcName);
        if (src == SRC_AVI)
            return new RgbDataSrcAVI(src, srcName);
        if (src == SRC_CAM)
            return new RgbDataSrcCam(src, srcName);
#endif

        //if (src == SRC_BMP)
        //    return new RgbDataSrcBmp(src, srcName);
        //if (src == SRC_JPG)
        //    return new RgbDataSrcJpg(src, srcName);
        //if (src == SRC_PNG)
        //    return new RgbDataSrcPng(src, srcName);

#ifdef MPEG2_USED
        if (src == SRC_MPEG2)
            return new RgbDataSrcMpeg2(src, srcName);
        if (src == SRC_MPEG2ES)
            return new RgbDataSrcMpeg2(src, srcName, true);
#endif

        //if (src == SRC_ALOI)
        //    return new RgbDataSrcAloi(src, srcName);
        //if (src == SRC_PNGLIST)
        //    return new RgbDataSrcPngList(src, srcName);

#ifdef AVC_USED
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        if (src == SRC_LAVC) 
            return new RgbDataSrcLavc(src, srcName, db, READIDX); // default 

        if (src == SRC_LAVC_NOCHECK)
            return new RgbDataSrcLavc(src, srcName, db, NOCHECK);

        if (src == SRC_LAVC_SCANONLY)
            return new RgbDataSrcLavc(src, srcName, db, SCANONLY);

        if (src == SRC_LAVC_READIDX)
            return new RgbDataSrcLavc(src, srcName, db, READIDX);

        if (src == SRC_LAVC_WITHIDX)
            return new RgbDataSrcLavc(src, srcName, db, WITHIDX);

        if (src == SRC_LAVC_WRITEIDX)
            return new RgbDataSrcLavc(src, srcName, db, WRITEIDX);

        if (src == SRC_LAVC_ADHOCIDX)
            return new RgbDataSrcLavc(src, srcName, db, ADHOCIDX);
#else // REPOSITORY_USED
        if (src == SRC_LAVC) 
            return new RgbDataSrcLavc(src, loc, READIDX); // default 

        if (src == SRC_LAVC_NOCHECK)
            return new RgbDataSrcLavc(src, loc, NOCHECK);

        if (src == SRC_LAVC_SCANONLY)
            return new RgbDataSrcLavc(src, loc, SCANONLY);

        if (src == SRC_LAVC_READIDX)
            return new RgbDataSrcLavc(src, loc, READIDX);

        if (src == SRC_LAVC_WITHIDX)
            return new RgbDataSrcLavc(src, loc, WITHIDX);

        if (src == SRC_LAVC_WRITEIDX)
            return new RgbDataSrcLavc(src, loc, WRITEIDX);

        if (src == SRC_LAVC_ADHOCIDX)
            return new RgbDataSrcLavc(src, loc, ADHOCIDX);
#endif // REPOSITORY_USED
#endif

        //if (src == SRC_INFO)
        //    return new RgbDataSrcInfo(src, srcName, db);
        //if (src == SRC_INDEX)
        //    return new RgbDataSrcInfo(src, srcName, db);

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        if (src == SRC_RAW)
            return new RgbDataSrcRaw(srcName);
#else // REPOSITORY_USED
        if (src == SRC_RAW)
        {
            Persistency::ImageArchiveLocator arLoc(loc, loc.GetName());
            Array::ImageArchive* archive =
                Persistency::ImageArchiveRepository().Get(arLoc);
            return new RgbDataSrcRaw(src, loc.GetName(), archive);
        }
#endif // REPOSITORY_USED

        ILOG_ERROR("Construction failed");
        return 0;
    }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    RgbDataSrc*
    ConstructWindow(CString srcName, CString srcOption, CString windowOption,
                    Util::Database* db)
    {
        RgbDataSrc* slave = Construct(srcName, srcOption, db);
#else // REPOSITORY_USED
    RgbDataSrc*
    ConstructWindow(const RgbDataSrcLocator& loc, CString srcOption,
                    CString windowOption)
    {
        RgbDataSrc* slave = Construct(loc, srcOption);
#endif // REPOSITORY_USED
        if (windowOption.empty())
            return slave;

        StringList sList(windowOption, ';');
        if (sList.size() < 3)
        {
            ILOG_ERROR("src window needs at least 3 arguments");
            return slave;
        }

        StringListCI it = sList.begin();
        String sizeType = *it++; // should be just "size"
        int wSize = atol(*it++);
        String prepType = *it++;
        if (prepType == "copyreal")
        {
            WindowPrepCopyToVec3Real64* prep = new WindowPrepCopyToVec3Real64();
            typedef RgbDataSrcWindow<WindowPrepCopyToVec3Real64> WindowType;
            WindowType* win = new WindowType(slave, wSize, prep, true, true);
            return win;
        }
        if (prepType == "rgb2ooo")
        {
            WindowPrepRgb2Ooo* prep = new WindowPrepRgb2Ooo();
            typedef RgbDataSrcWindow<WindowPrepRgb2Ooo> WindowType;
            WindowType* win = new WindowType(slave, wSize, prep, true, true);
            return win;
        }
        if (prepType == "gauss")
        {
            if (sList.size() != 7)
            {
                ILOG_ERROR("gauss prep window needs 4 arguments");
                return slave;
            }
            double sigma = atof(*it++);
            int orderDerivx = atol(*it++);
            int orderDerivy = atol(*it++);
            double truncation = atof(*it++);
            WindowPrepGaussDerivative* prep =
                new WindowPrepGaussDerivative(sigma, orderDerivx, orderDerivy,
                                              truncation);
            typedef RgbDataSrcWindow<WindowPrepGaussDerivative> WindowType;
            WindowType* win = new WindowType(slave, wSize, prep, true, true);
            return win;
        }
        ILOG_ERROR("Unknown window prep type " << prepType << "!");
        return slave;
    }

private:

    RgbDataSrcFactory()
    {
    }

    RgbDataSrcFactory(const RgbDataSrcFactory&)
    {
    }

    RgbDataSrcFactory&
    operator=(const RgbDataSrcFactory&);

    ILOG_VAR_DECL;
};

ILOG_VAR_INIT(RgbDataSrcFactory, Impala.Core.Stream);

} // namespace Stream
} // namespace Core
} // namespace Impala

#endif

---