Ray-casting algorithm: Difference between revisions

'''if''' Py < Ay '''or''' Py > By '''then'''

'''return''' false

'''return''' false

'''else'''

(To avoid the "ray on vertex" problem, the point is moved upward of a small quantity &nbsp; <big>&epsilon;</big>.)

<br><br>

 

=={{header|Ada}}==

polygons.ads:

 

type Point is record

function Is_Inside (Who : Point; Where : Polygon) return Boolean;

 

 

polygons.adb:

EPSILON : constant := 0.00001;

 

end Is_Inside;

 

 

Example use:

 

main.adb:

with Polygons;

procedure Main is

Ada.Text_IO.New_Line;

end loop;

 

Output:

Point(8.0,5.0): TRUE

Point(10.0,10.0): FALSE</pre>

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey L}}

, {x: 5.0, y: 8.0}

, {x:-10.0, y: 5.0}

}

}

{{out}}

<pre>---------------------------

OK

---------------------------</pre>

 

=={{header|C}}==

#include <stdlib.h>

#include <math.h>

 

return 0;

 

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

{{works with|C++|11}}

{{trans|D}}

#include <cstdlib>

#include <iomanip>

 

return EXIT_SUCCESS;

{{output}}

As D.

=={{header|CoffeeScript}}==

Takes a polygon as a list of points joining segments, and creates segments between them.

 

pointInPoly = (point,poly) ->

mAB = (b.y - a.y) / (b.x - a.x)

mAP = (p.y - a.y) / (p.x - a.x)

 

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

Points are represented as cons cells whose car is an x value and whose cdr is a y value. A line segment is a cons cell of two points. A polygon is a list of line segments.

(do ((in-p nil)) ((endp polygon) in-p)

(when (ray-intersects-segment point (pop polygon))

((null m-blue) t)

((null m-red) nil)

 

Testing code

#((0 . 0) (10 . 0) (10 . 10) (0 . 10)

(2.5 . 2.5) (7.5 . 2.5) (7.5 . 7.5) (2.5 . 7.5)

do (format t "~&~w ~:[outside~;inside ~]."

test-point

 

=={{header|D}}==

 

immutable struct Point { double x, y; }

writeln;

}

{{out}}

<pre>Is point inside figure "Square"?

=={{header|Factor}}==

To test whether a ray intersects a line, we test that the starting point is between the endpoints in y value, and that it is to the left of the point on the segment with the same y value. Note that this implementation does not support polygons with horizontal edges.

IN: raycasting

 

[ dup first suffix [ rest-slice ] [ but-last-slice ] bi ] dip

[ ray ] curry 2map

Usage:

( scratchpad ) square { 0 0 } raycast .

t

f

( scratchpad ) square { 2 0 } raycast .

 

=={{header|Fortran}}==

 

This module ''defines'' "polygons".

use Points_Module

implicit none

end subroutine free_polygon

 

 

The ray casting algorithm module:

use Polygons

implicit none

end function point_is_inside

 

 

'''Testing'''

use Points_Module

use Ray_Casting_Algo

end do

 

 

=={{header|FreeBASIC}}==

Inpolygon by Winding number method

As Single x,y

End Type

End Select

Next z

Output:

<pre>squared

 

The first solution given here follows the model of most other solutions on the page in defining a polygon as a list of segments. Unfortunately this representation does not require that the polygon is ''closed''. Input to the ray-casting algorithm, as noted in the WP article though, is specified to be a closed polygon. The "strange" shape defined here is not a closed polygon and so gives incorrect results against some points. (Graphically it may appear closed but mathematically it needs an additional segment returning to the starting point.)

 

import (

}

}

{{out}}

<pre>

 

Here input is given as a list of N vertices defining N segments, where one segment extends from each vertex to the next, and one more extends from the last vertex to the first. In the case of the "strange" shape, this mathematically closes the polygon and allows the program to give correct results.

 

import (

}

}

{{out}}

<pre>

 

This solution is preferred over the two above.

 

import "fmt"

}

}

 

=={{header|Haskell}}==

 

type Point = (Rational, Rational)

(py /= by || ay < py)

((ax, ay), (bx, by)) = side

 

=={{header|J}}==

NB. bool=. points crossPnP polygon

crossPnP=: 4 : 0"2

p2=. (x0-/X) < (x0-x1) * (y0-/Y) % (y0 - y1)

2|+/ p1*.p2

 

Sample data:

SQUAREV=: SQUAREV, 2.5 2.5 , 7.5 0.1 , 7.5 7.5 ,: 2.5 7.5

 

STRANGE=: (0 4,4 3,3 7,7 6,6 2,2 1,1 5,:5 0) , .{ SQUAREV

 

 

Testing:

1 1 1 0 0 1 1 1 0 1 0

1 1 1 0 0 1 1 1 0 1 0

0 1 1 0 0 1 1 1 0 1 0

 

=={{header|Java}}==

 

public class RayCasting {

P[1] += 0.0001;

 

return false;

 

 

final static int[][][] shapes = {square, squareHole, strange, hexagon};

 

 

=={{header|Javascript}}==

/**

* @return {boolean} true if (lng, lat) is in bounds

}

}

 

=={{header|Kotlin}}==

{{trans|D}}

import java.lang.Double.MIN_VALUE

import java.lang.Math.abs

}

}

val figures = arrayOf(Figure("Square", arrayOf(Edge(Point(0.0, 0.0), Point(10.0, 0.0)), Edge(Point(10.0, 0.0), Point(10.0, 10.0)),

Edge(Point(10.0, 10.0), Point(0.0, 10.0)),Edge(Point(0.0, 10.0), Point(0.0, 0.0)))),

 

Ray_casting.check(figures, points)

{{out}}

<pre>points: [Point(x=5.0, y=5.0), Point(x=5.0, y=8.0), Point(x=-10.0, y=5.0), Point(x=0.0, y=5.0), Point(x=10.0, y=5.0), Point(x=8.0, y=5.0), Point(x=10.0, y=10.0)]

 

Displays interactively on-screen.

Global sw, sh, verts

 

Function rand(loNum,hiNum)

rand = Int(Rnd(0)*(hiNum-loNum+1)+loNum)

 

=={{header|OCaml}}==

{{Trans|C}}

type polygon = {

print_newline()

) test_points;

 

=={{header|Perl}}==

use List::Util qw(max min);

 

 

return ($m_blue >= $m_red) ? 1 : 0;

 

Testing:

sub point

{

( point_in_polygon($tp, $rp) ? "INSIDE" : "OUTSIDE" ) . "\n";

}

 

=={{header|Phix}}==

{{out}}

<pre>

********** ********** **** ******

********** ********** * ****

</pre>

 

=={{header|PicoLisp}}==

 

(de intersects (Px Py Ax Ay Bx By)

(when (apply intersects Edge (car Pt) (cdr Pt))

(onOff Res) ) )

Test data:

<pre style="height:20em;overflow:scroll">(de Square

=={{header|PureBasic}}==

The code below is includes a GUI for drawing a polygon with the mouse that constantly tests whether the mouse is inside or outside the polygon. It displays a message and changes the windows color slightly to indicate if the pointer is inside or outside the polygon being drawn. The routine that does the checking is called inpoly() and it returns a value of one if the point is with the polygon and zero if it isn't.

x.f

y.f

FlipBuffers()

 

=={{header|Python}}==

from pprint import pprint as pp

import sys

for p in testpoints[3:6]))

print (' ', '\t'.join("%s: %s" % (p, ispointinside(p, poly))

 

'''Sample output'''

 

'''Helper routine to convert Fortran Polygons and points to Python'''

point = Pt

pts = (point(0,0), point(10,0), point(10,10), point(0,10),

print ' ', ',\n '.join(str(e) for e in p.edges) + '\n )),'

print ' ]'

 

=={{header|R}}==

count <- 0

for(side in polygon) {

}

}

 

 

point <- function(x,y) list(x=x, y=y)

}

pol

 

 

pts <- list(point(0,0), point(10,0), point(10,10), point(0,10),

p$x, p$y, point_in_polygon(polygons[[polysi]], p), names(polygons[polysi])))

}

 

=={{header|Racket}}==

Straightforward implementation of pseudocode

#lang racket

 

(module pip racket

(require racket/contract)

(provide point)

(provide seg)

 

(struct point (x y) #:transparent)

(define ε 0.000001)

(define (neq? x y) (not (eq? x y)))

(eq? Pyo By))

ε 0))])

[(> Px (max Ax Bx)) #f]

 

(define (point-in-polygon? point polygon)

(test-figure square "square")

(test-figure exagon "exagon")

 

{{out}}

testing (point 10.0 10.0): #f

</pre>

 

=={{header|REXX}}==

 

Code was added to facilitate easier specification of polygon sides by just specifying their &nbsp; ''vertices'' &nbsp; instead of specifying their &nbsp; ''line segments''.

call points 5 5, 5 8, -10 5, 0 5, 10 5, 8 5, 10 10

call poly 0 0, 10 0, 10 10, 0 10 ; call test 'square'

call poly 0 0, 10 0, 10 10, 0 10, A A, B A, B B, A B ; call test 'square hole'

call poly 0 0, A A, 0 10, A B, B B, 10 10, 10 0 ; call test 'irregular'

call poly 3 0, 7 0, 10 5, 7 10, 3 10, 0 5 ; call test 'hexagon'

/*──────────────────────────────────────────────────────────────────────────────────────*/

return # // 2 /*ODD is inside. EVEN is outside.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

if Ay>By then parse value Ax Ay Bx By with Bx By Ax Ay

/*──────────────────────────────────────────────────────────────────────────────────────*/

end /*j*/

call value point.0, j-1 /*define the number of points. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

end /*j*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

right( right(point.k.x, wx)', 'right(point.k.y, wy), w) " is ",

end /*k*/

<pre>

[square] point: 5, 5 is inside

=={{header|Rust}}==

{{trans|Python}}

 

const _EPS: f64 = 0.00001;

const _MAX: f64 = f64::MAX;

 

struct Point {

x: f64,

}

 

struct Edge {

pt1: Point,

}

 

impl Edge {

fn new(pt1: (f64, f64), pt2: (f64, f64)) -> Edge {

}

}

 

}

 

fn pt_in_polygon(pt: &Point, poly: &Polygon) -> bool {

}

 

let (mut a, mut b): (&Point, &Point) = (&edge.pt1, &edge.pt2);

if a.y > b.y {

}

if pt.y == a.y || pt.y == b.y {

}

if (pt.y > b.y || pt.y < a.y) || pt.x > a.x.max(b.x) {

} else {

}

}

 

let poly_square = Polygon {

edges: vec![

Edge::new((10.0, 0.0), (10.0, 10.0)),

Edge::new((10.0, 10.0), (0.0, 10.0)),

let poly_square_hole = Polygon {

edges: vec![

Edge::new((7.5, 2.5), (7.5, 7.5)),

Edge::new((7.5, 7.5), (2.5, 7.5)),

};

let poly_strange = Polygon {

Edge::new((7.5, 7.5), (10.0, 10.0)),

Edge::new((10.0, 10.0), (10.0, 0.0)),

};

let poly_hexagon = Polygon {

Edge::new((7.0, 10.0), (3.0, 10.0)),

Edge::new((3.0, 10.0), (0.0, 5.0)),

print!("\nSquare :");

print!(" {:?}", pt_in_polygon(pt, &poly_square));

}

print!("\nSquare with hole:");

print!(" {:?}", pt_in_polygon(pt, &poly_square_hole));

}

print!("\nStrange polygon :");

print!(" {:?}", pt_in_polygon(pt, &poly_strange));

}

print!("\nHexagon :");

print!(" {:?}", pt_in_polygon(pt, &poly_hexagon));

}

{{out}}

<pre>

=={{header|Scala}}==

{{trans|D}}

 

case class Edge(_1: (Double, Double), _2: (Double, Double)) {

 

private implicit def to_edge(p: ((Double, Double), (Double, Double))): Edge = Edge(p._1, p._2)

{{out}}

<pre>points: List((5.0,5.0), (5.0,8.0), (-10.0,5.0), (0.0,5.0), (10.0,5.0), (8.0,5.0), (10.0,10.0))

{{works with|GNU Smalltalk}}

The class Segment holds the code to test if a ray starting from a point (and going towards "right") intersects the segment (method <tt>doesIntersectRayFrom</tt>); while the class Polygon hosts the code to test if a point is inside the polygon (method <tt>pointInside</tt>).

|pts|

Segment class >> new: points [ |a|

^ ( cnt \\ 2 = 0 ) not

]

 

'''Testing'''

 

points := {

].

' ' displayNl.

 

=={{header|Tcl}}==

proc point_in_polygon {point polygon} {

} {

puts "$point in $poly = [point_in_polygon $point $poly]"

 

=={{header|Ursala}}==

value if it's outside, using the algorithm described above.

For points on the boundary the result is unspecified.

 

in =

@lrzyCipPX ~|afatPRZaq ~&EZ+fleq~~lrPrbr2G&& ~&B+fleq~~lrPrbl2G!| -&

~&Y+ ~~lrPrbl2G fleq,

This test program tries it on a couple of examples.

 

examples =

in* <

((0.5,0.6),<(0.,0.),(1.,2.),(1.,0.)>),

output:

<pre><true,false></pre>

 

=={{header|zkl}}==

fcn rayHitsSeg([(Px,Py)],[(Ax,Ay)],[(Bx,By)]){ // --> Bool

})

.len().isOdd; // True if crossed an odd number of borders ie inside polygon

T("squared",

T(T(T( 0.0, 0.0), T(10.0, 0.0)),

pointInPoly(testPoint,polywanna) and "IN" or "OUT");

}

{{out}}

<pre>