shape_ellipse.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <core/mirror.h>
#include <geometry/shape.h>
#include <geometry/ellipse.h>
#include <geometry/eda_angle.h>
#include <math/box2.h>
#include <math/vector2d.h>
 
class SHAPE_LINE_CHAIN;
class SHAPE_ARC;
class CIRCLE;
 
class SHAPE_ELLIPSE : public SHAPE
{
public:
    SHAPE_ELLIPSE();
 
    SHAPE_ELLIPSE( const VECTOR2I& aCenter, int aMajorRadius, int aMinorRadius, const EDA_ANGLE& aRotation );
 
    SHAPE_ELLIPSE( const VECTOR2I& aCenter, int aMajorRadius, int aMinorRadius, const EDA_ANGLE& aRotation,
                   const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle );
 
    SHAPE_ELLIPSE( const VECTOR2I& aCenter, const VECTOR2I& aMajorEndpoint, double aRatio );
 
    SHAPE_ELLIPSE( const VECTOR2I& aCenter, const VECTOR2I& aMajorEndpoint, double aRatio, const EDA_ANGLE& aStartAngle,
                   const EDA_ANGLE& aEndAngle );
 
    SHAPE_ELLIPSE( const SHAPE_ELLIPSE& aOther ) = default;
    SHAPE_ELLIPSE& operator=( const SHAPE_ELLIPSE& ) = default;
    ~SHAPE_ELLIPSE() override = default;

    bool operator==( const SHAPE_ELLIPSE& aOther ) const
    {
        return m_isArc == aOther.m_isArc && m_ellipse.Center == aOther.m_ellipse.Center
               && m_ellipse.MajorRadius == aOther.m_ellipse.MajorRadius
               && m_ellipse.MinorRadius == aOther.m_ellipse.MinorRadius
               && m_ellipse.Rotation == aOther.m_ellipse.Rotation && m_ellipse.StartAngle == aOther.m_ellipse.StartAngle
               && m_ellipse.EndAngle == aOther.m_ellipse.EndAngle;
    }
 
    SHAPE* Clone() const override { return new SHAPE_ELLIPSE( *this ); }
 
    const VECTOR2I&  GetCenter() const { return m_ellipse.Center; }
    int              GetMajorRadius() const { return m_ellipse.MajorRadius; }
    int              GetMinorRadius() const { return m_ellipse.MinorRadius; }
    const EDA_ANGLE& GetRotation() const { return m_ellipse.Rotation; }
    const EDA_ANGLE& GetStartAngle() const { return m_ellipse.StartAngle; }
    const EDA_ANGLE& GetEndAngle() const { return m_ellipse.EndAngle; }
 
    bool IsArc() const { return m_isArc; }
 
    void SetCenter( const VECTOR2I& aCenter );
    void SetMajorRadius( int aRadius );
    void SetMinorRadius( int aRadius );
    void SetRotation( const EDA_ANGLE& aAngle );
    void SetStartAngle( const EDA_ANGLE& aAngle );
    void SetEndAngle( const EDA_ANGLE& aAngle );
 
    const BOX2I BBox( int aClearance = 0 ) const override;
 
    bool Collide( const SEG& aSeg, int aClearance = 0, int* aActual = nullptr,
                  VECTOR2I* aLocation = nullptr ) const override;
 
    bool Collide( const SHAPE* aShape, int aClearance = 0, int* aActual = nullptr,
                  VECTOR2I* aLocation = nullptr ) const override
    {
        return SHAPE::Collide( aShape, aClearance, aActual, aLocation );
    }
 
    void TransformToPolygon( SHAPE_POLY_SET& aBuffer, int aError, ERROR_LOC aErrorLoc ) const override;
 
    void Rotate( const EDA_ANGLE& aAngle, const VECTOR2I& aCenter = { 0, 0 } ) override;
    void Move( const VECTOR2I& aVector ) override;
 
    bool IsSolid() const override { return !m_isArc; }

    void Mirror( const VECTOR2I& aRef, FLIP_DIRECTION aFlipDirection );

    const std::string Format( bool aCplusPlus = true ) const override;
 
    double GetLength() const;

    SHAPE_LINE_CHAIN ConvertToPolyline( int aMaxError ) const;
 
    bool PointInside( const VECTOR2I& aPt, int aAccuracy = 0, bool aUseBBoxCache = false ) const override;
 
    SEG::ecoord SquaredDistance( const VECTOR2I& aP, bool aOutlineOnly = false ) const override;

    VECTOR2I NearestPoint( const VECTOR2I& aP ) const;

    std::vector<VECTOR2I> Intersect( const SHAPE_ELLIPSE& aOther ) const;
    std::vector<VECTOR2I> Intersect( const CIRCLE& aCircle ) const;
    std::vector<VECTOR2I> Intersect( const SHAPE_ARC& aArc ) const;

    std::vector<VECTOR2I> Intersect( const SEG& aSeg, bool aTreatAsLine = false ) const;
 
private:
    struct CONIC
    {
        double Axx;
        double Axy;
        double Ayy;
        double Bx;
        double By;
        double C;
    };

    void normalize();

    void updateCache();

    bool isAngleInSweep( double aAngleRad ) const;

    void sweepRange( double& aStart, double& aEnd ) const;
 
    VECTOR2D toLocal( const VECTOR2I& aP ) const;
    VECTOR2I toWorld( const VECTOR2D& aP ) const;

    VECTOR2D pointAtParam( double aTheta ) const;

    VECTOR2D closestLocalPoint( const VECTOR2D& aLocal ) const;

    CONIC conicOf( const VECTOR2I& aCenter, double aMajorR, double aMinorR, const EDA_ANGLE& aRotation ) const;

    std::vector<double> conicRoots( const CONIC& aConic ) const;

    std::vector<VECTOR2I> intersectCircle( const VECTOR2I& aCenter, double aRadius ) const;
 
    ELLIPSE<int> m_ellipse; 
    bool         m_isArc;   
 
    double m_sinRot;      
    double m_cosRot;      
    double m_invMajorRSq; 
    double m_invMinorRSq; 
};