Determine if two triangles overlap: Difference between revisions

{{trans|D}}

 

(Float, Float) p1, p2, p3

 

print(t1" and\n"t2)

print(‘which have only a single corner in contact, if boundary points do not collide’)

 

{{out}}

 

=={{header|Ada}}==

WITH Ada.Text_IO; USE Ada.Text_IO;

 

Put ((0.0, 0.0, 1.0, 0.0, 0.0, 1.0), (1.0, 0.0, 2.0, 0.0, 1.0, 1.0));

END Main;

{{out}}

<pre>true

{{Trans|Kotlin}}

... with different output format (based on Modula 2).

record Point ( real x, y );

record Triangle ( reference(Point) p1, p2, p3 );

CheckOverlap( t1, t2, 0.0, false, false );

end

{{out}}

<pre>

 

=={{header|AutoHotkey}}==

counter := 0

for i, Pt in T1

isBetween(x, p1, p2){

return !((x>p1 && x>p2) || (x<p1 && x<p2))

result .= TrianglesIntersect([[0,0],[5,0],[0,5]], [[0,0],[5,0],[0,6]]) "`n"

result .= TrianglesIntersect([[0,0],[0,5],[5,0]], [[0,0],[0,5],[5,0]]) "`n"

result .= TrianglesIntersect([[0,0],[1,0],[0,1]], [[1,0],[2,0],[1,1]]) "`n"

MsgBox % result

Outputs:<pre>1

1

=={{header|C}}==

{{trans|C++}}

#include <stdbool.h>

#include <stdio.h>

 

return EXIT_SUCCESS;

{{out}}

<pre>1,true

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

 

}

}

{{out}}

<pre>Triangle: (0, 0), (5, 0), (0, 5) and

 

=={{header|C++}}==

#include <iostream>

#include <stdexcept>

cout << TriTri2D(t1, t2, 0.0, false, false) << "," << false << endl;}

 

 

{{out}}

=={{header|D}}==

{{trans|Kotlin}}

import std.typecons;

 

writeln("which have only a single corner in contact, if boundary points do not collide");

overlap(t1, t2, 0.0, false, false);

 

{{out}}

=={{header|F Sharp|F#}}==

{{trans|Kotlin}}

 

type Point = double * double

Console.WriteLine("{0} and\n{1}\nwhich have only a single corner in contact, if boundary points do not collide\n{2}", t11, t12, if TriTri2D 0.0 false false t11 t12 then "overlap" else "do not overlap")

 

{{out}}

<pre>((0, 0), (5, 0), (0, 5)) and

 

=={{header|FreeBASIC}}==

Iif(x>y,y,x)

#endmacro

print triangle_overlap( a(), b() )

next t

{{out}}

<pre>

=={{header|Go}}==

{{trans|Kotlin}}

 

import "fmt"

overlapping = triTri2D(t1, t2, 0.0, false, false)

fmt.Println(iff(overlapping, "overlap", "do not overlap"))

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

 

class TriangleOverlap {

}

}

{{out}}

<pre>Triangle: (0.0, 0.0), (5.0, 0.0), (0.0, 5.0) and

Uses the solution of the task [[Find_if_a_point_is_within_a_triangle#Haskell]]

 

isOverlapping t1 t2 = vertexInside || midLineInside

where

, (Triangle (0,0) (1,1) (0,2), Triangle (2,1) (3,0) (3,2))

, (Triangle (0,0) (1,1) (0,2), Triangle (2,1) (3,-2) (3,4))

 

<pre>λ> test

{{trans|Kotlin}}

{{works with|Java|8}}

 

public class TriangleOverlap {

}

}

{{out}}

<pre>Triangle: (0.0, 0.0), (5.0, 0.0), (0.0, 5.0) and

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

# Triangles are realized as triples of Points [p1, p2, p3]

else true # The triangles overlap

end

'''The Task'''

def t: "Triangle: ";

def printTris(t1; t2; nl):

if triTri2D($t1; $t2; 0; false; false) then "overlap" else "do not overlap" end) );

 

{{out}}

<pre>

{{trans|Python}}

'''Module''':

 

using LinearAlgebra

end

 

 

'''Main''':

 

t1 = [0 0; 5 0; 0 5]

t1 = [0 0; 1 0; 0 1]

t2 = [1 0; 2 0; 1 1]

 

{{out}}

=={{header|Kotlin}}==

{{trans|C++}}

 

typealias Point = Pair<Double, Double>

println("which have only a single corner in contact, if boundary points do not collide")

println(if (triTri2D(t1, t2, 0.0, false, false)) "overlap" else "do not overlap")

 

{{out}}

 

=={{header|Lambdatalk}}==

Here we present a rasterized version based on a single function "isInside".

 

.............................11

..............................1

 

=={{header|Lua}}==

{{trans|C++}}

return p1.x * (p2.y - p3.y)

+ p2.x * (p3.y - p1.y)

print(formatTri(t1).." and")

print(formatTri(t2))

{{out}}

<pre>Triangle: (0, 0), (5, 0), (0, 5) and

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

p2 = Polygon@{{0, 0}, {5, 0}, {0, 6}};

! RegionDisjoint[p1, p2]

p1 = Polygon@{{0, 0}, {1, 0}, {0, 1}};

p2 = Polygon@{{1, 0}, {2, 0}, {1, 1}};

{{out}}

<pre>True

 

=={{header|Modula-2}}==

FROM EXCEPTIONS IMPORT AllocateSource,ExceptionSource,GetMessage,RAISE;

FROM LongStr IMPORT RealToFixed;

 

ReadChar

 

=={{header|Nim}}==

{{trans|Go}}

 

type Point = tuple[x, y: float]

echo "which have only a single corner in contact, if boundary points do not collide"

overlapping = triTri2D(t1, t2, 0, false, false)

 

{{out}}

 

=={{header|ooRexx}}==

* Determine if two triangles overlap

* Fully (?) tested with integer coordinates of the 6 corners

res=res word(list,i)

End

{{out}}

<pre>0 0 4 0 0 4 1 1 2 1 1 2

=={{header|Pascal}}==

A console application in Free Pascal, created with the Lazarus IDE. It recognizes three possible outcomes: disjoint, positive overlap, and borderline (overlap at a point or line segment).

program TrianglesOverlap;

{

TestTrianglePair( 0,0,1,0,0,1, 1,0,2,0,1,1);

end.

{{out}}

<pre>

=={{header|Perl}}==

===Port of Lua===

use warnings;

 

@t1 = ({x=>0, y=>0}, {x=>1, y=>0}, {x=>0, y=>1});

@t2 = ({x=>1, y=>0}, {x=>2, y=>0}, {x=>1, y=>1});

{{out}}

<pre>Triangle: (0, 0), (5, 0), (0, 5) and

 

===More Idiomatic===

use warnings;

use feature 'say';

);

 

{{out}}

<pre> overlap: (0,0), (5,0), (0,5) and (0,0), (5,0), (0,6)

{{trans|zkl}}

Plus draw all eight pairs of triangles for visual confirmation.

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Determine_if_two_triangles_overlap.exw

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

 

=={{header|Python}}==

{{libheader|NumPy}}

Using numpy:

import numpy as np

 

t1 = [[0,0],[1,0],[0,1]]

t2 = [[1,0],[2,0],[1,1]]

 

{{out}}

{{libheader|Shapely}}

Using shapely:

from shapely.geometry import Polygon

 

t1 = [[0,0],[1,0],[0,1]]

t2 = [[1,0],[2,0],[1,1]]

 

{{out}}

 

=={{header|QB64}}==

DATA 0,0,5,0,0,5,0,0,5,0,0,6

DATA 0,0,0,5,5,0,0,0,0,5,5,0

p.y = (10 + p.y) * 30

END SUB

 

=={{header|Racket}}==

{{trans|Zkl}}

 

 

;; A triangle is a list of three pairs of points: '((x . y) (x . y) (x . y))

(check-true (tri-tri-2d? c1 c2 #:on-boundary? #t))

(check-false (tri-tri-2d? c1 c2 #:on-boundary? #f))))

 

No output &rarr; all tests passed

(formerly Perl 6)

First, check if any vertex is inside each other triangle (that should cover most overlapping cases including enclosures). Then see if an edge of triangle A intersects any of two edges of B (for shapes like Star of David [https://en.wikipedia.org/wiki/Star_of_David])

# https://stackoverflow.com/questions/2049582/how-to-determine-if-a-point-is-in-a-2d-triangle

# https://www.geeksforgeeks.org/check-if-two-given-line-segments-intersect/

];

 

{{out}}

<pre>[(0 0) (5 0) (0 5)] and [(0 0) (5 0) (0 6)] do overlap.

=={{header|REXX}}==

Note: The triangles must be real triangles (no edge of length 0)

Signal On Halt

Signal On Novalue

Nop

End

{{out}}

<pre>ABC: (0/0) (5/0) (0/5)

=={{header|Ruby}}==

{{trans|C}}

 

def det2D(p1, p2, p3)

end

 

{{out}}

<pre>Triangle: [Vector[0, 0], Vector[5, 0], Vector[0, 5]]

=={{header|Scala}}==

{{trans|Kotlin}}

type Point = (Double, Double)

 

println(if (triTri2D(t1, t2, onBoundary = false)) "overlap" else "do not overlap")

}

{{out}}

<pre>Triangle: (0.0,0.0), (5.0,0.0), (0.0,5.0) and

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Class Triangle

End Sub

 

{{out}}

<pre>Triangle: (0, 0), (5, 0), (0, 5) and

=={{header|Vlang}}==

{{trans|Go}}

x f64

y f64

overlapping = tri_tri_2d(mut t1, mut t2, 0.0, false, false)

println(iff(overlapping, "overlap", "do not overlap"))

 

{{out}}

{{trans|Kotlin}}

{{libheader|Wren-dynamic}}

 

var Point = Tuple.create("Point", ["x", "y"])

printTris.call(t1, t2, "\n")

System.print("which have only a single corner in contact, if boundary points do not collide")

 

{{out}}

=={{header|zkl}}==

{{trans|C++}}

 

fcn det2D(triangle){

}

True // The triangles collide

vm.arglist.apply("toFloat").pump(List,Void.Read)

}

c1,c2 := toTri(0,0, 1,0, 0,1), toTri(1,0, 2,0, 1,1);

println("Corner case (barely touching): ",triTri2D(c1,c2,0.0,False,True)); // True

{{out}}

<pre>