Question

我只是通过移动其中一个抓点来改变弧形，我遇到了一些麻烦。

我得到三分：中心点center，起点start和终点end。只有两种可能的行动：

更改start，end保持不变，
更改end，start保持不变。

我发现：

更改其中一个点的位置，

使用以下公式使用旧中心点和未触及点重新计算半径：

if (start.changed) {
    radius = std::sqrt(
        (center.x - end.x) * (center.x - end.x) +
        (center.y - end.y) * (center.y - end.y)
    );
}
if (end.changed) {
    radius = std::sqrt(
        (center.x - start.x) * (center.m_x - start.x) +
        (center.y - start.y) * (center.m_y - start.y)
    );
}

使用以下公式重新计算弧的角度：

startAngle = std::atan2(start.y - center.y, start.x - center.x);
endAngle   = std::atan2(end.y - center.y, end.x - center.x);

允许我自由修改其角度。我不能调整它的大小。我认为在从列表中执行步骤2和3之前修改中心点可以解决问题。

不幸的是，我尝试的每一个解决方案都失败了，现在我很无助。我怀疑我必须在步骤center和start之间测量end，1和2之间的角度，然后使用该角度计算新的中心。这是对的吗？

This is how it currently looks in different states This is how I'd like it to work

Answer 1

它应该如何工作视频显示在圆2端点上有3个点，在它们之间有一个点（不是圆心）所以你需要在它和你的表示之间进行转换。所以视频有：

A,B - 端点
M - 弧线中点

你得到了：

A,B - 端点
C - 中心
a0,a1 - 假设a0<a1
r - radius

A,B是相同的，a0,a1由atan2计算，就像您已经做过的那样。现在如何计算其余部分：

a = 0.5*(a0+a1);
M.x = C.x + r*cos(a);
M.y = C.y + r*sin(a);

要从A,B,M计算半径，您可以解决此二次系统：

(A.x-C.x)^2 + (A.y-C.y)^2 = r
(B.x-C.x)^2 + (B.y-C.y)^2 = r
(M.x-C.x)^2 + (M.y-C.y)^2 = r

其中C.x,C.y,r是未知数。或者使用这种简单的线性方法：

how to find a bitangent, point of concavity and center of gravity of concavity?

由此您将获得C和r = |A-C| = |B-C|

这里有一个小型C ++演示：

//---------------------------------------------------------------------------
inline bool Intersect2DRayRay(double *pp,double *p0,double *p1,double *p2,double *p3) // pp = intersection point
    {
/*
    p0+(p1-p0)*s = p2+(p3-p2)*t
    ---------------------------
    s = ( (p2-p0)+(p3-p2)*t )/(p1-p0)
    t = ( (p0-p2)+(p1-p0)*s )/(p3-p2)
    ---------------------------------
    s = ( (p2[0]-p0[0])+(p3[0]-p2[0])*t )/(p1[0]-p0[0])
    t = ( (p0[1]-p2[1])+(p1[1]-p0[1])*s )/(p3[1]-p2[1])
    ---------------------------------------------------
        (p1[0]-p0[0])*(p0[1]-p2[1]) + (p1[1]-p0[1])*(p2[0]-p0[0])
    t = ---------------------------------------------------------
        (p1[0]-p0[0])*(p3[1]-p2[1]) - (p1[1]-p0[1])*(p3[0]-p2[0])

        (p1[1]-p0[1])*(p0[0]-p2[0]) + (p1[0]-p0[0])*(p2[1]-p0[1])
    t = ---------------------------------------------------------
        (p1[1]-p0[1])*(p3[0]-p2[0]) - (p1[0]-p0[0])*(p3[1]-p2[1])

    s = ( (p2[0]-p0[0])+(p3[0]-p2[0])*t )/(p1[0]-p0[0])
    s = ( (p2[1]-p0[1])+(p3[1]-p2[1])*t )/(p1[1]-p0[1])
    ---------------------------------------------------
*/
    double s,t,a,b;
    const double _zero=1e-30;
    a=((p1[0]-p0[0])*(p3[1]-p2[1]))-((p1[1]-p0[1])*(p3[0]-p2[0]));
    b=((p1[1]-p0[1])*(p3[0]-p2[0]))-((p1[0]-p0[0])*(p3[1]-p2[1]));
    if (fabs(a)>=fabs(b)) { b=a; a=((p1[0]-p0[0])*(p0[1]-p2[1]))+((p1[1]-p0[1])*(p2[0]-p0[0])); }
    else                  {      a=((p1[1]-p0[1])*(p0[0]-p2[0]))+((p1[0]-p0[0])*(p2[1]-p0[1])); }
    if (fabs(b)<=_zero) // paralelne alebo nulove ciary
        {
        double x0,x1,x2,x3,y0,y1,y2,y3;
        if (p0[0]<p1[0]) { x0=p0[0]; x1=p1[0]; } else { x0=p1[0]; x1=p0[0]; }
        if (p0[1]<p1[1]) { y0=p0[1]; y1=p1[1]; } else { y0=p1[1]; y1=p0[1]; }
        if (p2[0]<p3[0]) { x2=p2[0]; x3=p3[0]; } else { x2=p3[0]; x3=p2[0]; }
        if (p2[1]<p3[1]) { y2=p2[1]; y3=p3[1]; } else { y2=p3[1]; y3=p2[1]; }
        if (x1-x0>_zero)
            {
            if (x3<x0) return false;
            if (x2>x1) return false;
            if (fabs(y3-y0)<=_zero) return true;
            return false;
            }
        if (y1-y0>_zero)
            {
            if (y3<y0) return false;
            if (y2>y1) return false;
            if (fabs(x3-x0)<=_zero) return true;
            return false;
            }
        if (fabs(y3-y0)+fabs(x3-x0)<=_zero) return true;
        return false;
        } else t=a/b;
    a=p1[0]-p0[0];
    b=p1[1]-p0[1];
    if (fabs(a)>=fabs(b)) { b=a; a=(p2[0]-p0[0])+((p3[0]-p2[0])*t); }
    else                  {      a=(p2[1]-p0[1])+((p3[1]-p2[1])*t); }
    if (fabs(b)<=_zero)
        {
        b=1/0;                  // error possibly due to low accuracy or horrible input
        } else s=a/b;
//  if ((s<0.0)||(s>1.0)) return false;
//  if ((t<0.0)||(t>1.0)) return false;
    pp[0]=p0[0]+(p1[0]-p0[0])*s;
    pp[1]=p0[1]+(p1[1]-p0[1])*s;
    return true;
    }
//---------------------------------------------------------------------------
const double _point_r=8.0;  // select and render point size
const double _point_rr=_point_r*_point_r;
enum _arc_sel               // selection ID
    {
    _arc_sel_none=-1,
    _arc_sel_a,
    _arc_sel_b,
    _arc_sel_m,
    };
class arc
    {
public:
    double ax,ay,bx,by,cx,cy,mx,my;
    int sel;    // mouse selection ID
    bool _sel;  // is sel locked? (durring editation)
    arc()   { _sel=false; sel=_arc_sel_none; }
    arc(arc& a) { *this=a; }
    ~arc()  {}
    arc* operator = (const arc *a) { *this=*a; return this; }
    //arc* operator = (const arc &a) { ...copy... return this; }

    // A,B,M -> C
    void compute_c()
        {
        double pp[2],p0[2],p1[2],p2[2],p3[3];
        // center is intersection of normals from line midpoints
        p0[0]=0.5*(ax+mx); p1[0]=p0[0]+ay-my;
        p0[1]=0.5*(ay+my); p1[1]=p0[1]-ax+mx;
        p2[0]=0.5*(bx+mx); p3[0]=p2[0]+by-my;
        p2[1]=0.5*(by+my); p3[1]=p2[1]-bx+mx;
        if (Intersect2DRayRay(pp,p0,p1,p2,p3))
            {
            cx=pp[0];
            cy=pp[1];
            p0[0]=mx-ax;
            p0[1]=my-ay;
            p1[0]=bx-mx;
            p1[1]=by-my;
            p2[1]=(p0[0]*p1[1])-(p0[1]*p1[0]);
            // swap A,B if wrong winding =  sighn of z coordinate of (p0 x p1)
            if ((p0[0]*p1[1])-(p0[1]*p1[0])>0.0)
                {
                p0[0]=ax; ax=bx; bx=p0[0];
                p0[0]=ay; ay=by; by=p0[0];
                     if (sel==_arc_sel_a) sel=_arc_sel_b;
                else if (sel==_arc_sel_b) sel=_arc_sel_a;
                }
            }
        }
    // A,B,C -> M
    void compute_m()
        {
        double x,y,r,a0,a1,am;
        x=ax-cx; x*=x;
        y=ay-cy; y*=y;
        r=sqrt(x+y);
        a0=atan2(ay-cy,ax-cx);
        a1=atan2(by-cy,bx-cx);
        if (a1<a0) a1+=2.0*M_PI;
        am=0.5*a0+a1;
        mx=cx+r*cos(am);
        my=cy+r*sin(am);
        }
    // VCL render (can ignore this)
    void draw(TCanvas *scr)
        {
        double x,y,r;
        x=ax-cx; x*=x;
        y=ay-cy; y*=y;
        r=sqrt(x+y);
        scr->Pen->Color=clSilver;
        scr->Arc(cx-r,cy-r,cx+r,cy+r,ax,ay,bx,by);
        r=_point_r;
        scr->Pen->Color=clBlue;
        if (sel==_arc_sel_a) scr->Brush->Color=clAqua; else scr->Brush->Color=clDkGray; scr->Ellipse(ax-r,ay-r,ax+r,ay+r);
        if (sel==_arc_sel_b) scr->Brush->Color=clAqua; else scr->Brush->Color=clDkGray; scr->Ellipse(bx-r,by-r,bx+r,by+r);
        if (sel==_arc_sel_m) scr->Brush->Color=clAqua; else scr->Brush->Color=clDkGray; scr->Ellipse(mx-r,my-r,mx+r,my+r);
        scr->Pen->Color=clRed;
        scr->Brush->Color=clDkGray;
        scr->Ellipse(cx-r,cy-r,cx+r,cy+r);
        }
    // VCL mouse handler (can ignore this)
    double mx0,my0; TShiftState sh0;
    void mouse(double mx1,double my1,TShiftState sh1)
        {
        double x,y;
        int q0,q1;
        // point selection
        if (!_sel)
            {
            sel=_arc_sel_none;
            x=ax-mx1; y=ay-my1; if ((x*x)+(y*y)<=_point_rr) sel=_arc_sel_a;
            x=bx-mx1; y=by-my1; if ((x*x)+(y*y)<=_point_rr) sel=_arc_sel_b;
            x=mx-mx1; y=my-my1; if ((x*x)+(y*y)<=_point_rr) sel=_arc_sel_m;
            }
        // left mouse button handler
        q0=sh0.Contains(ssLeft);
        q1=sh1.Contains(ssLeft);
        if ((!q0)&&(q1))    // click start
            {
            _sel=1;
            mx0=mx1;
            my0=my1;
            }
        if (q1)             // click move
            {
            x=mx1-mx0;
            y=my1-my0;
            if (sel==_arc_sel_a) { ax+=x; ay+=y; compute_c(); }
            if (sel==_arc_sel_b) { bx+=x; by+=y; compute_c(); }
            if (sel==_arc_sel_m) { mx+=x; my+=y; compute_c();}
            }
        if ((q0)&&(!q1))    // click end
            {
            _sel=0;
            }
        // remember last mouse state
        mx0=mx1; my0=my1; sh0=sh1;
        }
    };
//---------------------------------------------------------------------------

忽略或重写 VCL 内容。它在这里使用math.h预览：

通过仅移动一个点

1 个答案: