TranslationTransform2d.h

// TranslationTransform2d.h:
// -------------------------
//

#ifndef __IPSDKGEOMETRY_TRANSLATIONTRANSFORM2D_H__
#define __IPSDKGEOMETRY_TRANSLATIONTRANSFORM2D_H__

#include <IPSDKGeometry/Transform/2d/BaseGeometryTransform2d.h>
#include <IPSDKGeometry/Entity/2d/Vector/Vector2d.h>
#include <IPSDKMath/Geometry/2d/Transform/Translation2d.h>

namespace ipsdk {
namespace geom {


class IPSDKGEOMETRY_API TranslationTransform2d : public BaseGeometryTransform2d
{
    // declare geometry transform 2d
    IPSDK_DECLARE_GEOMETRY_TRANSFORM_2D(IPSDKGeometry, TranslationTransform2d)

// predefined public types
public:
    static const eTransform2dType::domain g_transform2dType = eTransform2dType::eT2DT_Translation;

public:
    TranslationTransform2d();
    TranslationTransform2d(const ipReal64 xOffset, const ipReal64 yOffset);
    TranslationTransform2d(const Vector2d& vec);
    TranslationTransform2d(const math::transform::Translation2d& transform);
    ~TranslationTransform2d();

// methods
public:
    eTransform2dType    getTransform2dType() const;

    void                init(const ipReal64 xOffset,
                             const ipReal64 yOffset);
    void                init(const Vector2d& vec);
    void                init(const math::transform::Translation2d& transform);

protected:
    template <typename T>
    void                processPoint(Point2dData<T>& entity) const;
    template <typename T>
    bool                processInSitu(Point2d<T>& entity) const;
    bool                processInSitu(Vector2d& entity) const;
    template <typename T>
    bool                processInSitu(BoundingBox2d<T>& entity) const;
    template <typename T>
    bool                processInSitu(PointCloud2d<T>& entity) const;
    template <typename T>
    bool                processInSitu(Polygon2d<T>& entity) const;
    template <typename T>
    bool                processInSitu(PolygonWithHoles2d<T>& entity) const;
    bool                processInSitu(Shape2d& entity) const;
    template <typename T>
    bool                processInSitu(Circle2d<T>& entity) const;
    template <typename T>
    bool                processInSitu(Ellipse2d<T>& entity) const;
    template <typename T>
    bool                processInSitu(Square2d<T>& entity) const;
    template <typename T>
    bool                processInSitu(Rectangle2d<T>& entity) const;
    bool                processInSitu(Line2d& entity) const;
    bool                processInSitu(Parabola2d& entity) const;
    template <typename T>
    bool                processInSitu(Segment2d<T>& entity) const;
    
// attributes
protected:
    math::transform::Translation2d  _transform;
};


inline
TranslationTransform2d::TranslationTransform2d(const Vector2d& vec)
{
    init(vec);
}

inline eTransform2dType
TranslationTransform2d::getTransform2dType() const
{
    return g_transform2dType;
}

inline void
TranslationTransform2d::init(const ipReal64 xOffset,
                             const ipReal64 yOffset)
{
    _transform.setParams(xOffset, yOffset);
}

inline void
TranslationTransform2d::init(const Vector2d& vec)
{
    _transform.setParams(vec.getX(), vec.getY());
}

inline void
TranslationTransform2d::init(const math::transform::Translation2d& transform)
{
    _transform = transform;
}


} // end of namespace geom
} // end of namespace ipsdk

#endif // __IPSDKGEOMETRY_TRANSLATIONTRANSFORM2D_H__