KMeansImgLvl1.h

// KMeansImgLvl1.h:
// ----------------
//

#ifndef __IPSDKIPLCLASSIFICATION_KMEANSIMGLVL1_H__
#define __IPSDKIPLCLASSIFICATION_KMEANSIMGLVL1_H__

#include <IPSDKIPL/IPSDKIPLClassification/IPSDKIPLClassificationExports.h>
#include <IPSDKIPL/IPSDKIPLClassification/Processor/KMeansAssignImg/KMeansAssignImgLvl1.h>
#include <IPSDKIPL/IPSDKIPLClassification/Processor/KMeansPPClusterInit/KMeansPPClusterInitLvl1.h>
#include <IPSDKIPL/IPSDKIPLClassification/Processor/KMeansComputeCompactness/KMeansComputeCompactnessLvl1.h>
#include <IPSDKBaseProcessing/Processor/ProcessorHdrMacros.h>
#include <IPSDKIPL/IPSDKIPLClassification/OutputInitializer/KMeansInitializerUtils.h>
#include <IPSDKIPL/IPSDKIPLClassification/Rule/KMeansRuleUtils.h>
#include <IPSDKIPL/IPSDKIPLUtility/Processor/CopyImg/CopyImgLvl1.h>

// Attributes headers
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/DataItem/InOutOptClustersPptiesColl.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/DataItem/OutKMeansAssignmentInfo.h>
#include <IPSDKIPL/IPSDKIPLAttributes/DataItem/ClusterEltInfo.h>
#include <IPSDKIPL/IPSDKIPLAttributes/DataItem/Doubles.h>
#include <IPSDKIPL/IPSDKIPLAttributes/DataItem/UIntegers64.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Input/InHomogeneousImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/OutClassImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/Optional/OutOptPosterizedImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Output/Working/Optional/OutOptWkClassImg.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Value/InOptClustersCentersShiftTolerance.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Value/InNbClusters.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Value/InOptNbAttempts.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Value/InOptNbMaxIter.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Value/OutCompactness.h>
#include <IPSDKIPL/IPSDKIPLAttributes/Attribute/Image/Input/Optional/InOptSingleGreyMaskImg.h>

namespace ipsdk {
namespace imaproc {
namespace classif {

class KMeansCentersRandomInitLvl1;
class LocateMostEccentricClusterEltLvl1;
class KMeansPosterizeImgLvl1;


// declare processor class
IPSDK_DECLARE_LVL1_PROCESSOR(REP_ASYNC1, IPSDKIPLClassification, KMeansImg,
                             ipsdk::imaproc::matchSize(eMatchImageSizeType::eMIST_3d, _pInHomogeneousImg, _pOutClassImg) &&
                             ipsdk::processor::ifIsSet(_pOutOptPosterizedImg,
                                 ipsdk::imaproc::matchSizeAndType(_pInHomogeneousImg, _pOutOptPosterizedImg)) &&
                             ipsdk::processor::ifIsSet(_pOutOptWkClassImg,
                                 ipsdk::imaproc::matchSizeAndType(_pOutClassImg, _pOutOptWkClassImg)) &&
                            ipsdk::imaproc::customImageProperty(_pOutClassImg, allowedClassImgBuffersFromNbClusters(_pInNbClusters)) &&
                            ipsdk::processor::If(ipsdk::processor::isSet(_pInOptSingleGreyMaskImg),
                                ipsdk::imaproc::matchSize(eMatchImageSizeType::eMIST_3d, _pInHomogeneousImg, _pInOptSingleGreyMaskImg),
                                ipsdk::processor::none()),

                             (((ipsdk)(imaproc)(attr))(InHomogeneousImg))
                             (((ipsdk)(imaproc)(attr))(InOptSingleGreyMaskImg))
                             (((ipsdk)(imaproc)(attr))(InOptNbAttempts))
                             (((ipsdk)(imaproc)(attr))(InOptNbMaxIter))
                             (((ipsdk)(imaproc)(attr))(InNbClusters))
                             (((ipsdk)(imaproc)(attr))(InOptClustersCentersShiftTolerance))
                             (((ipsdk)(imaproc)(attr))(OutClustersCenters)(allocate))
                             (((ipsdk)(imaproc)(attr))(OutCompactness))
                             (((ipsdk)(imaproc)(attr))(OutOptWkClassImg)(customOutput)(outputKMeans(_pOutClassImg, _pInHomogeneousImg, _pInNbClusters)))
                             (((ipsdk)(imaproc)(attr))(OutOptPosterizedImg))
                             (((ipsdk)(imaproc)(attr))(OutClassImg)(customOutput)(outputKMeans(_pInHomogeneousImg, _pInNbClusters))))

// methods
public:

protected:
    
    void finalizeClustersCenters();
    void computeNewCenters();
    bool checkCentersShift();

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

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

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

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

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

    processor::RetrievalResult replaceEmptyCluster(
        ipUInt64 emptyClusterIx,
        const attr::ClusterEltInfo& mostEccentricClusterEltInfo,
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider);

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

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

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

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

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

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

    processor::RetrievalResult compactnessForCurrentAttemptComputed(
        const core::BasePriority& priority,
        core::ActionProviderPtr& pProvider,
        ipReal64 compactness);

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

    ipUInt64 findBiggestCluster();

// attributes
protected:
    image::ImageConstPtr                                        _pReinterpretedInImg;
    image::ImagePtr                                             _pReinterpretedOutPosterizedImg;

    ipUInt32                                                    _iterIx;
    ipUInt32                                                    _attemptIx;

    boost::shared_ptr<KMeansAssignImgLvl1>                      _pKMeansAssignProcessor;
    boost::shared_ptr<KMeansPPClusterInitLvl1>                  _pKMeansInitCentersProcessor;
    boost::shared_ptr<LocateMostEccentricClusterEltLvl1>        _pLocateEmptyClusterSubstituteProcessor;
    boost::shared_ptr<KMeansComputeCompactnessLvl1>             _pKMeansComputeCompactnessProcessor;
    boost::shared_ptr<util::CopyImgLvl1>                        _pSetCurClassImgAsBestProcessor;
    boost::shared_ptr<util::CopyImgLvl1>                        _pCopyBestClassImgToOutClassImgProcessor;
    boost::shared_ptr<KMeansPosterizeImgLvl1>                   _pPosterizeProcessor;

    attr::KMeansAssignmentInfoPtr                               _pKMeansAssignmentInfo;
    ipUInt64                                                    _lastEmptyClusterIx;
    std::vector<ipReal64>                                       _oldFlattenedClustersCenters;
    std::vector<ipReal64>                                       _flattenedClustersCenters;
    std::vector<ipReal64>                                       _flattenedClustersStdDeviations;

    std::vector<ipReal64>                                       _bestFlattenedClustersCenters;
    
    ipReal64                                                    _bestCompactness;

    // declaration of dispatch results collection
    IPSDK_DECLARE_STATIC_RESULT_COLL(attr::OutKMeansAssignmentInfo, KMeansAssignmentInfoColl);
};


} // end of namespace classif
} // end of namespace imaproc
} // end of namespace ipsdk

#endif // __IPSDKIPLCLASSIFICATION_KMEANSIMGLVL1_H__