algorithm/line_vacuate/studio_geo_c.c

/**
******************************************************************************
* @file           : studio_geo_c.h
* @author         : wangyingjie
* @brief          : 几何矢量类型 C 语言版
* @attention      : None
* @date           : 2025/5/10
******************************************************************************
*/

#include "studio_geo_c.h"

////////////// 点 //////////////

studio_point_c studio_point_init(double xx, double yy)
{
    studio_point_c point = {xx, yy};
    return point;
}

bool studio_point_equal(const studio_point_c *p1, const studio_point_c *p2)
{
    bool is_equal = fabs(p1->x - p2->x) <= AO_EPSILON && fabs(p1->y - p2->y) <= AO_EPSILON;
    return is_equal;
}

////////////// 线 //////////////

// 初始化线段 (默认容量为4)
studio_line_c studio_line_c_init()
{
    studio_line_c line;
    line.size = 0;
    line.capacity = 4;
    line.data = (studio_point_c *) malloc(line.capacity * sizeof(studio_point_c));
    return line; // 注意: 返回结构体副本 (需配合 C99 或更高标准)
}

// 销毁线段 (释放内存)
void studio_line_c_destroy(studio_line_c *line)
{
    if (line->data)
    {
        free(line->data);
        line->data = NULL;
        line->size = 0;
        line->capacity = 0;
    }
}

// 添加点 (自动扩容)
void studio_line_c_add_point(studio_line_c *line, studio_point_c point)
{
    // 容量不足时扩容 (策略: 增加固定容量 10)
    if (line->size >= line->capacity)
    {
        line->capacity += 10;
        studio_point_c *new_data = (studio_point_c *) realloc(line->data, line->capacity * sizeof(studio_point_c));
        if (!new_data)
        {
            // 此处可添加错误处理 (例如: 终止程序或返回错误码)
            return;
        }
        line->data = new_data;
    }

    // 添加新元素
    line->data[line->size++] = point;
}

// 获取当前元素数量
unsigned int studio_line_c_size(const studio_line_c *line)
{
    return line->size;
}

// 获取指定位置的点的引用 (注意索引越界问题)
studio_point_c studio_line_c_get_point(const studio_line_c *line, unsigned int index)
{
    studio_point_c tmp;
    if (index < line->size)
    {
        tmp = line->data[index];
        return tmp;
    }
    return tmp; // 越界返回空指针
}

////////////// 矩形 //////////////

studio_rect_c studio_rect_init(double l, double t, double r, double b)
{
    studio_rect_c rect = {studio_point_init(l, t), studio_point_init(r, b)};
    return rect;
}

void studio_rect_correct(studio_rect_c *rect)
{
    if (rect->left_top.x > rect->right_bottom.x)
    {
        double temp = rect->left_top.x;
        rect->left_top.x = rect->right_bottom.x;
        rect->right_bottom.x = temp;
    }
    if (rect->left_top.y < rect->right_bottom.y)
    {
        double temp = rect->left_top.y;
        rect->left_top.y = rect->right_bottom.y;
        rect->right_bottom.y = temp;
    }
}

bool studio_rect_intersect(const studio_rect_c *r1, const studio_rect_c *r2)
{
    return !(r1->right_bottom.x < r2->left_top.x || r1->left_top.x > r2->right_bottom.x || r1->right_bottom.y > r2->
             left_top.y || r1->left_top.y < r2->right_bottom.y);
}

////////////// 圆 //////////////

studio_circle_c studio_circle_init(studio_point_c center, double radius)
{
    studio_circle_c circle = {center, radius};
    return circle;
}

double studio_circle_area(const studio_circle_c *circle)
{
    return AO_M_PI * circle->radius * circle->radius;
}

////////////// 三角形 //////////////

studio_triangle_c studio_triangle_init(studio_point_c a, studio_point_c b, studio_point_c c)
{
    studio_triangle_c triangle = {a, b, c};
    return triangle;
}

double studio_triangle_oriented_area(const studio_triangle_c *triangle)
{
    return (triangle->a.x * (triangle->b.y - triangle->c.y) + triangle->b.x * (triangle->c.y - triangle->a.y) + triangle
            ->c.x * (triangle->a.y - triangle->b.y)) / 2.0;
}

double studio_triangle_area(const studio_triangle_c *triangle)
{
    return fabs(studio_triangle_oriented_area(triangle));
}

////////////// 椭圆 //////////////

studio_ellipse_c studio_ellipse_init(studio_point_c center, double rx, double ry)
{
    studio_ellipse_c ellipse = {center, rx, ry};
    return ellipse;
}

double studio_ellipse_area(const studio_ellipse_c *ellipse)
{
    return AO_M_PI * ellipse->rx * ellipse->ry;
}

double studio_ellipse_circumference(const studio_ellipse_c *ellipse, int Ramanujan)
{
    if (Ramanujan == 1)
    {
        return AO_M_PI * (3 * (ellipse->rx + ellipse->ry) - sqrt(
                              (3 * ellipse->rx + ellipse->ry) * (ellipse->rx + 3 * ellipse->ry)));
    }
    return 2 * AO_M_PI * sqrt((ellipse->rx * ellipse->rx + ellipse->ry * ellipse->ry) / 2);
}