Polygon Algorithm | 易学教程

问题

I'm trying to code a general algorithm that can find a polygon from the area swept out by a circle (red line) that follows some known path (green line), and where the circle gets bigger as it moves further down the known path. Basically, can anyone point me down a direction to solve this, please? I can't seem to nail down which tangent points are part of the polygon for any point (and thus circle) on the path.

Any help is appreciated.

回答1:

Well, the easiest is to approximate your path by small segments on which your path is linear, and your circle grows linearly.

Your segments and angles will likely be small, but for the sake of the example, let's take bigger (and more obvious) angles.

Going through the geometry

Good lines for the edges of your polygon are the tangents to both circles. Note that there aren't always close to the lines defined by the intersections between the circles and the orthogonal line to the path, especially with stronger growth speeds. See the figure below, where (AB) is the path, we want the (OE) and (OF) lines, but not the (MN) one for example :

The first step is to identify the point O. It is the only point that defines a homothetic transformation between both circles, with a positive ratio.

Thus ratio = OA/OB = (radius C) / (radius C') and O = A + AB/(1-ratio)

Now let u be the vector from O to A normalized, and v a vector orthogonal to u (let us take it in the direction from A to M).

Let us call a the vector from O to E normalized, and beta the angle EOA. Then, since (OE) and (AE) are perpendicular, sin(beta) = (radius C) / OA. We also have the scalar product a.u = cos(beta) and since the norm of a is 1, a = u * cos(beta) + v * sin(beta)

Then it comes easily that with b the vector from O to F normalized, b = u * cos(beta) - v * sin(beta)

Since beta is an angle less than 90° (otherwise the growth of the circle would be so much faster than it going forward, that the second circle contains the first completely), we know that cos(beta) > 0.

Pseudo-code-ish solution

For the first and last circles you can do something closer to them -- fort the sake of simplicity, I'm just going to use the intersection between the lines I'm building and the tangent to the circle that's orthogonal to the first (or last) path, as illustrated in the first figure of this post.

Along the path, you can make your polygon arbitrarily close to the real swept area by making the segments smaller.

Also, I assume you have a function find_intersection that, given two parametric equations of two lines, returns the point of intersection between them. First of all, it makes it trivial to see if they are parallel (which they should never be), and it allows to easily represent vertical lines.

w = 1; // width of the first circle
C = {x : 0, y : 0}; // first circle center

while( (new_C, new_w) = next_step )
{
    // the vector (seg_x, seg_y) is directing the segment
    seg = new_C - C;
    norm_seg =  sqrt( seg.x * seg.x + seg.y * seg.y );

    // the vector (ortho_x, ortho_y) is orthogonal to the segment, with same norm
    ortho = { x = -seg.y, y = seg.x };

    // apply the formulas we devised : get ratio-1
    fact = new_w / w - 1;

    O = new_C - seg / fact;

    sin_beta = w * fact / norm_seg;
    cos_beta = sqrt(1 - sin_beta * sin_beta);

    // here you know the two lines, parametric equations are O+t*a and O+t*b
    a = cos_beta * seg + sin_beta * ortho;
    b = cos_beta * seg - sin_beta * ortho;

    if( first iteration )
    {
        // initialize both "old lines" to a line perpendicular to the first segment
        // that passes through the opposite side of the circle
        old_a =  ortho;
        old_b = -ortho;
        old_O = C - seg * (w / norm_seg);
    }

    P = find_intersection(old_O, old_a, O, a);
    // add P to polygon construction clockwise

    Q = find_intersection(old_O, old_b, O, b);
    // add Q to polygon construction clockwise

    old_a = a;
    old_b = b;
    old_O = O;
    w = new_w;
    C = new_C;
}

// Similarly, finish with line orthogonal to last direction, that is tangent to last circle
O = C + seg * (w / norm_seg);
a =  ortho;
b = -ortho;

P = find_intersection(old_O, old_a, O, a);
// add P to polygon construction clockwise

Q = find_intersection(old_O, old_b, O, b);
    // add Q to polygon construction clockwise

回答2:

Let's suppose the centers are along the positive x-axis, and the lines in the envelope are y=mx and y=-mx for some m>0. The distance from (x,0) to y=mx is mx/sqrt(1+m^2). So, if the radius is increasing at a rate of m/sqrt(1+m^2) times the distance moved along the x-axis, the enveloping lines are y=mx and y=-mx.

Inverting this, if you put a circle of radius cx at the center of (x,0), then c=m/sqrt(1+m^2) so

m = c/sqrt(1-c^2).

If c=1 then you get a vertical line, and if c>1 then every point in the plane is included in some circle.

This is how you can tell how much faster than sound a supersonic object is moving from the Mach angle of the envelope of the disturbed medium.

You can rotate this to nonhorizontal lines. It may help to use the angle formulation mu = arcsin(c), where mu is the angle between the envelope and the path, and the Mach number is 1/c.

来源：https://stackoverflow.com/questions/27948181/polygon-algorithm

标签

algorithm

math

geometry

polygon