LawTexture3dImgLvl1.h

// LawTexture3dImgLvl1.h:
// ----------------------
//

#ifndef __IPSDKIPLSTATS_LAWTEXTURE3DIMGLVL1_H__
#define __IPSDKIPLSTATS_LAWTEXTURE3DIMGLVL1_H__

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

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

// Attributes headers
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/DataItem/InOptLawTextureKernel3dTypes.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/DataItem/InOptLawTexPreProcParams.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/DataItem/InOptLawTexPostProcParams.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Input/3d/InSingleImg3d.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/Optional/OutOptWk3RealImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/Working/OutWk1RealImg.h>

#include <map>
#include <set>

namespace ipsdk {
namespace imaproc {
namespace stats {

struct LawTex3dConvolRes;
typedef boost::shared_ptr<LawTex3dConvolRes>    LawTex3dConvolResPtr;


// declare processor class
IPSDK_DECLARE_LVL1_PROCESSOR(REP_ASYNC1, IPSDKIPLStats, LawTexture3dImg,
                              ipsdk::imaproc::matchSize(_pInSingleImg3d, _pOutWk1RealImg) &&
                             (ipsdk::processor::ifIsSet(_pOutOptWk1RealImg,
                                ipsdk::imaproc::matchSize(_pInSingleImg3d, _pOutOptWk1RealImg))) &&
                             (ipsdk::processor::ifIsSet(_pOutOptWk2RealImg,
                                ipsdk::imaproc::matchSize(_pInSingleImg3d, _pOutOptWk2RealImg))),
                             (((ipsdk)(imaproc)(attr))(InSingleImg3d))
                             (((ipsdk)(imaproc)(attr))(InOptLawTextureKernel3dTypes))
                             (((ipsdk)(imaproc)(attr))(InOptLawTexPreProcParams))
                             (((ipsdk)(imaproc)(attr))(InOptLawTexPostProcParams))
                             (((ipsdk)(imaproc)(attr))(OutRealImg)(customOutput)(outputLawTexture3d(_pInSingleImg3d, _pInOptLawTextureKernel3dTypes)))
                             (((ipsdk)(imaproc)(attr))(OutWk1RealImg)(ipsdk::imaproc::duplicateInOut)(_pInSingleImg3d)(ipsdk::image::eImageBufferType::eIBT_Real32))
                             (((ipsdk)(imaproc)(attr))(OutOptWk1RealImg))
                             (((ipsdk)(imaproc)(attr))(OutOptWk2RealImg))
                             (((ipsdk)(imaproc)(attr))(OutOptWk3RealImg)))

// 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 KernelXYZPtr& 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 convolveZKernel(
        const std::string& kernelId,
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider);

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

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

    processor::RetrievalResult divideImageByScalar(
        const image::ImagePtr& pImg,
        const ipUInt32 scalar,
        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& pImg);
    BoolResult takeInitializedOptWk2Image(const WorkImageId& id, image::ImagePtr& pImg);
    BoolResult takeInitializedOptWk3Image(const WorkImageId& id, image::ImagePtr& pImg);
    void releaseImage(const WorkImageId& id);
    bool doAllConvolsLeftStartWithSameLetter() const;
    bool doAllConvolsLeftStartWithTwoSameLetters() const;

// attributes
protected:
    std::map<char, KernelXYZPtr>                                    _mapKnlX;
    std::map<char, KernelXYZPtr>                                    _mapKnlY;
    std::map<char, KernelXYZPtr>                                    _mapKnlZ;

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

    // border policy used for convolutions
    image::Border3dPolicyPtr                                        _pBorder3dPolicy;

    WorkImageId                                                     _optWk1RealImgId;
    WorkImageId                                                     _optWk2RealImgId;
    WorkImageId                                                     _optWk3RealImgId;
};


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

#endif // __IPSDKIPLSTATS_LAWTEXTURE3DIMGLVL1_H__