InputImageTile3dCollSplit.h

// InputImageTile3dCollSplit.h:
// ----------------------------
//

#ifndef __IPSDKIMAGEPROCESSING_INPUTIMAGETILE3DCOLLSPLIT_H__
#define __IPSDKIMAGEPROCESSING_INPUTIMAGETILE3DCOLLSPLIT_H__

#include <IPSDKImageProcessing/DataSplit/TileColl/BaseImageTile3dCollSplit.h>
#include <IPSDKImage/Fragment/BorderPolicy/3d/Border3dPolicy.h>
#include <IPSDKImage/Fragment/Extractor/ImageTileExtractor.h>
#include <IPSDKImage/Fragment/Tile/Tile3d/InputImageTile3d.h>

namespace ipsdk {
namespace imaproc {


template <typename TProcessor, typename TAttribute>
class InputImageTile3dCollSplit : public BaseImageTile3dCollSplit<typename TAttribute::TileType>
{
// predefined public types
public:
    typedef TProcessor ProcessorType;

    typedef TAttribute AttributeType;

    typedef BaseImageTile3dCollSplit<typename TAttribute::TileType> BaseClassType;

    typedef typename BaseClassType::InputImageType InputImageType;

    typedef boost::shared_ptr<InputImageType> InputImagePtrType;

    typedef typename TAttribute::TileType OutputTileType;

    typedef typename BaseClassType::Tile3dPtr Tile3dPtr;

    typedef typename BaseClassType::Tile3dColl Tile3dColl;

public:
    InputImageTile3dCollSplit() {}
    ~InputImageTile3dCollSplit() {}

// methods
public:
    const std::string&  getAttributeName() const;

    const std::string&  getAttributeToolTip() const;

    void                init(const boost::shared_ptr<InputImageType>& pImage,
                             const image::Border3dPolicy& border3dPolicy,
                             const Tile3dCoordsColl& tile3dCoordsColl,
                             const ipUInt64 nbMinEltsPerSplit = 1,
                             const ipUInt64 nbMaxEltsPerSplit = NumericLimits<ipUInt32>::max());

protected:
    bool                checkProcessorType(const processor::BaseProcessor& processor);

    Tile3dPtr           extractTile3d(const Tile3dCoords& curTile3dCoords);

    BoolResult          processAttribute(processor::BaseProcessor& processor,
                                         const Tile3dColl& tile3dColl);

// attributes
protected:
    image::Border3dPolicy   _border3dPolicy;
};


template <typename TProcessor, typename TAttribute>
inline const std::string&
InputImageTile3dCollSplit<TProcessor, TAttribute>::getAttributeName() const
{
    return TAttribute::getObjectNameStr();
}

template <typename TProcessor, typename TAttribute>
inline const std::string&
InputImageTile3dCollSplit<TProcessor, TAttribute>::getAttributeToolTip() const
{
    return TAttribute::getToolTipStr();
}

template <typename TProcessor, typename TAttribute>
inline void
InputImageTile3dCollSplit<TProcessor, TAttribute>::init(const boost::shared_ptr<InputImageType>& pImage,
                                                        const image::Border3dPolicy& border3dPolicy,
                                                        const Tile3dCoordsColl& tile3dCoordsColl,
                                                        const ipUInt64 nbMinEltsPerSplit,
                                                        const ipUInt64 nbMaxEltsPerSplit)
{
    // store input border policy
    _border3dPolicy = border3dPolicy;

    // call of base class initialization method
    return this->initBase(pImage, tile3dCoordsColl, nbMinEltsPerSplit, nbMaxEltsPerSplit);
}

template <typename TProcessor, typename TAttribute>
inline bool
InputImageTile3dCollSplit<TProcessor, TAttribute>::checkProcessorType(const processor::BaseProcessor& processor)
{
    // check for consistency between processor and attribute
    BOOST_STATIC_ASSERT_MSG((processor::ExistsAttribute<TAttribute, typename TProcessor::AttributesInfo>::g_bValue),
                            "This attribute is not part of processor class");

    return dynamic_cast<const TProcessor*>(&processor) != 0;
}

template <typename TProcessor, typename TAttribute>
inline typename InputImageTile3dCollSplit<TProcessor, TAttribute>::Tile3dPtr
InputImageTile3dCollSplit<TProcessor, TAttribute>::extractTile3d(const Tile3dCoords& curTile3dCoords)
{
    Tile3dPtr pCurTile(boost::make_shared<OutputTileType>());
    image::ImageTileExtractor::extractInputTile3d(0, 0,
                                                  curTile3dCoords._startOffsetX, curTile3dCoords._startOffsetY, curTile3dCoords._startOffsetZ,
                                                  curTile3dCoords._sizeX, curTile3dCoords._sizeY, curTile3dCoords._sizeZ,
                                                  *(this->getImagePtr()), _border3dPolicy, *pCurTile);

    return pCurTile;
}

template <typename TProcessor, typename TAttribute>
inline BoolResult
InputImageTile3dCollSplit<TProcessor, TAttribute>::processAttribute(processor::BaseProcessor& processor,
                                                                    const Tile3dColl& tile3dColl)
{
    // cast of input processor object
    TProcessor& tProcessor = static_cast<TProcessor&>(processor);

    // update of processor attribute value
    tProcessor.TProcessor::template set<TAttribute>(tile3dColl);

    return true;
}


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

#endif // __IPSDKIMAGEPROCESSING_INPUTIMAGETILE3DCOLLSPLIT_H__