LawTexture2dImgLvl1.h

// LawTexture2dImgLvl1.h:
// ----------------------
//

#ifndef __IPSDKIPLSTATS_LAWTEXTURE2DIMGLVL1_H__
#define __IPSDKIPLSTATS_LAWTEXTURE2DIMGLVL1_H__

#include <IPSDKIPL/IPSDKIPLStats/IPSDKIPLStatsExports.h>
#include <IPSDKBaseData/Pattern/Kernel/KernelTypes.h>
#include <IPSDKBaseProcessing/Processor/ProcessorHdrMacros.h>
#include <IPSDKImage/Fragment/BorderPolicy/2d/Border2dPolicyTypes.h>
#include <IPSDKImageProcessing/OutputInitializer/Image/ImageInitializerOperators.h>

#include <IPSDKIPL/IPSDKIPLStats/OutputInitializer/LawTexInitializerUtils.h>

// Attributes headers
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/DataItem/InOptLawTextureKernel2dTypes.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/DataItem/InOptLawTexPreProcParams.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/DataItem/InOptLawTexPostProcParams.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Input/InSingleImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/OutRealImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/Working/Optional/OutOptWk1RealImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/Working/Optional/OutOptWk2RealImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/Working/OutWk1RealImg.h>

#include <map>
#include <set>

namespace ipsdk {
namespace imaproc {
namespace stats {

struct LawTex2dConvolRes;
typedef boost::shared_ptr<LawTex2dConvolRes>    LawTex2dConvolResPtr;


// declare processor class
IPSDK_DECLARE_LVL1_PROCESSOR(REP_ASYNC1, IPSDKIPLStats, LawTexture2dImg,
                             ipsdk::imaproc::matchSize(_pInSingleImg, _pOutWk1RealImg) &&
                             (ipsdk::processor::ifIsSet(_pOutOptWk1RealImg,
                                ipsdk::imaproc::matchSize(_pInSingleImg, _pOutOptWk1RealImg))) &&
                             (ipsdk::processor::ifIsSet(_pOutOptWk2RealImg,
                                ipsdk::imaproc::matchSize(_pInSingleImg, _pOutOptWk2RealImg))),
                             (((ipsdk)(imaproc)(attr))(InSingleImg))
                             (((ipsdk)(imaproc)(attr))(InOptLawTextureKernel2dTypes))
                             (((ipsdk)(imaproc)(attr))(InOptLawTexPreProcParams))
                             (((ipsdk)(imaproc)(attr))(InOptLawTexPostProcParams))
                             (((ipsdk)(imaproc)(attr))(OutRealImg)(customOutput)(outputLawTexture2d(_pInSingleImg, _pInOptLawTextureKernel2dTypes)))
                             (((ipsdk)(imaproc)(attr))(OutWk1RealImg)(ipsdk::imaproc::duplicateInOut)(_pInSingleImg)(ipsdk::image::eImageBufferType::eIBT_Real32))
                             (((ipsdk)(imaproc)(attr))(OutOptWk1RealImg))
                             (((ipsdk)(imaproc)(attr))(OutOptWk2RealImg)))

// methods
public:

protected:
    typedef std::string FinalImageId;
    typedef std::string WorkImageId;
    typedef std::map<FinalImageId, std::pair<image::ImagePtr, WorkImageId> > MapImages;

    processor::RetrievalResult meanSmoothing(
        const image::ImageConstPtr& pInImg,
        const image::ImagePtr& pOutImg,
        const ipUInt32 halfKnlSize,
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider);

    processor::RetrievalResult gaussianSmoothing(
        const image::ImageConstPtr& pInImg,
        const image::ImagePtr& pOutImg,
        const ipReal32 stdDev,
        const attr::GaussianCoverage& gaussianCoverage,
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider);

    processor::RetrievalResult smoothInputImg(
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider);

    processor::RetrievalResult subtractSmoothedToInputImg(
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider);

    processor::RetrievalResult convolve(
        const image::ImageConstPtr& pInImg,
        const KernelXYPtr& pKnl,
        const image::ImagePtr& pOutImg,
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider);

    processor::RetrievalResult convolveXKernel(
        char kernelId,
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider);

    processor::RetrievalResult convolveYKernel(
        const std::string& kernelId,
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider);

    processor::RetrievalResult computeAbsImg(
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider);

    processor::RetrievalResult blendAB_BA(
        const std::string& kernelId,
        const image::ImagePtr& pLastImgConvol2D,
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider);

    processor::RetrievalResult computeEnergyMap(
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider);

    processor::RetrievalResult provideProcessor(
        const boost::shared_ptr<core::BaseAction>& pProcessor,
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider);

    void build1DKernels();
    BoolResult buildConvolQueues();

    BoolResult insertKernelType(const std::string& id, const ipUInt32 frameIx);

    image::ImagePtr takeGreatestAvailableElementInImagesMapWithKeyGreaterThan(
        const WorkImageId&  id);

    image::ImagePtr takeElementInImagesMap(
        const FinalImageId& finalId,
        const WorkImageId& workId);

    BoolResult pickImage(const WorkImageId& id, image::ImagePtr& pImg);
    BoolResult takeInitializedOptWk1Image(const WorkImageId& id, image::ImagePtr& pOutOptWk1Img);
    BoolResult takeInitializedOptWk2Image(const WorkImageId& id, image::ImagePtr& pOutOptWk2Img);
    void releaseImage(const WorkImageId& id);
    bool doAllConvolsLeftStartWithSameLetter() const;
// attributes
protected:
    std::map<char, KernelXYPtr>                                     _mapKnlX;
    std::map<char, KernelXYPtr>                                     _mapKnlY;

    MapImages                                                       _workImages;
    std::map<std::string, LawTex2dConvolResPtr>                     _convolsToCompute;

    // border policy used for convolutions
    image::Border2dPolicyPtr                                        _pBorder2dPolicy;

    WorkImageId                                                     _optWk1RealImgId;
    WorkImageId                                                     _optWk2RealImgId;
};


} // end of namespace stats
} // end of namespace imaproc
} // end of namespace ipsdk

#endif // __IPSDKIPLSTATS_LAWTEXTURE2DIMGLVL1_H__