点、矩形旋转后的新的点+判断曲线是否在矩形范围内

/**
 * @brief 判断曲线【n条直线】是否在QMesh范围内
 * @param[in] polyline - 待检测的线【包含n条直线】
 * @param[in] offset - 每个点的偏移量，对于已经转换好的点offset.x和offset.y都设置为0；
 * @param[in] recSrc - 矩形框范围
 * @return 在矩形框范围内，返回ture，否则返回false；
 */
bool testInRange(const Polyline polyline, const Point offset, const Rectangle recSrc);

/**
 * @brief 判断直线是否在QMesh范围内
 * @param[in] vector - 某条直线
 * @param[in] recSrc - 矩形框范围
 * @return 直线属于直线，返回true，否则返回false；
 */
bool IsLineInRectangle(RtVector * vector, const Rectangle rect);

/**
 * @brief 起始点绕中心点旋转指定度数后的新点
 * @param[in] rotateCenter - 旋转中心点
 * @param[in] pt - 旋转点
 * @param[in] angel - 旋转角度
 * @return 返回旋转后的点
 * @note
 * 1. angle需要传入角度对应的弧度值，正为顺时针，负为逆时针.
 */
Point PointRotate(const Point rotateCenter, const Point pt, const double angleHude);

/**
 * @brief 矩形绕自身中心点按照指定度数进行旋转
 * @param[in] pRectangle - 旋转矩形
 * @param[in] angel - 旋转角度
 * @return 返回旋转后的点
 * @note
 * 1. angle需要传入角度，正为顺时针，负为逆时针.
 */
void RetancgleRotate(Rectangle * pRectangle, const double angle);


bool IsLineInRectangle(RtVector * vector, const Rectangle rect)
{
    int i = 0;
    bool flag = false;
    int16_t u1 = 0, u2 =1;
    int16_t p[4], q[4];
    int16_t r;

    p[0] = vector->sp.x - vector->ep.x;
    p[1] = vector->ep.x - vector->sp.x;
    p[2] = vector->sp.y - vector->ep.y;
    p[3] = -vector->sp.y + vector->ep.y;
    q[0] = vector->sp.x - rect.x;
    q[1] = rect.x + rect.width - vector->sp.x;
    q[2] = vector->sp.y - rect.y;
    q[3] = rect.y + rect.height - vector->sp.y;

    if (0 == p[0] && ((vector->sp.x < rect.x) || (vector->sp.x > (rect.x + rect.width))))
    {
        return false;
    }
    if (0 == p[2] && ((vector->sp.y < rect.y) || (vector->sp.y > (rect.y + rect.height))))
    {
        return false;
    }

    for (i = 0; i < 4; ++i)
    {
        r = (float)q[i] / (float)p[i];
        if (p[i] < 0)
        {
            u1 = max(u1, r);
            if(u1 > u2)
            {
                flag = true;
            }
        }
        if (p[i] > 0)
        {
            u2 = min(u2, r);
            if (u1 > u2)
            {
                flag = true;
            }
        }
        if (0 == p[i] && p[i] < 0)
        {
            flag = true;
        }
    }

    if (flag)
    {
        return false;
    }

    return true;
}

bool testInRange(const Polyline polyline,const Point offset, const Rectangle recSrc)
{
    uint32_t i = 0;
    RtVector rtVect;

    if (polyline.count < 2)
    {
        return false;
    }

    for (i = 0; i < (polyline.count - 1); ++i)
    {
        rtVect.sp.x = polyline.pPoints[i].x + offset.x;
        rtVect.sp.y = polyline.pPoints[i].y + offset.y;

        rtVect.ep.x = polyline.pPoints[i + 1].x + offset.x;
        rtVect.ep.y = polyline.pPoints[i + 1].y + offset.y;

        if (IsLineInRectangle(&rtVect, recSrc))
        {
            return true;
        }
    }

    return false;
}

Point PointRotate(const Point rotateCenter, const Point pt, const double angleHude)
{
    Point newPt;
    double xNew, yNew;

    xNew = (pt.x - rotateCenter.x) * cos(angleHude) +
            (pt.y - rotateCenter.y) * sin(angleHude) + rotateCenter .x;
    yNew = -(pt.x - rotateCenter.x) * sin(angleHude) +
            (pt.y - rotateCenter.y) * cos(angleHude) + rotateCenter.y;
    newPt.x = (int16_t)xNew;
    newPt.y = (int16_t)yNew;

    return newPt;
}

void RetancgleRotate(Rectangle * pRectangle, const double angle)
{
    Point topLeft, downLeft, topRight, downRight;
    Point pt;
    int16_t Xmin0, Ymax0, Xmax0, Ymin0;
    int16_t Xmin1, Ymax1, Xmax1, Ymin1;
    double angleHude;

    topLeft.x = pRectangle->x;
    topLeft.y = pRectangle->y;

    downLeft.x = topLeft.x;
    downLeft.y = topLeft.y - pRectangle->height;

    topRight.x = topLeft.x + pRectangle->width;
    topRight.y = topLeft.y;

    downRight.x = topRight.x;
    downRight.y = downLeft.y;

    pt.x = topLeft.x + pRectangle->width/2;
    pt.y = topLeft.y - pRectangle->height/2;

    angleHude = angle * PI / 180;

    topLeft = PointRotate(pt, topLeft, angleHude);
    downLeft = PointRotate(pt, downLeft, angleHude);
    topRight = PointRotate(pt, topRight, angleHude);
    downRight = PointRotate(pt, downRight, angleHude);

    {
        ///< 对角点进行比较
        if (topLeft.x > downRight.x)
        {
            Xmin0 = downRight.x;
            Xmax0 = topLeft.x;
        }
        else
        {
            Xmin0 = topLeft.x;
            Xmax0 = downRight.x;
        }
        if (topLeft.y > downRight.y)
        {
            Ymin0 = downRight.y;
            Ymax0 = topLeft.y;
        }
        else
        {
            Ymin0 = topLeft.y;
            Ymax0 = downRight.y;
        }

        ///< 对角点进行比较
        if (topRight.x > downLeft.x)
        {
            Xmin1 = downLeft.x;
            Xmax1 = topRight.x;
        }
        else
        {
            Xmin1 = topRight.x;
            Xmax1 = downLeft.x;
        }
        if (topRight.y > downLeft.y)
        {
            Ymin1 = downLeft.y;
            Ymax1 = topRight.y;
        }
        else
        {
            Ymin1 = topRight.y;
            Ymax1 = downLeft.y;
        }

        ///< 找出x、y最小最大值
        Xmin0 = Xmin0 > Xmin1 ? Xmin1 : Xmin0;
        Xmax0 = Xmax0 > Xmax1 ? Xmax0 : Xmax1;
        Ymin0 = Ymin0 > Ymin1 ? Ymin1 : Ymin0;
        Ymax0 = Ymax0 > Ymax1 ? Ymax0 : Ymax1;
    }

    pRectangle->x = Xmin0;
    pRectangle->y = -Ymax0; ///< 屏幕坐标系和计算旋转点的坐标系的y轴是相反的，因此取反
    pRectangle->width = Xmax0 - Xmin0;
    pRectangle->height = Ymax0 - Ymin0;

    return;
}