Find if a point is within a triangle: Difference between revisions

:* Wolfram entry [[https://mathworld.wolfram.com/TriangleInterior.html]]

<br><br>

 

=={{header|ALGOL 68}}==

With additional material

{{Trans|Wren}}

# tolerance for the accurate test #

REAL eps = 0.001;

, ( 0.1, 0.11111111111111 ), ( 12.5, 33.333333333333 ), ( -12.5, 16.666666666667 )

)

{{out}}

<pre>

[ 5.4143, 14.3492] in ( [ 0.1000, 0.1111], [ 12.5000, 33.3333], [-12.5000, 16.6667]) -> false

</pre>

 

=={{header|AutoHotkey}}==

for i, p in [[0, 0], [0, 1], [3, 1], [5.4142857, 14.349206]]

result .= "[" p.1 ", " p.2 "] is within triangle?`t" (TriHasP(T, p) ? "ture" : "false") "`n"

TriArea(x1, y1, x2, y2, x3, y3){

return Abs((x1 * (y2-y3) + x2 * (y3-y1) + x3 * (y1-y2)) / 2)

{{out}}

<pre>[0, 0] is within triangle? ture

=={{header|C}}==

{{trans|Go}}

#include <stdio.h>

#include <stdlib.h>

 

return 0;

{{out}}

<pre>Triangle is [(1.500000, 2.400000), (5.100000, -3.100000), (-3.800000, 1.200000)]

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

{{trans|C}}

 

const double EPS = 0.001;

 

return 0;

{{out}}

<pre>Triangle is [(1.5, 2.4), (5.1, -3.1), (-3.8, 1.2)]

 

=={{header|Common Lisp}}==

; There are different algorithms to solve this problem, such as adding areas, adding angles, etc... but these

; solutions are sensitive to rounding errors intrinsic to float operations. We want to avoid these issues, therefore we

(- (car P) (car A)) ))))

 

{{out}}

<pre>

 

=={{header|D}}==

import std.stdio;

 

void main() {

test(1.5, 2.4, 5.1, -3.1, -3.8, 1.2, 0, 0);

test(1.5, 2.4, 5.1, -3.1, -3.8, 1.2, 0, 1);

test(1.5, 2.4, 5.1, -3.1, -3.8, 1.2, 3, 1);

writeln;

test(0.1, 0.1111111111111111, 12.5, 33.333333333333336, -12.5, 16.666666666666668, 5.414285714285714, 14.349206349206348);

writeln;

{{out}}

Point (0, 0) is within triangle? true

Triangle is [(1.5, 2.4), (5.1, -3.1), (-3.8, 1.2)]

Point (0, 1) is within triangle? true

Triangle is [(1.5, 2.4), (5.1, -3.1), (-3.8, 1.2)]

Point (3, 1) is within triangle? false

 

Triangle is [(0.1, 0.111111), (12.5, 33.3333), (-12.5, 16.6667)]

 

=={{header|Factor}}==

Uses the parametric equations method from [https://totologic.blogspot.com/2014/01/accurate-point-in-triangle-test.html].

 

TUPLE: point x y ;

3 3 <point> 16 10 <point> 10 16 <point> <triangle> ! Make a triangle

'[ [ _ point-in-triangle? "#" "." ? write ] each nl ] each nl ! Show points inside the triangle with '#'

{{out}}

<pre>

....................

</pre>

 

=={{header|Go}}==

{{trans|Wren}}

 

import (

within = accuratePointInTriangle(x1, y1, x2, y2, x3, y3, x, y)

fmt.Println("Point", pt, "is within triangle ?", within)

 

{{out}}

Point [5.414285714285714 14.349206349206348] is within triangle ? true

</pre>

 

=={{header|Java}}==

{{trans|Go}}

 

public class FindTriangle {

test(tri, pt);

}

{{out}}

<pre>Triangle[(1.500000, 2.400000), (5.100000, -3.100000), (-3.800000, 1.200000)]

Triangle[(0.100000, 0.111111), (12.500000, 33.333333), (-12.500000, 16.666667)]

Point (5.414286, 14.349206) is within triangle? true</pre>

 

=={{header|Julia}}==

{{trans|Python}}

Using the Wren examples.

Triangle(a, b, c) = [a, b, c]

LEzero(x) = x < 0 || isapprox(x, 0, atol=0.00000001)

end

end

<pre>

Using triangle [[1.5, 2.4], [0.51, -0.31], [-0.38, 1.2]]:

=={{header|Kotlin}}==

{{trans|Java}}

import kotlin.math.min

 

}

}

{{out}}

<pre>Triangle[(1.5, 2.4), (5.1, -3.1), (-3.8, 1.2)]

=={{header|Lua}}==

{{trans|C++}}

EPS_SQUARE = EPS * EPS

 

 

test(0.1, 0.1111111111111111, 12.5, 33.333333333333336, -12.5, 16.666666666666668, 5.414285714285714, 14.349206349206348)

{{out}}

<pre>Triangle is [(1.5, 2.4), (5.1, -3.1), (-3.8, 1.2)]

 

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

{{out}}

<pre>True</pre>

=={{header|Nim}}==

{{trans|Kotlin}}

 

const

p3 = (-100 / 8, 100 / 6)

tri = initTriangle(p1, p2, p3)

 

{{out}}

=={{header|Perl}}==

Translate the Java program at [https://totologic.blogspot.com/2014/01/accurate-point-in-triangle-test.html this blog post] and data set is taken from the [[Find_if_a_point_is_within_a_triangle#Raku|Raku]] entry.

 

use strict;

while ( my @vertex = $iter->()) { print '(',join(',',@vertex),') ' }

print ': ',naivePointInTriangle (@DATA, @$point) ? 'True' : 'False', "\n" ;

{{out}}

<pre>Point (0,0) is within triangle (1.5,2.4) (5.1,-3.1) (-3.8,0.5) : True

 

=={{header|Phix}}==

=== using convex_hull ===

Using convex_hull() from [[Convex_hull#Phix]]

{{out}}

<pre>

 

===trans python===

 

=={{header|Python}}==

""" find if point is in a triangle """

 

isornot = "is" if iswithin(pnt, a, b, c) else "is not"

print("Point", pnt, isornot, "within the triangle", TRI)

<pre>

Point Point2D(0, 0) is within the triangle Triangle(Point2D(3/2, 12/5), Point2D(51/10, -31/10), Point2D(-19/5, 1/2))

I would probably use the dot-product version, if only because it requires less (no) division.

 

 

(define-syntax-rule (all-between-0..1? x ...)

(run-tests point-in-triangle?/barycentric)

(run-tests point-in-triangle?/parametric)

 

{{out}}

Reusing code from the [[Convex_hull#Raku|Convex hull]] task and some logic from the [[Determine_if_two_triangles_overlap#Raku|Determine if two triangles overlap]] task.

 

has Real $.x is rw;

has Real $.y is rw;

say "Point {$point.gist} is within triangle {join ', ', @triangle».gist}: ",

$point.&is-within: @triangle

{{out}}

<pre>Point (0, 0) is within triangle (1.5, 2.4), (5.1, -3.1), (-3.8, 0.5): True

 

<br>Extra certification code was added to verify that the &nbsp; '''X,Y''' &nbsp; coördinates for the points are not missing and are numeric.

parse arg p a b c . /*obtain optional arguments from the CL*/

if p=='' | p=="," then p= '(0,0)' /*Not specified? Then use the default.*/

y: procedure; parse arg ',' y ")"; return cert(y,"Y") /* " " Y " */

$: parse arg aa,bb,cc; return (x(aa)-x(cc)) *(y(bb)-y(cc)) - (x(bb)-x(cc)) *(y(aa)-y(cc))

{{out|output|text=&nbsp; when using the default triangle and the point at: &nbsp; <tt> (0,0) </tt>}}

<pre>

<pre>

point (3,1) isn't within the triangle (1.5,2.4) , (5.1,-3.1) , (-3.8,0.5)

</pre>

 

=={{header|Ruby}}==

{{trans|Go}}

EPS_SQUARE = EPS * EPS

 

end

 

{{out}}

<pre>Triangle is [[1.5, 2.4], [5.1, -3.1], [-3.8, 1.2]]

Triangle is [[0.1, 0.1111111111111111], [12.5, 33.333333333333336], [-12.5, 16.666666666666668]]

Point [5.414285714285714, 14.349206349206348] is within triangle? true</pre>

 

=={{header|Wren}}==

This is a translation of the ActionScript code for the 'accurate' method in the first referenced article above.

var EPS_SQUARE = EPS * EPS

 

 

var pointInTriangleBoundingBox = Fn.new { |x1, y1, x2, y2, x3, y3, x, y|

return !(x < xMin || xMax < x || y < yMin || yMax < y)

}

y3 = tri[2][1]

within = accuratePointInTriangle.call(x1, y1, x2, y2, x3, y3, x, y)

 

{{out}}

 

=={{header|XPL0}}==

real W,X,Y,Z; \ (W-X) dot (Y-Z)

real WX(2), YZ(2);

Text(0, if PointInTri([-5.0,-2.2]) then "inside" else "outside"); CrLf(0);

Text(0, if PointInTri([10.5, 6.3]) then "inside" else "outside"); CrLf(0);

 

{{out}}