Як визначити, чи відповідає перелік точок багатокутника за годинниковою стрілкою?

Маючи список точок, як я можу дізнатися, чи вони розташовані за годинниковою стрілкою?

Наприклад:

point[0] = (5,0)
point[1] = (6,4)
point[2] = (4,5)
point[3] = (1,5)
point[4] = (1,0)

сказали б, що це проти годинникової стрілки (або проти годинникової стрілки для деяких людей).

Деякі із запропонованих методів вийдуть з ладу у випадку неопуклого багатокутника, наприклад півмісяця. Ось простий, який буде працювати з неопуклими багатокутниками (він навіть буде працювати з самопересічним багатокутником, як цифра-вісім, підказуючи, чи здебільшого це за годинниковою стрілкою).

Сума по краях, (x ₂ - x ₁ ) (y ₂ + y ₁ ). Якщо результат позитивний, крива знаходиться за годинниковою стрілкою, якщо негативна - крива проти годинникової стрілки. (Результат - удвічі більше вкладеної області, з +/- умовою.)

point[0] = (5,0)   edge[0]: (6-5)(4+0) =   4
point[1] = (6,4)   edge[1]: (4-6)(5+4) = -18
point[2] = (4,5)   edge[2]: (1-4)(5+5) = -30
point[3] = (1,5)   edge[3]: (1-1)(0+5) =   0
point[4] = (1,0)   edge[4]: (5-1)(0+0) =   0
                                         ---
                                         -44  counter-clockwise

Хрест продукт вимірює ступінь перпендикулярної-ність двох векторів. Уявіть, що кожен край вашого многокутника є вектором у площині xy тривимірного (3-D) ксилового простору. Тоді поперечний добуток двох послідовних ребер є вектором у напрямку z, (позитивний z-напрямок, якщо другий відрізок за годинниковою стрілкою, мінус z-напрямок, якщо він проти годинникової стрілки). Величина цього вектора пропорційна синусу кута між двома вихідними ребрами, тому він досягає максимуму, коли вони перпендикулярні, і звужується, щоб зникнути, коли ребра колінеарні (паралельні).

Отже, для кожної вершини (точки) багатокутника обчисліть величину поперечного добутку двох сусідніх ребер:

Using your data:
point[0] = (5, 0)
point[1] = (6, 4)
point[2] = (4, 5)
point[3] = (1, 5)
point[4] = (1, 0)

Так Позначте краю послідовно , як
edgeAце відрізок від point0до point1і
edgeBміж point1до point2
...
edgeEміж point4і point0.

Тоді вершина A ( point0) знаходиться між
edgeE[Від point4до point0]
edgeA[Від point0до `точки1 '

Ці два ребра самі є векторами, координати x і y можна визначити, віднімаючи координати їх початкової та кінцевої точок:

edgeE= point0- point4= (1, 0) - (5, 0)= (-4, 0) і
edgeA= point1- point0= (6, 4) - (1, 0)= (5, 4) і

І хрест твір цих двох суміжних ребер обчислюється з використанням визначник наступної матриці, яка будується шляхом введення координат двох векторів нижче символів , що представляють три осі координат ( i, j, & k). Третя (нульова) оцінена координата є, тому що концепція перехресного продукту - це 3-D конструкція, і тому ми розширюємо ці 2-D вектори на 3-D для того, щоб застосувати крос-продукт:

 i    j    k 
-4    0    0
 1    4    0    

Зважаючи на те, що всі поперечні продукти дають вектор, перпендикулярний множині площини двох векторів, детермінант матриці вище має лише kкомпонент (або вісь z).
Формула для обчислення величини kкомпонента осі або z є
a1*b2 - a2*b1 = -4* 4 - 0* 1 = -16

Величина цього значення ( -16) - це міра синуса кута між двома вихідними векторами, помноженими на добуток величин двох векторів.
Власне, ще одна формула його значення
A X B (Cross Product) = |A| * |B| * sin(AB).

Отже, щоб повернутися до міри кута, вам потрібно розділити це значення ( -16) на добуток величин двох векторів.

|A| * |B| = 4 * Sqrt(17) =16.4924...

Отже міра гріха (AB) = -16 / 16.4924=-.97014...

Це міра того, чи наступний відрізок після вершини зігнувся вліво або вправо, і на скільки. Не потрібно приймати дугу-синус. Все, про що ми будемо дбати, - це його масштабність, і звичайно її знак (позитивний чи негативний)!

Зробіть це для кожної з інших 4 точок навколо закритого шляху та додайте значення з цього обчислення в кожній вершині.

Якщо остаточна сума позитивна, ви пішли за годинниковою, негативною, проти годинникової стрілки.

Я думаю, це досить старе питання, але я все одно викину інше рішення, тому що це прямо і не є математично інтенсивним - він просто використовує базову алгебру. Обчисліть підписану площу багатокутника. Якщо це негативно, точки розташовуються за годинниковою стрілкою, якщо позитивно - проти годинникової стрілки. (Це дуже схоже на рішення Beta.)

Обчисліть підписану площу: A = 1/2 * (x ₁ * y ₂ - x ₂ * y ₁ + x ₂ * y ₃ - x ₃ * y ₂ + ... + x _n * y ₁ - x ₁ * y _n )

Або в псевдокоді:

signedArea = 0
for each point in points:
    x1 = point[0]
    y1 = point[1]
    if point is last point
        x2 = firstPoint[0]
        y2 = firstPoint[1]
    else
        x2 = nextPoint[0]
        y2 = nextPoint[1]
    end if

    signedArea += (x1 * y2 - x2 * y1)
end for
return signedArea / 2

Зауважте, що якщо ви лише перевіряєте замовлення, вам не потрібно буде ділитися на ділення на 2.

Джерела: http://mathworld.wolfram.com/PolygonArea.html

Знайдіть вершину з найменшим y (і найбільшим x, якщо є зв’язки). Нехай вершиною буде Aі попередня вершина у списку, Bа наступною вершиною у списку буде C. Тепер обчисліть знак перехресного добутку ABта AC.

Список літератури:

• Як знайти орієнтацію простого багатокутника? у запитаннях: comp.graphics.algorithms .

• Крива орієнтація у Вікіпедії.

Ось проста C # реалізація алгоритму на основі цієї відповіді .

Припустимо, що у нас є Vectorтип, що має Xта Yвластивості типу double.

public bool IsClockwise(IList<Vector> vertices)
{
    double sum = 0.0;
    for (int i = 0; i < vertices.Count; i++) {
        Vector v1 = vertices[i];
        Vector v2 = vertices[(i + 1) % vertices.Count];
        sum += (v2.X - v1.X) * (v2.Y + v1.Y);
    }
    return sum > 0.0;
}

%- оператор модуля чи залишку, що виконує операцію модуля, яка ( згідно Вікіпедії ) знаходить залишок після ділення одного числа на інше.

Почніть з однієї з вершин і обчисліть кут, підкреслений кожною стороною.

Перший і останній будуть нульовими (тому пропустіть ці); для решти синус кута буде заданий поперечним добутком нормувань на одиницю довжини (точка [n]-точка [0]) та (точка [n-1]-точка [0]).

Якщо сума значень додатна, то ваш многокутник намальовано в напрямку проти годинникової стрілки.

Для чого це варто, я використав цей міксин для обчислення замовлення намотування для додатків Google Maps API v3.

Код використовує побічний ефект полігонових областей: порядок обмоток вершин за годинниковою стрілкою дає позитивну площу, тоді як порядок намотування проти верхніх годин за тією ж вершиною створює ту саму площу, що і негативне значення. Код також використовує своєрідний приватний API в бібліотеці геометрій Google Maps. Я почував себе комфортно, використовуючи його - використовуйте на свій страх і ризик.

Використання зразка:

var myPolygon = new google.maps.Polygon({/*options*/});
var isCW = myPolygon.isPathClockwise();

Повний приклад з одиничними тестами @ http://jsfiddle.net/stevejansen/bq2ec/

/** Mixin to extend the behavior of the Google Maps JS API Polygon type
 *  to determine if a polygon path has clockwise of counter-clockwise winding order.
 *  
 *  Tested against v3.14 of the GMaps API.
 *
 *  @author  stevejansen_github@icloud.com
 *
 *  @license http://opensource.org/licenses/MIT
 *
 *  @version 1.0
 *
 *  @mixin
 *  
 *  @param {(number|Array|google.maps.MVCArray)} [path] - an optional polygon path; defaults to the first path of the polygon
 *  @returns {boolean} true if the path is clockwise; false if the path is counter-clockwise
 */
(function() {
  var category = 'google.maps.Polygon.isPathClockwise';
     // check that the GMaps API was already loaded
  if (null == google || null == google.maps || null == google.maps.Polygon) {
    console.error(category, 'Google Maps API not found');
    return;
  }
  if (typeof(google.maps.geometry.spherical.computeArea) !== 'function') {
    console.error(category, 'Google Maps geometry library not found');
    return;
  }

  if (typeof(google.maps.geometry.spherical.computeSignedArea) !== 'function') {
    console.error(category, 'Google Maps geometry library private function computeSignedArea() is missing; this may break this mixin');
  }

  function isPathClockwise(path) {
    var self = this,
        isCounterClockwise;

    if (null === path)
      throw new Error('Path is optional, but cannot be null');

    // default to the first path
    if (arguments.length === 0)
        path = self.getPath();

    // support for passing an index number to a path
    if (typeof(path) === 'number')
        path = self.getPaths().getAt(path);

    if (!path instanceof Array && !path instanceof google.maps.MVCArray)
      throw new Error('Path must be an Array or MVCArray');

    // negative polygon areas have counter-clockwise paths
    isCounterClockwise = (google.maps.geometry.spherical.computeSignedArea(path) < 0);

    return (!isCounterClockwise);
  }

  if (typeof(google.maps.Polygon.prototype.isPathClockwise) !== 'function') {
    google.maps.Polygon.prototype.isPathClockwise = isPathClockwise;
  }
})();

Впровадження відповіді Шона в JavaScript:

function calcArea(poly) {
    if(!poly || poly.length < 3) return null;
    let end = poly.length - 1;
    let sum = poly[end][0]*poly[0][1] - poly[0][0]*poly[end][1];
    for(let i=0; i<end; ++i) {
        const n=i+1;
        sum += poly[i][0]*poly[n][1] - poly[n][0]*poly[i][1];
    }
    return sum;
}

function isClockwise(poly) {
    return calcArea(poly) > 0;
}

let poly = [[352,168],[305,208],[312,256],[366,287],[434,248],[416,186]];

console.log(isClockwise(poly));

let poly2 = [[618,186],[650,170],[701,179],[716,207],[708,247],[666,259],[637,246],[615,219]];

console.log(isClockwise(poly2));

Досить впевнений, що це правильно. Здається, працює :-)

Ці багатокутники виглядають приблизно так, якщо вам цікаво:

Це реалізована функція для OpenLayers 2 . Умова наявності багатокутника за годинниковою стрілкою - area < 0це підтверджено цим посиланням .

function IsClockwise(feature)
{
    if(feature.geometry == null)
        return -1;

    var vertices = feature.geometry.getVertices();
    var area = 0;

    for (var i = 0; i < (vertices.length); i++) {
        j = (i + 1) % vertices.length;

        area += vertices[i].x * vertices[j].y;
        area -= vertices[j].x * vertices[i].y;
        // console.log(area);
    }

    return (area < 0);
}

Якщо ви використовуєте Matlab, функція ispolycwповертає значення true, якщо вершини багатокутника розташовані в порядку годинникової стрілки.

Як також пояснено в цій статті Вікіпедії Крива орієнтація , задана 3 точками p, qі rна площині (тобто з координатами x і y) можна обчислити знак наступного визначника

Якщо визначник від'ємний (тобто Orient(p, q, r) < 0), то багатокутник орієнтований за годинниковою стрілкою (CW). Якщо визначник позитивний (тобто Orient(p, q, r) > 0), багатокутник орієнтується проти годинникової стрілки (CCW). Визначник дорівнює нулю (тобто Orient(p, q, r) == 0), якщо точки p, qі rє колінеарними .

У формулі вище ми додаємо ті, що знаходяться перед координатами p, q і rтому, що ми використовуємо однорідні координати .

Я думаю, що для того, щоб деякі точки були задані за годинниковою стрілкою, всі ребра повинні бути позитивними не лише сумою ребер. Якщо один край від'ємний, принаймні 3 бали задаються проти годинникової стрілки.

Моє рішення C # / LINQ засноване на крос-рекомендаціях щодо продукту @charlesbretana нижче. Можна задати еталонну норму для обмотки. Він повинен працювати до тих пір, поки крива знаходиться в основному в площині, визначеній вектором вгору.

using System.Collections.Generic;
using System.Linq;
using System.Numerics;

namespace SolidworksAddinFramework.Geometry
{
    public static class PlanePolygon
    {
        /// <summary>
        /// Assumes that polygon is closed, ie first and last points are the same
        /// </summary>
       public static bool Orientation
           (this IEnumerable<Vector3> polygon, Vector3 up)
        {
            var sum = polygon
                .Buffer(2, 1) // from Interactive Extensions Nuget Pkg
                .Where(b => b.Count == 2)
                .Aggregate
                  ( Vector3.Zero
                  , (p, b) => p + Vector3.Cross(b[0], b[1])
                                  /b[0].Length()/b[1].Length());

            return Vector3.Dot(up, sum) > 0;

        } 

    }
}

з одиничним тестом

namespace SolidworksAddinFramework.Spec.Geometry
{
    public class PlanePolygonSpec
    {
        [Fact]
        public void OrientationShouldWork()
        {

            var points = Sequences.LinSpace(0, Math.PI*2, 100)
                .Select(t => new Vector3((float) Math.Cos(t), (float) Math.Sin(t), 0))
                .ToList();

            points.Orientation(Vector3.UnitZ).Should().BeTrue();
            points.Reverse();
            points.Orientation(Vector3.UnitZ).Should().BeFalse();



        } 
    }
}

Це моє рішення, використовуючи пояснення в інших відповідях:

def segments(poly):
    """A sequence of (x,y) numeric coordinates pairs """
    return zip(poly, poly[1:] + [poly[0]])

def check_clockwise(poly):
    clockwise = False
    if (sum(x0*y1 - x1*y0 for ((x0, y0), (x1, y1)) in segments(poly))) < 0:
        clockwise = not clockwise
    return clockwise

poly = [(2,2),(6,2),(6,6),(2,6)]
check_clockwise(poly)
False

poly = [(2, 6), (6, 6), (6, 2), (2, 2)]
check_clockwise(poly)
True

Набагато простіший метод обчислення, якщо ви вже знаєте точку всередині полігону :

1. Виберіть будь-який відрізок лінії з початкового багатокутника, точок та їх координат у такому порядку.

2. Додайте відому «внутрішню» точку та сформуйте трикутник.

3. Обчисліть CW або CCW, як тут запропоновано, за допомогою цих трьох балів.

Після тестування декількох ненадійних реалізацій алгоритм, що дав задовільні результати щодо орієнтації CW / CCW поза коробкою, був алгоритмом, розміщеним ОП у цій темі ( shoelace_formula_3).

Як завжди, додатне число являє собою орієнтацію CW, тоді як негативне число CCW.

Ось швидке рішення 3.0, засноване на відповідях вище:

    for (i, point) in allPoints.enumerated() {
        let nextPoint = i == allPoints.count - 1 ? allPoints[0] : allPoints[i+1]
        signedArea += (point.x * nextPoint.y - nextPoint.x * point.y)
    }

    let clockwise  = signedArea < 0

Ще одне рішення для цього;

const isClockwise = (vertices=[]) => {
    const len = vertices.length;
    const sum = vertices.map(({x, y}, index) => {
        let nextIndex = index + 1;
        if (nextIndex === len) nextIndex = 0;

        return {
            x1: x,
            x2: vertices[nextIndex].x,
            y1: x,
            y2: vertices[nextIndex].x
        }
    }).map(({ x1, x2, y1, y2}) => ((x2 - x1) * (y1 + y2))).reduce((a, b) => a + b);

    if (sum > -1) return true;
    if (sum < 0) return false;
}

Прийміть усі вершини як такий масив;

const vertices = [{x: 5, y: 0}, {x: 6, y: 4}, {x: 4, y: 5}, {x: 1, y: 5}, {x: 1, y: 0}];
isClockwise(vertices);

Рішення для R для визначення напрямку та реверсу, якщо за годинниковою стрілкою (вважається необхідним для власних об'єктів):

coords <- cbind(x = c(5,6,4,1,1),y = c(0,4,5,5,0))
a <- numeric()
for (i in 1:dim(coords)[1]){
  #print(i)
  q <- i + 1
  if (i == (dim(coords)[1])) q <- 1
  out <- ((coords[q,1]) - (coords[i,1])) * ((coords[q,2]) + (coords[i,2]))
  a[q] <- out
  rm(q,out)
} #end i loop

rm(i)

a <- sum(a) #-ve is anti-clockwise

b <- cbind(x = rev(coords[,1]), y = rev(coords[,2]))

if (a>0) coords <- b #reverses coords if polygon not traced in anti-clockwise direction

Хоча ці відповіді правильні, вони більш математичні, ніж необхідні. Припустимо координати карти, де найпівнічніша точка - найвища точка на карті. Знайдіть саму північну точку, і якщо 2 бали зрівняються, то це сама північ, то сама східна (це точка, яку lhf ​​використовує у своїй відповіді). У ваших пунктах,

точка [0] = (5,0)

точка [1] = (6,4)

точка [2] = (4,5)

точка [3] = (1,5)

точка [4] = (1,0)

Якщо припустити, що P2 є найбільш північною, то східну точку або попередню, або наступну точку визначають за годинниковою стрілкою, CW або CCW. Оскільки найпівнічніша точка знаходиться на північній грані, якщо P1 (попередня) до P2 рухається на схід, то напрямок - CW. У цьому випадку він рухається на захід, тому напрямок - CCW, як говориться у прийнятій відповіді. Якщо попередня точка не має горизонтального руху, то така ж система застосовується до наступної точки, P3. Якщо P3 знаходиться на захід від P2, він є, тоді рух - CCW. Якщо рух P2 - P3 - схід, то в цьому випадку захід - рух CW. Припустимо, що nte, P2 у ваших даних, є найбільш північною, ніж східною точкою, а prv - попередньою точкою, P1 у ваших даних, а nxt - наступною точкою, P3 у ваших даних, а [0] - горизонтальною чи східною / захід, де захід менше, ніж схід, і [1] вертикальний.

if (nte[0] >= prv[0] && nxt[0] >= nte[0]) return(CW);
if (nte[0] <= prv[0] && nxt[0] <= nte[0]) return(CCW);
// Okay, it's not easy-peasy, so now, do the math
if (nte[0] * nxt[1] - nte[1] * nxt[0] - prv[0] * (nxt[1] - crt[1]) + prv[1] * (nxt[0] - nte[0]) >= 0) return(CCW); // For quadrant 3 return(CW)
return(CW) // For quadrant 3 return (CCW)

C # код для реалізації відповіді lhf :

// https://en.wikipedia.org/wiki/Curve_orientation#Orientation_of_a_simple_polygon
public static WindingOrder DetermineWindingOrder(IList<Vector2> vertices)
{
    int nVerts = vertices.Count;
    // If vertices duplicates first as last to represent closed polygon,
    // skip last.
    Vector2 lastV = vertices[nVerts - 1];
    if (lastV.Equals(vertices[0]))
        nVerts -= 1;
    int iMinVertex = FindCornerVertex(vertices);
    // Orientation matrix:
    //     [ 1  xa  ya ]
    // O = | 1  xb  yb |
    //     [ 1  xc  yc ]
    Vector2 a = vertices[WrapAt(iMinVertex - 1, nVerts)];
    Vector2 b = vertices[iMinVertex];
    Vector2 c = vertices[WrapAt(iMinVertex + 1, nVerts)];
    // determinant(O) = (xb*yc + xa*yb + ya*xc) - (ya*xb + yb*xc + xa*yc)
    double detOrient = (b.X * c.Y + a.X * b.Y + a.Y * c.X) - (a.Y * b.X + b.Y * c.X + a.X * c.Y);

    // TBD: check for "==0", in which case is not defined?
    // Can that happen?  Do we need to check other vertices / eliminate duplicate vertices?
    WindingOrder result = detOrient > 0
            ? WindingOrder.Clockwise
            : WindingOrder.CounterClockwise;
    return result;
}

public enum WindingOrder
{
    Clockwise,
    CounterClockwise
}

// Find vertex along one edge of bounding box.
// In this case, we find smallest y; in case of tie also smallest x.
private static int FindCornerVertex(IList<Vector2> vertices)
{
    int iMinVertex = -1;
    float minY = float.MaxValue;
    float minXAtMinY = float.MaxValue;
    for (int i = 0; i < vertices.Count; i++)
    {
        Vector2 vert = vertices[i];
        float y = vert.Y;
        if (y > minY)
            continue;
        if (y == minY)
            if (vert.X >= minXAtMinY)
                continue;

        // Minimum so far.
        iMinVertex = i;
        minY = y;
        minXAtMinY = vert.X;
    }

    return iMinVertex;
}

// Return value in (0..n-1).
// Works for i in (-n..+infinity).
// If need to allow more negative values, need more complex formula.
private static int WrapAt(int i, int n)
{
    // "+n": Moves (-n..) up to (0..).
    return (i + n) % n;
}

Ось проста реалізація Python 3 на основі цієї відповіді (яка, у свою чергу, ґрунтується на рішенні, запропонованому у прийнятій відповіді )

def is_clockwise(points):
    # points is your list (or array) of 2d points.
    assert len(points) > 0
    s = 0.0
    for p1, p2 in zip(points, points[1:] + [points[0]]):
        s += (p2[0] - p1[0]) * (p2[1] + p1[1])
    return s > 0.0

знайти центр маси цих точок.

припустимо, є лінії від цієї точки до ваших точок.

знайдіть кут між двома прямими для лінії0 пряма1

ніж це робити для line1 та line2

...

...

якщо цей кут монотонно збільшується, ніж проти годинникової стрілки,

інакше, якщо монотонно зменшується, це за годинниковою стрілкою

інше (це не монотонно)

ви не можете вирішити, так що це не мудро