Algorytm tworzenia zaokrąglonych narożników w wielokątu

Szukasz łuku stycznego do dwóch połączonych ze sobą segmentów linii, o określonym promieniu, określonym przez jakąś sekwencyjną tablicę punktów. Algorytm do znalezienia tego łuku jest następujący:

1. Dla każdego segmentu zbuduj wektor normalny.

   1. Jeśli pracujesz w 2d, możesz po prostu odjąć dwa punkty końcowe, aby uzyskać wektor styczny (X, Y). W takim przypadku wektory normalne będą plus lub minus (- Y, X). znormalizuj wektor normalny do długości 1. Na koniec wybierz kierunek z dodatnim iloczynem punktowym z wektorem stycznym następnego segmentu. (Patrz aktualizacja poniżej).

   2. Jeśli pracujesz w 3d, a nie 2d, aby uzyskać normalny, krzyż wektory styczne dwóch segmentów na wierzchołku, który chcesz zaokrąglić, aby uzyskać prostopadły wektor do płaszczyzny linii. Jeśli prostopadła ma długość zero, segmenty są równoległe i nie może być wymagane żadne okrągłe. W przeciwnym razie znormalizuj go, a następnie przekrocz prostopadle do stycznej, aby uzyskać normalną.)

2. Używając wektorów normalnych, przesuń każdy odcinek linii w kierunku wnętrza wielokąta o żądany promień. Aby skompensować odcinek, przesuń jego punkty końcowe za pomocą wektora normalnego N, który właśnie obliczyłeś, w następujący sposób: P' = P + r * N (kombinacja liniowa).

3. Przeciąć dwie przesunięte linie , aby znaleźć środek. (Działa to, ponieważ wektor promienia okręgu jest zawsze prostopadły do jego styczna.)

4. Aby znaleźć punkt, w którym okrąg przecina każdy segment, przesuń środek okręgu do tyłu do każdego oryginalnego segmentu. To będą punkty końcowe twojego łuku.

5. Upewnij się, że punkty końcowe łuku znajdują się wewnątrz każdego segmentu, w przeciwnym razie utworzysz wielokąt samo przecinający się.

6. Utwórz łuk w obu punktach końcowych z ustalonym środkiem i promieniem.

Nie mam żadnego odpowiedniego oprogramowania na ręka, ale ten diagram trochę pokazuje pomysł:

W tym momencie będziesz musiał albo wprowadzić klasy reprezentujące figurę składającą się z segmentów linii i łuku, albo poligonizować łuk z odpowiednią dokładnością i dodać wszystkie segmenty do wielokąta.

Aktualizacja: zaktualizowałem obraz, oznaczając punkty P1, P2 i P3 oraz wektory normalne Norm12 i Norm23. Normalni normalni są unikalne tylko do kierunku przewracania, i należy wybrać koziołki jak następuje:

• Iloczyn punktowy normy 12 z (P3-P2) musi być dodatni. Jeśli jest ujemna, wielokrotność Norm12 przez -1,0. Jeśli jest zero, punkty są koliniowe i nie trzeba tworzyć zaokrąglonych narożników. Dzieje się tak dlatego, że chcesz wyrównać w kierunku P3.

• Iloczyn punktowy Norm23 z (P1 - P2) musi być również dodatni, ponieważ kompensujesz w kierunku P1.

Objective - C adaptacja nempoBu4 odpowiedź:

typedef enum {
    path_move_to,
    path_line_to
} Path_command;





static inline CGFloat sqr (CGFloat a)
{
    return a * a;
}





static inline CGFloat positive_angle (CGFloat angle)
{
    return angle < 0 ? angle + 2 * (CGFloat) M_PI : angle;
}





static void add_corner (UIBezierPath* path, CGPoint p1, CGPoint p, CGPoint p2, CGFloat radius, Path_command first_add)
{
    // 2
    CGFloat angle = positive_angle (atan2f (p.y - p1.y, p.x - p1.x) - atan2f (p.y - p2.y, p.x - p2.x));

    // 3
    CGFloat segment = radius / fabsf (tanf (angle / 2));
    CGFloat p_c1 = segment;
    CGFloat p_c2 = segment;

    // 4
    CGFloat p_p1 = sqrtf (sqr (p.x - p1.x) + sqr (p.y - p1.y));
    CGFloat p_p2 = sqrtf (sqr (p.x - p2.x) + sqr (p.y - p2.y));
    CGFloat min = MIN(p_p1, p_p2);
    if (segment > min) {
        segment = min;
        radius = segment * fabsf (tanf (angle / 2));
    }

    // 5
    CGFloat p_o = sqrtf (sqr (radius) + sqr (segment));

    // 6
    CGPoint c1;
    c1.x = (CGFloat) (p.x - (p.x - p1.x) * p_c1 / p_p1);
    c1.y = (CGFloat) (p.y - (p.y - p1.y) * p_c1 / p_p1);

    //  7
    CGPoint c2;
    c2.x = (CGFloat) (p.x - (p.x - p2.x) * p_c2 / p_p2);
    c2.y = (CGFloat) (p.y - (p.y - p2.y) * p_c2 / p_p2);

    // 8
    CGFloat dx = p.x * 2 - c1.x - c2.x;
    CGFloat dy = p.y * 2 - c1.y - c2.y;

    CGFloat p_c = sqrtf (sqr (dx) + sqr (dy));

    CGPoint o;
    o.x = p.x - dx * p_o / p_c;
    o.y = p.y - dy * p_o / p_c;

    // 9
    CGFloat start_angle = positive_angle (atan2f ((c1.y - o.y), (c1.x - o.x)));
    CGFloat end_angle = positive_angle (atan2f ((c2.y - o.y), (c2.x - o.x)));


    if (first_add == path_move_to) {
        [path moveToPoint: c1];
    }
    else {
        [path addLineToPoint: c1];
    }
    [path addArcWithCenter: o radius: radius startAngle: start_angle endAngle: end_angle clockwise: angle < M_PI];
}





UIBezierPath* path_with_rounded_corners (NSArray<NSValue*>* points, CGFloat corner_radius)
{
    UIBezierPath* path = [UIBezierPath bezierPath];
    NSUInteger count = points.count;
    for (NSUInteger i = 0; i < count; ++i) {
        CGPoint prev = points[i > 0 ? i - 1 : count - 1].CGPointValue;
        CGPoint p = points[i].CGPointValue;
        CGPoint next = points[i + 1 < count ? i + 1 : 0].CGPointValue;
        add_corner (path, prev, p, next, corner_radius, i == 0 ? path_move_to : path_line_to);
    }
    [path closePath];
    return path;
}

Oto moja realizacja pomysłu dbc na c#:

/// <summary>
/// Round polygon corners
/// </summary>
/// <param name="points">Vertices array</param>
/// <param name="radius">Round radius</param>
/// <returns></returns>
static public GraphicsPath RoundCorners(PointF[] points, float radius) {
    GraphicsPath retval = new GraphicsPath();
    if (points.Length < 3) {
        throw new ArgumentException();
    }
    rects = new RectangleF[points.Length];
    PointF pt1, pt2;
    //Vectors for polygon sides and normal vectors
    Vector v1, v2, n1 = new Vector(), n2 = new Vector();
    //Rectangle that bounds arc
    SizeF size = new SizeF(2 * radius, 2 * radius);
    //Arc center
    PointF center = new PointF();

    for (int i = 0; i < points.Length; i++) {
        pt1 = points[i];//First vertex
        pt2 = points[i == points.Length - 1 ? 0 : i + 1];//Second vertex
        v1 = new Vector(pt2.X, pt2.Y) - new Vector(pt1.X, pt1.Y);//One vector
        pt2 = points[i == 0 ? points.Length - 1 : i - 1];//Third vertex
        v2 = new Vector(pt2.X, pt2.Y) - new Vector(pt1.X, pt1.Y);//Second vector
        //Angle between vectors
        float sweepangle = (float)Vector.AngleBetween(v1, v2);
        //Direction for normal vectors
        if (sweepangle < 0) { 
            n1 = new Vector(v1.Y, -v1.X);
            n2 = new Vector(-v2.Y, v2.X);
        }
        else {
            n1 = new Vector(-v1.Y, v1.X);
            n2 = new Vector(v2.Y, -v2.X);
        }

        n1.Normalize(); n2.Normalize();
        n1 *= radius; n2 *= radius;
        /// Points for lines which intersect in the arc center
        PointF pt = points[i];
        pt1 = new PointF((float)(pt.X + n1.X), (float)(pt.Y + n1.Y));
        pt2 = new PointF((float)(pt.X + n2.X), (float)(pt.Y + n2.Y));
        double m1 = v1.Y / v1.X, m2 = v2.Y / v2.X;
        //Arc center
        if (v1.X == 0) {// first line is parallel OY
            center.X = pt1.X;
            center.Y = (float)(m2 * (pt1.X - pt2.X) + pt2.Y);
        }
        else if (v1.Y == 0) {// first line is parallel OX
            center.X = (float)((pt1.Y - pt2.Y) / m2 + pt2.X);
            center.Y = pt1.Y;
        }
        else if (v2.X == 0) {// second line is parallel OY
            center.X = pt2.X;
            center.Y = (float)(m1 * (pt2.X - pt1.X) + pt1.Y);
        }
        else if (v2.Y == 0) {//second line is parallel OX
            center.X = (float)((pt2.Y - pt1.Y) / m1 + pt1.X);
            center.Y = pt2.Y;
        }
        else {
            center.X = (float)((pt2.Y - pt1.Y + m1 * pt1.X - m2 * pt2.X) / (m1 - m2));
            center.Y = (float)(pt1.Y + m1 * (center.X - pt1.X));
        }
        rects[i] = new RectangleF(center.X - 2, center.Y - 2, 4, 4);
        //Tangent points on polygon sides
        n1.Negate(); n2.Negate();
        pt1 = new PointF((float)(center.X + n1.X), (float)(center.Y + n1.Y));
        pt2 = new PointF((float)(center.X + n2.X), (float)(center.Y + n2.Y));
        //Rectangle that bounds tangent arc
        RectangleF rect = new RectangleF(new PointF(center.X - radius, center.Y - radius), size);
        sweepangle = (float)Vector.AngleBetween(n2, n1);
        retval.AddArc(rect, (float)Vector.AngleBetween(new Vector(1, 0), n2), sweepangle);
    }
    retval.CloseAllFigures();
    return retval;
}

Oto sposób użycia geometrii:-

1. dwie linie są styczne do okręgu wpisanego
2. normalna do stycznej spotyka się w środku okręgu.
3. niech kąt między liniami będzie x
4. kąt nachylenia w środku okręgu będzie wynosił K = 360-90 * 2-X = 180-x
5. pozwala określić dwa punkty styczne jako (x1, y) i (x2, y)
6. akord łączący punkty ma długość l = (x2-x1)
7. wewnątrz koła, akord i dwa normalne o długości r (promień) tworzą trójkąt równoramienny
8. wahadło dzieli traingle na równe połówki trójkątów kątowych.
9. jeden z kątów to K / 2, A bok to l / 2
10. używanie własności trójkąta kąta prostego sin (K/2) = (l/2)/r
11. r = (l/2) / sin (K/2)
12. ale K = 180-x więc r = (l/2)/sin(90-X/2) = (L / 2) / cos (X / 2)
13. stąd r = (x2-x1)/(2*cos(X/2))
14. Teraz po prostu narysuj łuk od (x1, y) do (x2, y) używając promienia r

Uwaga:-

Powyższe jest wyjaśnione tylko dla linii, które spotykają się na początku i oś Y dzieli kąt między nimi na pół. Ale to jest równie ważne dla wszystkich rogu wystarczy zastosować obrót i tłumaczenie przed zastosowaniem powyższego. Ponadto musisz wybrać kilka wartości x przecięcia, z których chcesz narysować łuk . Wartości nie powinny być zbyt daleko lub blisko pochodzenia