Bagaimana Anda bisa menentukan sebuah titik di antara dua titik lain pada ruas garis?

Misalkan Anda memiliki bidang dua dimensi dengan 2 titik (disebut a dan b) di atasnya yang diwakili oleh bilangan bulat x dan bilangan bulat ay untuk setiap titik.

Bagaimana Anda dapat menentukan jika titik c lain berada pada ruas garis yang ditentukan oleh a dan b?

Saya paling sering menggunakan python, tetapi contoh dalam bahasa apa pun akan membantu.

Periksa apakah produk silang dari (ba) dan (ca) adalah 0, seperti yang dikatakan Darius Bacon, memberi tahu Anda jika titik a, b dan c sejajar.

Tetapi, karena Anda ingin mengetahui apakah c berada di antara a dan b, Anda juga harus memeriksa bahwa hasil perkalian titik dari (ba) dan (ca) positif dan lebih kecil dari kuadrat jarak antara a dan b.

Dalam pseudocode yang tidak dioptimalkan:

def isBetween(a, b, c):
    crossproduct = (c.y - a.y) * (b.x - a.x) - (c.x - a.x) * (b.y - a.y)

    # compare versus epsilon for floating point values, or != 0 if using integers
    if abs(crossproduct) > epsilon:
        return False

    dotproduct = (c.x - a.x) * (b.x - a.x) + (c.y - a.y)*(b.y - a.y)
    if dotproduct < 0:
        return False

    squaredlengthba = (b.x - a.x)*(b.x - a.x) + (b.y - a.y)*(b.y - a.y)
    if dotproduct > squaredlengthba:
        return False

    return True

Inilah cara saya melakukannya:

def distance(a,b):
    return sqrt((a.x - b.x)**2 + (a.y - b.y)**2)

def is_between(a,c,b):
    return distance(a,c) + distance(c,b) == distance(a,b)

Periksa apakah perkalian silang dari b-adan c-aadalah 0: itu berarti semua titik collinear. Jika ya, periksa apakah ckoordinatnya antara as dan b. Gunakan koordinat x atau y, selama adan bterpisah pada sumbu tersebut (atau keduanya sama pada keduanya).

def is_on(a, b, c):
    "Return true iff point c intersects the line segment from a to b."
    # (or the degenerate case that all 3 points are coincident)
    return (collinear(a, b, c)
            and (within(a.x, c.x, b.x) if a.x != b.x else 
                 within(a.y, c.y, b.y)))

def collinear(a, b, c):
    "Return true iff a, b, and c all lie on the same line."
    return (b.x - a.x) * (c.y - a.y) == (c.x - a.x) * (b.y - a.y)

def within(p, q, r):
    "Return true iff q is between p and r (inclusive)."
    return p <= q <= r or r <= q <= p

Jawaban ini dulunya adalah kekacauan dari tiga pembaruan. Info berharga dari mereka: bab Brian Hayes dalam Beautiful Code mencakup ruang desain untuk fungsi uji-collinearity - latar belakang yang berguna. Jawaban Vincent membantu memperbaiki yang ini. Dan Hayes yang menyarankan pengujian hanya satu dari koordinat x atau y; awalnya kode telah andmenggantikan if a.x != b.x else.

Berikut pendekatan lain:

• Mari kita asumsikan dua titik menjadi A (x1, y1) dan B (x2, y2)
• Persamaan garis yang melewati titik-titik tersebut adalah (x-x1) / (y-y1) = (x2-x1) / (y2-y1) .. (hanya menyamakan lereng)

Titik C (x3, y3) akan berada di antara A & B jika:

• x3, y3 memenuhi persamaan di atas.
• x3 terletak di antara x1 & x2 dan y3 terletak di antara y1 & y2 (cek sepele)

Panjang segmen tidak penting, sehingga penggunaan akar kuadrat tidak diperlukan dan harus dihindari karena kita dapat kehilangan beberapa presisi.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Segment:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def is_between(self, c):
        # Check if slope of a to c is the same as a to b ;
        # that is, when moving from a.x to c.x, c.y must be proportionally
        # increased than it takes to get from a.x to b.x .

        # Then, c.x must be between a.x and b.x, and c.y must be between a.y and b.y.
        # => c is after a and before b, or the opposite
        # that is, the absolute value of cmp(a, b) + cmp(b, c) is either 0 ( 1 + -1 )
        #    or 1 ( c == a or c == b)

        a, b = self.a, self.b             

        return ((b.x - a.x) * (c.y - a.y) == (c.x - a.x) * (b.y - a.y) and 
                abs(cmp(a.x, c.x) + cmp(b.x, c.x)) <= 1 and
                abs(cmp(a.y, c.y) + cmp(b.y, c.y)) <= 1)

Beberapa contoh penggunaan acak:

a = Point(0,0)
b = Point(50,100)
c = Point(25,50)
d = Point(0,8)

print Segment(a,b).is_between(c)
print Segment(a,b).is_between(d)

Berikut cara lain untuk melakukannya, dengan kode yang diberikan dalam C ++. Diberikan dua poin, l1 dan l2 adalah sepele untuk mengekspresikan ruas garis di antara mereka sebagai

l1 + A(l2 - l1)

dimana 0 <= A <= 1. Ini dikenal sebagai representasi vektor dari sebuah garis jika Anda tertarik lebih dari sekadar menggunakannya untuk soal ini. Kita dapat membagi komponen x dan y ini, memberikan:

x = l1.x + A(l2.x - l1.x)
y = l1.y + A(l2.y - l1.y)

Ambil satu titik (x, y) dan gantikan komponen x dan y menjadi dua ekspresi ini untuk menyelesaikan A. Titik tersebut berada pada garis jika solusi untuk A di kedua ekspresi adalah sama dan 0 <= A <= 1. Karena Penyelesaian untuk A membutuhkan pembagian, ada kasus khusus yang membutuhkan penanganan untuk menghentikan pembagian dengan nol ketika ruas garis horizontal atau vertikal. Solusi akhirnya adalah sebagai berikut:

// Vec2 is a simple x/y struct - it could very well be named Point for this use

bool isBetween(double a, double b, double c) {
    // return if c is between a and b
    double larger = (a >= b) ? a : b;
    double smaller = (a != larger) ? a : b;

    return c <= larger && c >= smaller;
}

bool pointOnLine(Vec2<double> p, Vec2<double> l1, Vec2<double> l2) {
    if(l2.x - l1.x == 0) return isBetween(l1.y, l2.y, p.y); // vertical line
    if(l2.y - l1.y == 0) return isBetween(l1.x, l2.x, p.x); // horizontal line

    double Ax = (p.x - l1.x) / (l2.x - l1.x);
    double Ay = (p.y - l1.y) / (l2.y - l1.y);

    // We want Ax == Ay, so check if the difference is very small (floating
    // point comparison is fun!)

    return fabs(Ax - Ay) < 0.000001 && Ax >= 0.0 && Ax <= 1.0;
}

Dengan menggunakan pendekatan yang lebih geometris, hitung jarak berikut:

ab = sqrt((a.x-b.x)**2 + (a.y-b.y)**2)
ac = sqrt((a.x-c.x)**2 + (a.y-c.y)**2)
bc = sqrt((b.x-c.x)**2 + (b.y-c.y)**2)

dan uji apakah ac + bc sama dengan ab :

is_on_segment = abs(ac + bc - ab) < EPSILON

Itu karena ada tiga kemungkinan:

• 3 titik membentuk segitiga => ac + bc> ab
• Mereka collinear dan c berada di luar segmen ab => ac + bc> ab
• Mereka collinear dan c berada di dalam segmen ab => ac + bc = ab

Ok, banyak penyebutan aljabar linier (perkalian vektor) dan ini bekerja dalam ruang nyata (yaitu titik kontinu atau mengambang) tetapi pertanyaannya secara khusus menyatakan bahwa kedua titik tersebut dinyatakan sebagai bilangan bulat dan dengan demikian perkalian silang tidak benar solusi meskipun dapat memberikan solusi perkiraan.

Solusi yang tepat adalah dengan menggunakan Algoritma Garis Bresenham antara dua titik dan untuk melihat apakah titik ketiga adalah salah satu titik pada garis. Jika poinnya cukup jauh sehingga menghitung algoritme tidak berkinerja baik (dan itu harus sangat besar untuk menjadi kasusnya), saya yakin Anda dapat menggali dan menemukan optimisasi.

Hasil kali skalar antara (ca) dan (ba) harus sama dengan hasil kali panjangnya (ini berarti vektor (ca) dan (ba) sejajar dan searah). Selain itu, panjang (ca) harus kurang dari atau sama dengan (ba). Pseudocode:

# epsilon = small constant

def isBetween(a, b, c):
    lengthca2  = (c.x - a.x)*(c.x - a.x) + (c.y - a.y)*(c.y - a.y)
    lengthba2  = (b.x - a.x)*(b.x - a.x) + (b.y - a.y)*(b.y - a.y)
    if lengthca2 > lengthba2: return False
    dotproduct = (c.x - a.x)*(b.x - a.x) + (c.y - a.y)*(b.y - a.y)
    if dotproduct < 0.0: return False
    if abs(dotproduct*dotproduct - lengthca2*lengthba2) > epsilon: return False 
    return True

Saya membutuhkan ini untuk javascript untuk digunakan dalam kanvas html5 untuk mendeteksi apakah kursor pengguna berada di atas atau di dekat baris tertentu. Maka saya memodifikasi jawaban yang diberikan oleh Darius Bacon menjadi coffeescript:

is_on = (a,b,c) ->
    # "Return true if point c intersects the line segment from a to b."
    # (or the degenerate case that all 3 points are coincident)
    return (collinear(a,b,c) and withincheck(a,b,c))

withincheck = (a,b,c) ->
    if a[0] != b[0]
        within(a[0],c[0],b[0]) 
    else 
        within(a[1],c[1],b[1])

collinear = (a,b,c) ->
    # "Return true if a, b, and c all lie on the same line."
    ((b[0]-a[0])*(c[1]-a[1]) < (c[0]-a[0])*(b[1]-a[1]) + 1000) and ((b[0]-a[0])*(c[1]-a[1]) > (c[0]-a[0])*(b[1]-a[1]) - 1000)

within = (p,q,r) ->
    # "Return true if q is between p and r (inclusive)."
    p <= q <= r or r <= q <= p

Anda dapat menggunakan produk wedge dan dot:

def dot(v,w): return v.x*w.x + v.y*w.y
def wedge(v,w): return v.x*w.y - v.y*w.x

def is_between(a,b,c):
   v = a - b
   w = b - c
   return wedge(v,w) == 0 and dot(v,w) > 0

Begini cara saya melakukannya di sekolah. Saya lupa mengapa itu bukan ide yang bagus.

EDIT:

@Darius Bacon: mengutip buku "Beautiful Code" yang berisi penjelasan mengapa kode di bawah ini bukan ide yang bagus.

#!/usr/bin/env python
from __future__ import division

epsilon = 1e-6

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

class LineSegment:
    """
    >>> ls = LineSegment(Point(0,0), Point(2,4))
    >>> Point(1, 2) in ls
    True
    >>> Point(.5, 1) in ls
    True
    >>> Point(.5, 1.1) in ls
    False
    >>> Point(-1, -2) in ls
    False
    >>> Point(.1, 0.20000001) in ls
    True
    >>> Point(.1, 0.2001) in ls
    False
    >>> ls = LineSegment(Point(1, 1), Point(3, 5))
    >>> Point(2, 3) in ls
    True
    >>> Point(1.5, 2) in ls
    True
    >>> Point(0, -1) in ls
    False
    >>> ls = LineSegment(Point(1, 2), Point(1, 10))
    >>> Point(1, 6) in ls
    True
    >>> Point(1, 1) in ls
    False
    >>> Point(2, 6) in ls 
    False
    >>> ls = LineSegment(Point(-1, 10), Point(5, 10))
    >>> Point(3, 10) in ls
    True
    >>> Point(6, 10) in ls
    False
    >>> Point(5, 10) in ls
    True
    >>> Point(3, 11) in ls
    False
    """
    def __init__(self, a, b):
        if a.x > b.x:
            a, b = b, a
        (self.x0, self.y0, self.x1, self.y1) = (a.x, a.y, b.x, b.y)
        self.slope = (self.y1 - self.y0) / (self.x1 - self.x0) if self.x1 != self.x0 else None

    def __contains__(self, c):
        return (self.x0 <= c.x <= self.x1 and
                min(self.y0, self.y1) <= c.y <= max(self.y0, self.y1) and
                (not self.slope or -epsilon < (c.y - self.y(c.x)) < epsilon))

    def y(self, x):        
        return self.slope * (x - self.x0) + self.y0

if __name__ == '__main__':
    import  doctest
    doctest.testmod()

Setiap titik pada ruas garis ( a , b ) (di mana a dan b adalah vektor) dapat dinyatakan sebagai kombinasi linier dari dua vektor a dan b :

Dengan kata lain, jika c terletak pada ruas garis ( a , b ):

c = ma + (1 - m)b, where 0 <= m <= 1

Memecahkan m , kita dapatkan:

m = (c.x - b.x)/(a.x - b.x) = (c.y - b.y)/(a.y - b.y)

Jadi, pengujian kami menjadi (dengan Python):

def is_on(a, b, c):
    """Is c on the line segment ab?"""

    def _is_zero( val ):
        return -epsilon < val < epsilon

    x1 = a.x - b.x
    x2 = c.x - b.x
    y1 = a.y - b.y
    y2 = c.y - b.y

    if _is_zero(x1) and _is_zero(y1):
        # a and b are the same point:
        # so check that c is the same as a and b
        return _is_zero(x2) and _is_zero(y2)

    if _is_zero(x1):
        # a and b are on same vertical line
        m2 = y2 * 1.0 / y1
        return _is_zero(x2) and 0 <= m2 <= 1
    elif _is_zero(y1):
        # a and b are on same horizontal line
        m1 = x2 * 1.0 / x1
        return _is_zero(y2) and 0 <= m1 <= 1
    else:
        m1 = x2 * 1.0 / x1
        if m1 < 0 or m1 > 1:
            return False
        m2 = y2 * 1.0 / y1
        return _is_zero(m2 - m1)

c # Dari http://www.faqs.org/faqs/graphics/algorithms-faq/ -> Subjek 1.02: Bagaimana cara mencari jarak dari satu titik ke garis?

Boolean Contains(PointF from, PointF to, PointF pt, double epsilon)
        {

            double segmentLengthSqr = (to.X - from.X) * (to.X - from.X) + (to.Y - from.Y) * (to.Y - from.Y);
            double r = ((pt.X - from.X) * (to.X - from.X) + (pt.Y - from.Y) * (to.Y - from.Y)) / segmentLengthSqr;
            if(r<0 || r>1) return false;
            double sl = ((from.Y - pt.Y) * (to.X - from.X) - (from.X - pt.X) * (to.Y - from.Y)) / System.Math.Sqrt(segmentLengthSqr);
            return -epsilon <= sl && sl <= epsilon;
        }

Berikut beberapa kode Java yang berhasil untuk saya:

boolean liesOnSegment(Coordinate a, Coordinate b, Coordinate  c) {

    double dotProduct = (c.x - a.x) * (c.x - b.x) + (c.y - a.y) * (c.y - b.y);
    if (dotProduct < 0) return true;
    return false;
}

bagaimana dengan memastikan bahwa kemiringannya sama dan titiknya berada di antara yang lain?

diberikan poin (x1, y1) dan (x2, y2) (dengan x2> x1) dan kandidat poin (a, b)

if (b-y1) / (a-x1) = (y2-y2) / (x2-x1) Dan x1 <a <x2

Maka (a, b) harus berada pada garis antara (x1, y1) dan (x2, y2)

Jawaban di C # menggunakan kelas Vector2D

public static bool IsOnSegment(this Segment2D @this, Point2D c, double tolerance)
{
     var distanceSquared = tolerance*tolerance;
     // Start of segment to test point vector
     var v = new Vector2D( @this.P0, c ).To3D();
     // Segment vector
     var s = new Vector2D( @this.P0, @this.P1 ).To3D();
     // Dot product of s
     var ss = s*s;
     // k is the scalar we multiply s by to get the projection of c onto s
     // where we assume s is an infinte line
     var k = v*s/ss;
     // Convert our tolerance to the units of the scalar quanity k
     var kd = tolerance / Math.Sqrt( ss );
     // Check that the projection is within the bounds
     if (k <= -kd || k >= (1+kd))
     {
        return false;
     }
     // Find the projection point
     var p = k*s;
     // Find the vector between test point and it's projection
     var vp = (v - p);
     // Check the distance is within tolerance.
     return vp * vp < distanceSquared;
}

Catat itu

s * s

adalah produk titik dari vektor segmen melalui kelebihan beban operator di C #

Kuncinya adalah mengambil keuntungan dari proyeksi titik ke garis tak hingga dan mengamati bahwa kuantitas skalar dari proyeksi memberi tahu kita secara sepele apakah proyeksi itu ada di segmen atau tidak. Kami dapat menyesuaikan batas-batas kuantitas skalar untuk menggunakan toleransi fuzzy.

Jika proyeksi dalam batas-batas kami hanya menguji apakah jarak dari titik ke proyeksi dalam batas-batas.

Manfaat dari pendekatan produk silang adalah bahwa toleransi memiliki nilai yang berarti.

Inilah solusi saya dengan C # di Unity.

private bool _isPointOnLine( Vector2 ptLineStart, Vector2 ptLineEnd, Vector2 ptPoint )
{
    bool bRes = false;
    if((Mathf.Approximately(ptPoint.x, ptLineStart.x) || Mathf.Approximately(ptPoint.x, ptLineEnd.x)))
    {
        if(ptPoint.y > ptLineStart.y && ptPoint.y < ptLineEnd.y)
        {
            bRes = true;
        }
    }
    else if((Mathf.Approximately(ptPoint.y, ptLineStart.y) || Mathf.Approximately(ptPoint.y, ptLineEnd.y)))
    {
        if(ptPoint.x > ptLineStart.x && ptPoint.x < ptLineEnd.x)
        {
            bRes = true;
        }
    }
    return bRes;
}

Versi C # dari jawaban Jules:

public static double CalcDistanceBetween2Points(double x1, double y1, double x2, double y2)
{
    return Math.Sqrt(Math.Pow (x1-x2, 2) + Math.Pow (y1-y2, 2));
}

public static bool PointLinesOnLine (double x, double y, double x1, double y1, double x2, double y2, double allowedDistanceDifference)
{
    double dist1 = CalcDistanceBetween2Points(x, y, x1, y1);
    double dist2 = CalcDistanceBetween2Points(x, y, x2, y2);
    double dist3 = CalcDistanceBetween2Points(x1, y1, x2, y2);
    return Math.Abs(dist3 - (dist1 + dist2)) <= allowedDistanceDifference;
}

Anda dapat melakukannya dengan menyelesaikan persamaan garis untuk ruas garis tersebut dengan koordinat titik. Anda akan mengetahui apakah titik itu ada di garis dan kemudian memeriksa batas-batas ruas tersebut untuk mengetahui apakah itu di dalam atau di luarnya. Anda dapat menerapkan beberapa ambang batas karena itu adalah suatu tempat di ruang yang kemungkinan besar ditentukan oleh nilai titik mengambang dan Anda tidak boleh mencapai yang tepat. Contoh di php

function getLineDefinition($p1=array(0,0), $p2=array(0,0)){
    
    $k = ($p1[1]-$p2[1])/($p1[0]-$p2[0]);
    $q = $p1[1]-$k*$p1[0];
    
    return array($k, $q);
    
}

function isPointOnLineSegment($line=array(array(0,0),array(0,0)), $pt=array(0,0)){
    
    // GET THE LINE DEFINITION y = k.x + q AS array(k, q) 
    $def = getLineDefinition($line[0], $line[1]);
    
    // use the line definition to find y for the x of your point
    $y = $def[0]*$pt[0]+$def[1];

    $yMin = min($line[0][1], $line[1][1]);
    $yMax = max($line[0][1], $line[1][1]);

    // exclude y values that are outside this segments bounds
    if($y>$yMax || $y<$yMin) return false;
    
    // calculate the difference of your points y value from the reference value calculated from lines definition 
    // in ideal cases this would equal 0 but we are dealing with floating point values so we need some threshold value not to lose results
    // this is up to you to fine tune
    $diff = abs($pt[1]-$y);
    
    $thr = 0.000001;
    
    return $diff<=$thr;
    
}