DeepFlow2dImgLvl1.h

// DeepFlow2dImgLvl1.h:
// --------------------
//

#ifndef __IPSDKIPLREGISTRATION_DEEPFLOW2DIMGLVL1_H__
#define __IPSDKIPLREGISTRATION_DEEPFLOW2DIMGLVL1_H__

#include <IPSDKIPL/IPSDKIPLRegistration/IPSDKIPLRegistrationExports.h>
#include <IPSDKBaseProcessing/Processor/ProcessorHdrMacros.h>
#include <IPSDKImageProcessing/OutputInitializer/Image/ImageInitializerOperators.h>
#include <IPSDKIPL/IPSDKIPLRegistration/OutputInitializer/DeepFlowInitializerUtils.h>
#include <IPSDKIPL/IPSDKIPLRegistration/Rule/DeepFlowRuleUtils.h>
#include <IPSDKImage/Image/BaseImage.h>

// Attributes headers
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/DataItem/InDeepFlowParams.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Input/InSingleImg1.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Input/InSingleImg2.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Input/Optional/InOptRealSeqImg.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/Optional/OutOptWk4RealImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/Working/Optional/OutOptWk5RealImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/Working/Optional/OutOptWk6RealImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/Working/Optional/OutOptWk7RealImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/Working/Optional/OutOptWk8RealImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/OutRealImg1.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/OutRealImg2.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/OutRealSeqImg.h>

namespace ipsdk {
namespace imaproc {
namespace registration {


// declare processor class
IPSDK_DECLARE_LVL1_PROCESSOR(REP_ASYNC1, IPSDKIPLRegistration, DeepFlow2dImg,
                             matchSize(_pInSingleImg1, _pInSingleImg2) &&
                             matchSize(eMatchImageSizeType::eMIST_XYZC, _pInSingleImg1, _pOutRealImg1) &&
                             ipsdk::imaproc::customImageProperty(_pOutRealSeqImg, matchDeepFlow2d(_pInSingleImg1)) &&
                             ipsdk::processor::If(ipsdk::processor::isSet(_pInOptRealSeqImg),
                                 matchSize(_pInOptRealSeqImg, _pOutRealSeqImg),
                                 ipsdk::processor::none()),
                             (((ipsdk)(imaproc)(attr))(InSingleImg1))
                             (((ipsdk)(imaproc)(attr))(InSingleImg2))
                             (((ipsdk)(imaproc)(attr))(InDeepFlowParams))
                             (((ipsdk)(imaproc)(attr))(InOptRealSeqImg))
                             (((ipsdk)(imaproc)(attr))(OutOptWk1RealImg))
                             (((ipsdk)(imaproc)(attr))(OutOptWk2RealImg))
                             (((ipsdk)(imaproc)(attr))(OutOptWk3RealImg))
                             (((ipsdk)(imaproc)(attr))(OutOptWk4RealImg))
                             (((ipsdk)(imaproc)(attr))(OutOptWk5RealImg))
                             (((ipsdk)(imaproc)(attr))(OutOptWk6RealImg))
                             (((ipsdk)(imaproc)(attr))(OutOptWk7RealImg))
                             (((ipsdk)(imaproc)(attr))(OutOptWk8RealImg))
                             (((ipsdk)(imaproc)(attr))(OutRealImg1)(customOutput)(createSeqFromImage(_pInSingleImg1, 2)))
                             (((ipsdk)(imaproc)(attr))(OutRealImg2)(customOutput)(createSeqFromImage(_pInSingleImg1, 2)))
                             (((ipsdk)(imaproc)(attr))(OutRealSeqImg)(customOutput)(outputDeepFlow2d(_pInSingleImg1))))

// methods
public:

protected:
    ipsdk::core::ExecResult preProcess();

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


    processor::RetrievalResult gaussianSmoothing(const ipsdk::image::ImageConstPtr& pInImg,
                                                 const ipsdk::image::ImagePtr& pOutImg,
                                                 const ipsdk::ipReal32& sigma,
                                                 const core::BasePriority& priority,
                                                 core::ActionProviderPtr& pProvider);


    processor::RetrievalResult meanSmoothing(const ipReal64 factor,
                                             const core::BasePriority& priority,
                                             core::ActionProviderPtr& pProvider);

    processor::RetrievalResult erase(const core::BasePriority& priority,
                                     core::ActionProviderPtr& pProvider,
                                     const ipsdk::image::ImagePtr& pOutImg);

    processor::RetrievalResult zoom(const ipsdk::image::ImageConstPtr& pInImg,
                                    const ipsdk::image::ImagePtr& pOutImg,
                                    const core::BasePriority& priority,
                                    core::ActionProviderPtr& pProvider);

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

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

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

    BoolResult                 allocCurScale();
    BoolResult                 allocForLevel(const boost::shared_ptr<BaseInputImageAttribute>& pInImgAttr,
                                             const boost::shared_ptr<BaseOutputImageAttribute>& pOutImgAttr,
                                             const ipUInt32 level, const ipUInt64 nbFrames);
    BoolResult                 allocForLevel(const boost::shared_ptr<BaseOutputImageAttribute>& pInImgAttr,
                                             const boost::shared_ptr<BaseOutputImageAttribute>& pOutImgAttr,
                                             const ipUInt32 level);

// attributes
protected:
    ipUInt32 _nbLayers;

    ipUInt32    _level;

    ipBool      _bCopyPerformed;
};


} // end of namespace registration
} // end of namespace imaproc
} // end of namespace ipsdk

#endif // __IPSDKIPLREGISTRATION_DEEPFLOW2DIMGLVL1_H__