基本几何对象(7)——Circle

最新推荐文章于 2024-06-05 15:16:22 发布

.猪饲料.

最新推荐文章于 2024-06-05 15:16:22 发布

阅读量64

点赞数 2

分类专栏：部分平面几何算法的C++实现文章标签： c++ 几何学

本文链接：https://blog.csdn.net/qq_34343690/article/details/138309147

版权

部分平面几何算法的C++实现专栏收录该内容

17 篇文章 3 订阅

订阅专栏

定义Circle类，用圆心和半径表示圆。

下面给出Circle的声明。

class Circle : public Geometry
{
    private:
        Point _center;
        double _radius = 0;

    public:
        Circle() {};

        Circle(const double x, const double y, const double r);

        Circle(const Point &point, const double r);

        Circle(const Circle &circle);

        Circle &operator=(const Circle &circle);

        const Type type() const override;

        Point &center();

        const Point &center() const;

        double &radius();

        const double radius() const;

        const double area() const;

        const double length() const override;

        const bool empty() const override;

        void clear() override;

        Circle *clone() const override;

        void transform(const double a, const double b, const double c, const double d, const double e, const double f) override;

        void transform(const double mat[6]) override;

        void translate(const double tx, const double ty) override;

        void rotate(const double x, const double y, const double rad) override; // 弧度制

        void scale(const double x, const double y, const double k) override;

        AABBRect bounding_rect() const override;

        Polygon mini_bounding_rect() const override;

        Circle operator+(const Point &point) const;

        Circle operator-(const Point &point) const;

        void operator+=(const Point &point);

        void operator-=(const Point &point);
};

下面给出Circle的实现。

Circle::Circle(const double x, const double y, const double r)
    :_center(x, y)
    ,_radius(r)
{
    assert(r > 0);
}

Circle::Circle(const Point &point, const double r)
    :_center(point)
    ,_radius(r)
{
    assert(r > 0);
}

Circle::Circle(const Circle &circle)
    :Geometry(circle)
    ,_center(circle._center)
    ,_radius(circle._radius)
{}

Circle &Circle::operator=(const Circle &circle)
{
    if (this != &circle)
    {
        Geometry::operator=(circle);
        _center = circle._center;
        _radius = circle._radius;
    }
    return *this;
}

const Type Circle::type() const
{
    return Type::CIRCLE;
}

Point &Circle::center()
{
    return _center;
}

const Point &Circle::center() const
{
    return _center;
}

double &Circle::radius()
{
    return _radius;
}

const double Circle::radius() const
{
    return _radius;
}

const double Circle::area() const
{
    return Geo::PI * _radius * _radius;
}

const double Circle::length() const
{
    return 2.0 * Geo::PI * _radius;
}

const bool Circle::empty() const
{
    return _radius <= 0;
}

void Circle::clear()
{
    _radius = 0;
    _center.clear();
}

Circle *Circle::clone() const
{
    return new Circle(*this);
}

void Circle::transform(const double a, const double b, const double c, const double d, const double e, const double f)
{
    _center.transform(a,b,c,d,e,f);
    _radius *= std::abs(a);
}

void Circle::transform(const double mat[6])
{
    _center.transform(mat);
    _radius *= std::abs(mat[0]);
}

void Circle::translate(const double tx, const double ty)
{
   _center.translate(tx, ty);
}

void Circle::rotate(const double x, const double y, const double rad)
{
    _center.rotate(x, y, rad);
}

void Circle::scale(const double x, const double y, const double k)
{
    _center.scale(x, y, k);
    _radius *= k;
}

AABBRect Circle::bounding_rect() const
{
    if (_radius == 0)
    {
        return AABBRect();
    }
    else
    {
        return AABBRect(_center.x - _radius, _center.y + _radius, _center.x + _radius, _center.y - _radius);
    }
}

Polygon Circle::mini_bounding_rect() const
{
    if (_radius == 0)
    {
        return Polygon();
    }
    else
    {
        return AABBRect(_center.x - _radius, _center.y + _radius, _center.x + _radius, _center.y - _radius);
    }
}

Circle Circle::operator+(const Point &point) const
{
    return Circle(_center + point, _radius);
}

Circle Circle::operator-(const Point &point) const
{
    return Circle(_center - point, _radius);
}

void Circle::operator+=(const Point &point)
{
    _center += point;
}

void Circle::operator-=(const Point &point)
{
    _center -= point;
}