基本几何对象(8)——Line

最新推荐文章于 2024-09-23 20:41:21 发布

.猪饲料.

最新推荐文章于 2024-09-23 20:41:21 发布

阅读量88

点赞数 1

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

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

版权

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

17 篇文章 5 订阅

订阅专栏

本文介绍了如何在C++中定义Line类，用于表示线段或直线，包括构造函数、赋值重载、运算符实现以及几何属性计算，如长度、是否为空、边界矩形等方法。

摘要由CSDN通过智能技术生成

定义Line类，表示有限长的线段或无限长的直线，但这个类很少用，因为通常都是直接用两点表示Line了。

下面给出Line的声明。

class Line : public Geometry
{
    private:
        Point _start_point;
        Point _end_point;

    public:
        Line() {};

        Line(const double x0, const double y0, const double x1, const double y1);

        Line(const Point &start, const Point &end);

        Line(const Line &line);

        const Type type() const override;

        Line &operator=(const Line &line);

        Line operator+(const Point &point);

        Line operator-(const Point &point);

        void operator+=(const Point &point);

        void operator-=(const Point &point);

        const double length() const override;

        const bool empty() const override;

        void clear() override;

        Line *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;

        Point &front();

        const Point &front() const;

        Point &back();

        const Point &back() const;
};

下面给出Line的实现。

Line::Line(const double x0, const double y0, const double x1, const double y1)
    :_start_point(x0, y0)
    ,_end_point(x1, y1)
{}

Line::Line(const Point &start, const Point &end)
    :_start_point(start)
    ,_end_point(end)
{}

Line::Line(const Line &line)
    :Geometry(line)
    ,_start_point(line._start_point)
    ,_end_point(line._end_point)
{}

Line &Line::operator=(const Line &line)
{
    if (this != &line)
    {
        Geometry::operator=(line);
        _start_point = line._start_point;
        _end_point = line._end_point;
    }
    return *this;
}

const Type Line::type() const
{
    return Type::LINE;
}

Line Line::operator+(const Point &point)
{
    return Line(_start_point + point, _end_point + point);
}

Line Line::operator-(const Point &point)
{
    return Line(_start_point - point, _end_point - point);
}

void Line::operator+=(const Point &point)
{
    _start_point += point;
    _end_point += point;
}

void Line::operator-=(const Point &point)
{
    _start_point -= point;
    _end_point -= point;
}

const double Line::length() const
{
    return Geo::distance(_start_point, _end_point);
}

const bool Line::empty() const
{
    return _start_point == _end_point;
}

void Line::clear()
{
    _start_point.clear();
    _end_point.clear();
}

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

void Line::transform(const double a, const double b, const double c, const double d, const double e, const double f)
{
    _start_point.transform(a,b,c,d,e,f);
    _end_point.transform(a,b,c,d,e,f);
}

void Line::transform(const double mat[6])
{
    _start_point.transform(mat);
    _end_point.transform(mat);
}

void Line::translate(const double tx, const double ty)
{
    _start_point.translate(tx, ty);
    _end_point.translate(tx, ty);
}

void Line::rotate(const double x, const double y, const double rad)
{
    _start_point.rotate(x, y, rad);
    _end_point.rotate(x, y, rad);
}

void Line::scale(const double x, const double y, const double k)
{
    _start_point.scale(x, y, k);
    _end_point.scale(x, y, k);
}

AABBRect Line::bounding_rect() const
{
    if (_start_point == _end_point)
    {
        return AABBRect();
    }
    else
    {
        return AABBRect(std::min(_start_point.x, _end_point.x),
                        std::max(_start_point.y, _end_point.y),
                        std::max(_start_point.x, _end_point.x),
                        std::min(_start_point.y, _end_point.y));
    }
}

Polygon Line::mini_bounding_rect() const
{
    if (_start_point == _end_point)
    {
        return Polygon();
    }
    else
    {
        return AABBRect(std::min(_start_point.x, _end_point.x),
                        std::max(_start_point.y, _end_point.y),
                        std::max(_start_point.x, _end_point.x),
                        std::min(_start_point.y, _end_point.y));
    }
}

Point &Line::front()
{
    return _start_point;
}

const Point &Line::front() const
{
    return _start_point;
}

Point &Line::back()
{
    return _end_point;
}

const Point &Line::back() const
{
    return _end_point;
}