Arc2D.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Math Library
 * Module     : Arc2D
 * Package    : Zeus.ZeusMath.Geometry
 * Author     : Martin Abbuehl
 * Date       : 27.12.2011
 * System     : Zeus-Framework
 *****************************************************************************
 * Licence:                                                                  *
 *   This library is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU Lesser General Public License as          *
 *   published by the Free Software Foundation; either version               *
 *   2.1 of the License, or (at your option) any later version.              *
 *                                                                           *
 *   This library is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
 *   GNU Lesser General Public License for more details.                     *
 *                                                                           *
 *   You should have received a copy of the GNU Lesser General Public        *
 *   License along with this library; if not, write to the Free Software     *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
 *****************************************************************************/

/*****************************************************************************
 * Changes:
 *  27.12.2011 bha: created zeus 2.0
 *****************************************************************************/

#ifndef Arc2DH
#define Arc2DH

#include <zeusmath/Geometry/Interfaces/IArc2D.hpp>
#include <zeusmath/Geometry/Circle2D.h>
#include <zeusmath/System/Angle.h>


BEGIN_NAMESPACE_Zeus


/******************************************************************************/
/******************************************************************************/
zeusmath_class TArc2D : public IArc2D
{
  public:
    inline TArc2D() { }

    TArc2D(const IVector2D& rVecCenter, const Float& rfRadius,
           const IAngle& rStartAngle, const IAngle& rEndAngle,
           bool bAnglesAreGivenCounterClockwise);

    TArc2D(const ICircle2D& rCircle, const IAngle& rStartAngle,
           const IAngle& rEndAngle, bool bAnglesAreGivenCounterClockwise);

    inline TArc2D(const TArc2D& rArc) { *this = rArc; }

    inline TArc2D(const IArc2D& rArc) { *this = rArc; }

    static bool createFrom3Points(const IVector2D& rVecStartPoint,
                                  const IVector2D& rVecEndPoint,
                                  const IVector2D& rVecIntermediatePoint,
                                  IArc2D& rArc);

    static bool createFrom2PointsRadiusAndFlags(const IVector2D& rVecStartPoint,
                                                const IVector2D& rVecEndPoint,
                                                const Float& rfRadius,
                                                bool bPointsAreGivenCounterClockwise,
                                                bool bShorterArc, IArc2D& rArc,
                                                const Float& rfTangentTolerance =
                                                  INTERSECT_TANGENT_TOLERANCE);

    static bool createFrom2PointsAndCenter(const IVector2D& rVecStartPoint,
                                           const IVector2D& rVecEndPoint,
                                           const IVector2D& rVecCenter,
                                           bool bPointsAreGivenCounterClockwise,
                                           IArc2D& rArc,
                                           const Float& rfTangentTolerance =
                                                  INTERSECT_TANGENT_TOLERANCE);

    /******************************************************************************/
    /******************************************************************************/
    virtual inline ~TArc2D() { }

    /******************************************************************************/
    /******************************************************************************/
    virtual inline       ICircle2D& MQUALIFIER getCircle()            { return m_Circle; }
    virtual inline const ICircle2D& MQUALIFIER getCircleConst() const { return m_Circle; }
    
    virtual inline void MQUALIFIER setCircle(const ICircle2D& rCircle) { m_Circle = rCircle; }

    virtual inline const IVector2D& MQUALIFIER getCenter() const { return getCircleConst().getCenter(); }
    virtual inline void MQUALIFIER setCenter(const IVector2D& rVecCenter) { getCircle().setCenter(rVecCenter); }

    virtual inline const Float& MQUALIFIER getRadius() const { return getCircleConst().getRadius(); }
    virtual inline void MQUALIFIER setRadius(const Float& rfRadius) { getCircle().setRadius(rfRadius); }

    virtual inline const IAngle& MQUALIFIER getStartAngle() const { return m_StartAngle; }
    virtual inline const IAngle& MQUALIFIER getEndAngle()   const { return m_EndAngle; }
    virtual void MQUALIFIER setStartAngle(const IAngle& rStartAngle);
    virtual void MQUALIFIER setEndAngle  (const IAngle& rEndAngle);

    virtual void MQUALIFIER setAngles(const IAngle& rStartAngle, const IAngle& rEndAngle,
                                      bool bAnglesAreGivenCounterClockwise);

    virtual void MQUALIFIER switchAngles();

    virtual void MQUALIFIER getStartPoint(IVector2D& rVecStart) const;
    virtual void MQUALIFIER getEndPoint(IVector2D& rVecEnd) const;
    virtual void MQUALIFIER createSupplementArc(IArc2D& rSupplementArc) const;
    virtual bool MQUALIFIER isShorterThanSupplementArc() const;

    virtual inline void MQUALIFIER assign(const IArc2D& rArc) { *this = rArc; }

    virtual inline bool MQUALIFIER isEqual(const IArc2D& rArc) const { return *this == rArc; }

    virtual bool MQUALIFIER containsAngle(const IAngle& rAngle,
                                          bool bIncludeStartAndEndPoints = true) const;

    virtual bool MQUALIFIER containsPoint2(const IVector2D& rVecPoint,
                                           bool bIncludeStartAndEndPoints = true,
                                           const Float& rfTolerance = 0) const;

    virtual void MQUALIFIER moveStartPointOnCircle(const Float& rfDistance, bool bCounterClockwise);
    virtual void MQUALIFIER moveEndPointOnCircle(const Float& rfDistance, bool bCounterClockwise);

    /**************************************************************************/
    /* Static methods to calculate tangent arcs.                              */
    /**************************************************************************/
    static Retval calcArcsTangentTo2StraightLines(const IStraightLine2D& rStraightLine1,
                                                  const IStraightLine2D& rStraightLine2,
                                                  const Float& rfRadius,
                                                  IList<IArc2D>& rLstTangentArcs,
                                                  const Float& rfTangentTolerance =
                                                    INTERSECT_TANGENT_TOLERANCE);

    static Retval calcArcsTangentToStraightLineAndCircle(const IStraightLine2D& rStraightLine,
                                                         const ICircle2D& rCircle,
                                                         const Float& rfRadius,
                                                         IList<IArc2D>& rLstTangentArcs,
                                                         const Float& rfTangentTolerance =
                                                           INTERSECT_TANGENT_TOLERANCE);

    static Retval calcArcsTangentTo2Circles(const ICircle2D& rCircle1,
                                            const ICircle2D& rCircle2,
                                            const Float& rfRadius,
                                            IList<IArc2D>& rLstTangentArcs,
                                            const Float& rfTangentTolerance =
                                              INTERSECT_TANGENT_TOLERANCE);

    static Retval calcArcsTangentTo2LineSegments(const ILineSegment2D& rLineSegment1,
                                                 const ILineSegment2D& rLineSegment2,
                                                 const Float& rfRadius,
                                                 IList<IArc2D>& rLstTangentArcs,
                                                 const Float& rfTangentTolerance =
                                                   INTERSECT_TANGENT_TOLERANCE);

    static Retval calcArcsTangentToLineSegmentAndArc(const ILineSegment2D& rLineSegment,
                                                     const IArc2D& rArc,
                                                     const Float& rfRadius,
                                                     IList<IArc2D>& rLstTangentArcs,
                                                     const Float& rfTangentTolerance =
                                                       INTERSECT_TANGENT_TOLERANCE);

    static Retval calcArcsTangentTo2Arcs(const IArc2D& rArc1, const IArc2D& rArc2,
                                         const Float& rfRadius,
                                         IList<IArc2D>& rLstTangentArcs,
                                         const Float& rfTangentTolerance = INTERSECT_TANGENT_TOLERANCE);

    /******************************************************************************/
    /******************************************************************************/
    virtual inline const InterfaceID& MQUALIFIER getInterfaceID() const { return m_InterfaceID; }

    virtual Float MQUALIFIER getLength() const;

    virtual Retval MQUALIFIER getPointFromRunningParameter(const Float& rfRunningParameter,
                                                           IVector2D& rvecPoint) const;

    virtual Retval MQUALIFIER intersect(const IGeometricObject2D& rObject,
                                        IList<IVector2D>& rLstIntersectionPoints,
                                        const Float& rfTangentTolerance = INTERSECT_TANGENT_TOLERANCE) const;

    virtual inline bool MQUALIFIER containsPoint(const IVector2D& rVecPoint,
                                                 const Float& rfTolerance = 0) const
    { return containsPoint2(rVecPoint, true, rfTolerance); }

    virtual void MQUALIFIER calcClosestPointToPoint(const IVector2D& rVecPoint,
                                                    IVector2D& rVecClosestPoint) const;

    virtual Float MQUALIFIER calcDistanceToPoint(const IVector2D& rVecPoint) const;
    virtual Float MQUALIFIER calcDistanceToObject(const IGeometricObject2D& rObject) const;

    virtual Retval MQUALIFIER getXMinPoint(IVector2D& rVecPoint) const;
    virtual Retval MQUALIFIER getXMaxPoint(IVector2D& rVecPoint) const;
    virtual Retval MQUALIFIER getYMinPoint(IVector2D& rVecPoint) const;
    virtual Retval MQUALIFIER getYMaxPoint(IVector2D& rVecPoint) const;

    virtual void MQUALIFIER getMinMaxCoordinates(Float& rfXMin, Float& rfXMax,
                                                 Float& rfYMin, Float& rfYMax) const;

    /******************************************************************************/
    /******************************************************************************/
    const TArc2D& operator=(const IArc2D& rArc);

    const TArc2D& operator=(const TArc2D& rArc);

    /******************************************************************************/
    /******************************************************************************/
    /******************************************************************************/
    bool operator==(const IArc2D& rArc) const;

    inline bool operator!=(const IArc2D& rArc) const { return !(*this == rArc); }

  private:
    static void createFrom2PointsCenterAndRadius(const IVector2D& rVecStartPoint,
                                                 const IVector2D& rVecEndPoint,
                                                 const IVector2D& rVecCenter,
                                                 const Float& rfRadius,
                                                 bool bPointsAreGivenCounterClockwise,
                                                 IArc2D& rArc);

    static bool transformTangentCirclesToArcs(const IList<ICircle2D>& rLstTangentCircles,
                                              const IGeometricObject2D& rObject1,
                                              const IGeometricObject2D& rObject2,
                                              IList<IArc2D>& rLstTangentArcs,
                                              const Float& rfTangentTolerance =
                                                INTERSECT_TANGENT_TOLERANCE);

  private:
    // The underlying, defining circle.
    TCircle2D m_Circle;

    // The start and end angles.
    TAngle m_StartAngle;
    TAngle m_EndAngle;

    // Static members.
    static const InterfaceID m_InterfaceID;
};


END_NAMESPACE_Zeus

#endif