Wie kann festgestellt werden, ob eine Liste von Polygonpunkten im Uhrzeigersinn vorliegt?

Wie finde ich eine Liste mit Punkten im Uhrzeigersinn?

Beispielsweise:

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

würde sagen, dass es gegen den Uhrzeigersinn ist (oder gegen den Uhrzeigersinn für einige Leute).

Einige der vorgeschlagenen Methoden schlagen bei einem nicht konvexen Polygon wie einem Halbmond fehl. Hier ist eine einfache Methode, die mit nicht konvexen Polygonen funktioniert (sie funktioniert sogar mit einem sich selbst überschneidenden Polygon wie einer Acht, das Ihnen sagt, ob es größtenteils im Uhrzeigersinn ist).

Summiere über die Kanten (x ₂ - x ₁ ) (y ₂ + y ₁ ). Wenn das Ergebnis positiv ist, ist die Kurve im Uhrzeigersinn, wenn es negativ ist, ist die Kurve gegen den Uhrzeigersinn. (Das Ergebnis ist doppelt so groß wie der umschlossene Bereich mit einer +/- Konvention.)

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

Das Kreuzprodukt misst den Grad der Rechtwinkligkeit zweier Vektoren. Stellen Sie sich vor, jede Kante Ihres Polygons ist ein Vektor in der xy-Ebene eines dreidimensionalen (3-D) xyz-Raums. Dann ist das Kreuzprodukt zweier aufeinanderfolgender Kanten ein Vektor in z-Richtung (positive z-Richtung, wenn das zweite Segment im Uhrzeigersinn ist, minus z-Richtung, wenn es gegen den Uhrzeigersinn ist). Die Größe dieses Vektors ist proportional zum Sinus des Winkels zwischen den beiden ursprünglichen Kanten, sodass er ein Maximum erreicht, wenn sie senkrecht stehen, und sich verjüngt, um zu verschwinden, wenn die Kanten kollinear (parallel) sind.

Berechnen Sie also für jeden Scheitelpunkt (Punkt) des Polygons die Kreuzproduktgröße der beiden benachbarten Kanten:

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

Beschriften Sie die Kanten nacheinander, so wie
edgeAdas Segment von point0bis point1und
edgeBzwischen point1bis point2
...
edgeEzwischen point4und ist point0.

Dann liegt Vertex A ( point0) zwischen
edgeE[Von point4bis point0]
edgeA[Von point0bis `Punkt1 '

Diese beiden Kanten sind selbst Vektoren, deren x- und y-Koordinaten durch Subtrahieren der Koordinaten ihrer Start- und Endpunkte bestimmt werden können:

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

Und das Kreuzprodukt der beiden angrenzenden Kanten berechnet die Determinante der folgenden Matrix verwendet, die , indem sie die Koordinaten der beiden Vektoren unter den Symbolen aufgebaut ist , die die drei Koordinatenachsen ( i, j, & k). Die dritte (null) -bewertige Koordinate ist vorhanden, da das Kreuzproduktkonzept ein 3D-Konstrukt ist. Daher erweitern wir diese 2D-Vektoren in 3D, um das Kreuzprodukt anzuwenden:

 i    j    k 
-4    0    0
 1    4    0    

Da alle Kreuzprodukte einen Vektor senkrecht zur Ebene zweier zu multiplizierender Vektoren erzeugen, hat die Determinante der obigen Matrix nur eine k(oder z-Achsen-) Komponente.
Die Formel zur Berechnung der Größe der kKomponente oder der Z-Achse lautet
a1*b2 - a2*b1 = -4* 4 - 0* 1 = -16

Die Größe dieses Wertes ( -16) ist ein Maß für den Sinus des Winkels zwischen den beiden ursprünglichen Vektoren, multipliziert mit dem Produkt der Größen der beiden Vektoren.
Eigentlich ist eine andere Formel für seinen Wert
A X B (Cross Product) = |A| * |B| * sin(AB).

Um auf ein Maß des Winkels zurückzukommen, müssen Sie diesen Wert ( -16) durch das Produkt der Größen der beiden Vektoren dividieren .

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

Also das Maß der Sünde (AB) = -16 / 16.4924=-.97014...

Dies ist ein Maß dafür, ob und um wie viel sich das nächste Segment nach dem Scheitelpunkt nach links oder rechts gebogen hat. Es ist nicht erforderlich, Arc-Sinus zu nehmen. Wir werden uns nur um seine Größe und natürlich um sein Vorzeichen (positiv oder negativ) kümmern!

Führen Sie dies für jeden der anderen 4 Punkte um den geschlossenen Pfad aus und addieren Sie die Werte aus dieser Berechnung an jedem Scheitelpunkt.

Wenn die endgültige Summe positiv ist, sind Sie im Uhrzeigersinn, negativ und gegen den Uhrzeigersinn gegangen.

Ich denke, das ist eine ziemlich alte Frage, aber ich werde trotzdem eine andere Lösung herauswerfen, weil sie einfach und nicht mathematisch intensiv ist - sie verwendet nur die grundlegende Algebra. Berechnen Sie die vorzeichenbehaftete Fläche des Polygons. Wenn es negativ ist, sind die Punkte im Uhrzeigersinn, wenn es positiv ist, sind sie gegen den Uhrzeigersinn. (Dies ist der Beta-Lösung sehr ähnlich.)

Berechnen Sie die vorzeichenbehaftete Fläche: A = 1/2 * (x ₁ * y ₂ - x ₂ * y ₁ + x ₂ * y ₃ - x ₃ * y ₂ + ... + x _n * y ₁ - x ₁ * y _n )

Oder im Pseudocode:

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

Beachten Sie, dass Sie sich nicht die Mühe machen müssen, durch 2 zu teilen, wenn Sie nur die Bestellung überprüfen.

Quellen: http://mathworld.wolfram.com/PolygonArea.html

Finden Sie den Scheitelpunkt mit dem kleinsten y (und dem größten x, wenn es Bindungen gibt). Der Scheitelpunkt sei Aund der vorherige Scheitelpunkt in der Liste sei Bund der nächste Scheitelpunkt in der Liste sei C. Berechnen Sie nun das Vorzeichen des Kreuzprodukts von ABund AC.

Verweise:

• Wie finde ich die Ausrichtung eines einfachen Polygons? in häufig gestellten Fragen: comp.graphics.algorithms .

• Kurvenorientierung bei Wikipedia.

Hier ist eine einfache C # -Implementierung des Algorithmus basierend auf dieser Antwort .

Nehmen wir an, wir haben einen VectorTyp mit Xund YEigenschaften von Typ 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;
}

%ist der Modulo- oder Restoperator, der die Modulo-Operation ausführt, die ( laut Wikipedia ) den Rest nach Division einer Zahl durch eine andere findet.

Beginnen Sie an einem der Eckpunkte und berechnen Sie den Winkel, den jede Seite bildet.

Der erste und der letzte sind Null (überspringen Sie diese also); im übrigen wird der Sinus des Winkels durch das Kreuzprodukt der Normalisierungen zur Längeneinheit von (Punkt [n] -Punkt [0]) und (Punkt [n-1] -Punkt [0]) gegeben.

Wenn die Summe der Werte positiv ist, wird Ihr Polygon gegen den Uhrzeigersinn gezeichnet.

Für das, was es wert ist, habe ich dieses Mixin verwendet, um die Wicklungsreihenfolge für Google Maps API v3-Apps zu berechnen.

Der Code nutzt den Nebeneffekt von Polygonbereichen: Eine Wicklungsreihenfolge von Scheitelpunkten im Uhrzeigersinn ergibt eine positive Fläche, während eine Wicklungsreihenfolge derselben Scheitelpunkte gegen den Uhrzeigersinn dieselbe Fläche wie ein negativer Wert erzeugt. Der Code verwendet auch eine Art private API in der Google Maps-Geometriebibliothek. Ich habe mich wohl gefühlt - auf eigenes Risiko.

Beispielnutzung:

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

Vollständiges Beispiel mit Unit-Tests @ 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;
  }
})();

Eine Implementierung von Seans Antwort in 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));

Ich bin mir ziemlich sicher, dass das richtig ist. Es scheint zu funktionieren :-)

Diese Polygone sehen so aus, wenn Sie sich fragen:

Dies ist die implementierte Funktion für OpenLayers 2 . Die Bedingung für ein Polygon im Uhrzeigersinn ist area < 0, wie durch diese Referenz bestätigt .

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);
}

Wenn Sie Matlab verwenden, gibt die Funktion ispolycwtrue zurück, wenn die Polygonscheitelpunkte im Uhrzeigersinn sind.

Wie erläutert auch in diesem Artikel Wikipedia Orientierung Curve , 3 Punkte gegeben p, qund rauf der Ebene (dh mit x und y - Koordinaten), kann das Vorzeichen der folgenden Determinante berechnen

Wenn die Determinante negativ ist (dh Orient(p, q, r) < 0), ist das Polygon im Uhrzeigersinn ausgerichtet (CW). Wenn die Determinante positiv ist (dh Orient(p, q, r) > 0), ist das Polygon gegen den Uhrzeigersinn (CCW) ausgerichtet. Die Determinante Null ist (dh Orient(p, q, r) == 0) , wenn Punkte p, qund rsind kollinear .

In der obigen Formel prepend wir die , die vor den Koordinaten p, q und rda wir verwenden homogene Koordinaten .

Ich denke, damit einige Punkte im Uhrzeigersinn vergeben werden, müssen alle Kanten positiv sein, nicht nur die Summe der Kanten. Wenn eine Flanke negativ ist, werden mindestens 3 Punkte gegen den Uhrzeigersinn vergeben.

Meine C # / LINQ-Lösung basiert auf den produktübergreifenden Empfehlungen von @charlesbretana. Sie können eine Referenznormale für die Wicklung angeben. Es sollte funktionieren, solange sich die Kurve größtenteils in der durch den Aufwärtsvektor definierten Ebene befindet.

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;

        } 

    }
}

mit einem Unit-Test

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();



        } 
    }
}

Dies ist meine Lösung unter Verwendung der Erklärungen in den anderen Antworten:

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

Eine viel rechnerisch einfachere Methode, wenn Sie bereits einen Punkt innerhalb des Polygons kennen :

1. Wählen Sie ein beliebiges Liniensegment aus dem ursprünglichen Polygon, den Punkten und deren Koordinaten in dieser Reihenfolge.

2. Fügen Sie einen bekannten "inneren" Punkt hinzu und bilden Sie ein Dreieck.

3. Berechnen Sie CW oder CCW wie hier vorgeschlagen mit diesen drei Punkten.

Nach dem Testen mehrerer unzuverlässiger Implementierungen war der Algorithmus, der sofort zufriedenstellende Ergebnisse hinsichtlich der CW / CCW-Ausrichtung lieferte, derjenige, der von OP in diesem Thread veröffentlicht wurde (shoelace_formula_3 ) veröffentlicht wurde.

Wie immer steht eine positive Zahl für eine CW-Ausrichtung, während eine negative Zahl CCW darstellt.

Hier ist eine schnelle 3.0-Lösung basierend auf den obigen Antworten:

    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

Eine andere Lösung dafür;

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;
}

Nehmen Sie alle Eckpunkte als Array wie dieses;

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

Lösung für R, um die Richtung zu bestimmen und im Uhrzeigersinn umzukehren (für Owin-Objekte erforderlich):

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

Diese Antworten sind zwar richtig, aber mathematisch intensiver als nötig. Nehmen Sie Kartenkoordinaten an, wobei der nördlichste Punkt der höchste Punkt auf der Karte ist. Finden Sie den nördlichsten Punkt, und wenn 2 Punkte gleich sind, ist es der nördlichste und dann der östlichste (dies ist der Punkt, den lhf in seiner Antwort verwendet). In Ihren Punkten,

Punkt [0] = (5,0)

Punkt [1] = (6,4)

Punkt [2] = (4,5)

Punkt [3] = (1,5)

Punkt [4] = (1,0)

Wenn wir annehmen, dass P2 der nördlichste und der östlichste Punkt ist, bestimmen entweder der vorherige oder der nächste Punkt im Uhrzeigersinn, CW oder CCW. Da sich der nördlichste Punkt auf der Nordseite befindet, ist die Richtung CW, wenn sich P1 (vorher) zu P2 nach Osten bewegt. In diesem Fall bewegt es sich nach Westen, sodass die Richtung CCW ist, wie in der akzeptierten Antwort angegeben. Wenn der vorherige Punkt keine horizontale Bewegung hat, gilt dasselbe System für den nächsten Punkt, P3. Wenn P3 westlich von P2 liegt, ist die Bewegung gegen den Uhrzeigersinn. Wenn die Bewegung von P2 nach P3 nach Osten, in diesem Fall nach Westen, ist die Bewegung CW. Angenommen, nte, P2 in Ihren Daten, ist der nördlichste und östlichste Punkt und prv ist der vorherige Punkt, P1 in Ihren Daten und nxt ist der nächste Punkt, P3 in Ihren Daten und [0] ist horizontal oder östlich / West, wo West weniger als Ost ist und [1] vertikal ist.

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 # -Code zur Implementierung der Antwort von 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;
}

Hier ist eine einfache Python 3-Implementierung, die auf dieser Antwort basiert (die wiederum auf der in der akzeptierten Antwort vorgeschlagenen Lösung basiert ).

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

Finden Sie den Schwerpunkt dieser Punkte.

Angenommen, es gibt Linien von diesem Punkt zu Ihren Punkten.

Finden Sie den Winkel zwischen zwei Linien für Linie0, Linie1

als für line1 und line2

...

...

Wenn dieser Winkel monoton größer ist als gegen den Uhrzeigersinn,

sonst, wenn es monoton abnimmt, ist es im Uhrzeigersinn

sonst (es ist nicht monoton)

Sie können sich nicht entscheiden, also ist es nicht klug