Find the intersection of a line with a plane: Difference between revisions

[[Category:Geometry]]

[[Category:Collision detection]]

 

;Task:

 

=={{header|11l}}==

 

 

 

{{out}}

<pre>

The ray intersects the plane at (0, -5, 5)

</pre>

 

=={{header|C}}==

Straightforward application of the intersection formula, prints usage on incorrect invocation.

#include<stdio.h>

 

return 0;

}

Invocation and output:

<pre>

Intersection point is (0.000000,-5.000000,5.000000)

</pre>

 

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

{{trans|Java}}

#include <sstream>

 

 

return 0;

{{out}}

<pre>The ray intersects the plane at (0, -5, 5)</pre>

 

=={{header|D}}==

{{trans|Kotlin}}

 

struct Vector3D {

auto ip = intersectPoint(rv, rp, pn, pp);

writeln("The ray intersects the plane at ", ip);

 

{{out}}

<pre>The ray intersects the plane at (0.000000,-5.000000,5.000000)</pre>

 

{{trans|C#}}

 

type Vector(x : double, y : double, z : double) =

Console.WriteLine("The ray intersects the plane at {0}", ip)

 

{{out}}

<pre>The ray intersects the plane at (0.00, -5.00, 5.00)</pre>

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>line intersects the plane at (0, -5, 5)</pre>

=={{header|Go}}==

{{trans|Kotlin}}

 

import "fmt"

ip := intersectPoint(rv, rp, pn, pp)

fmt.Println("The ray intersects the plane at", ip)

 

{{out}}

The ray intersects the plane at (0, -5, 5)

</pre>

 

=={{header|Haskell}}==

{{trans|Kotlin}}

Note that V3 is implemented similarly in the external library [https://hackage.haskell.org/package/linear-1.20.7/docs/Linear-V3.html linear].

import Text.Printf (printf)

 

rp = V3 0 0 10

pn = V3 0 0 1

{{out}}

<pre>The ray intersects the plane at (0.0, -5.0, 5.0)</pre>

=={{header|J}}==

'''Solution:'''

p=: mp&{: %~ -~&{. mp {:@] NB. solve

'''Example Usage:'''

Plane=: 0 0 5 ,: 0 0 1 NB. Point, Normal

Line intersectLinePlane Plane

 

=={{header|Java}}==

{{trans|Kotlin}}

private static class Vector3D {

private double x, y, z;

System.out.println("The ray intersects the plane at " + ip);

}

{{out}}

<pre>The ray intersects the plane at (0.000000, -5.000000, 5.000000)</pre>

 

=={{header|Julia}}==

{{trans|Python}}

 

ndotu = dot(planenorm, raydir)

if ndotu ≈ 0 error("no intersection or line is within plane") end

 

ψ = lineplanecollision(planenorm, planepnt, raydir, raypnt)

 

{{out}}

 

=={{header|Kotlin}}==

 

class Vector3D(val x: Double, val y: Double, val z: Double) {

val ip = intersectPoint(rv, rp, pn, pp)

println("The ray intersects the plane at $ip")

 

{{out}}

 

=={{header|Lua}}==

return {x=xval, y=yval, z=zval}

end

pp = make(0.0, 0.0, 5.0)

ip = intersectPoint(rv, rp, pn, pp)

{{out}}

<pre>The ray intersects the plane at (0, -5, 5)</pre>

 

=={{header|Maple}}==

geom3d:-line(L, [geom3d:-point(p2,0,0,10), [0,-1,-1]]);

geom3d:-intersection(px,L,P);

{{Out}}

<pre>[["name of the object",px],["form of the object",point3d],["coordinates of the point",[0,-5,5]]]</pre>

 

=={{header|MATLAB}}==

{{trans|Kotlin}}

 

pdiff = rayPoint - planePoint;

prod3 = prod1 / prod2;

 

{{out}}

 

ans =

 

0 -5 5

 

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

FROM RealStr IMPORT RealToStr;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar;

 

=={{header|Perl}}==

package Plane; sub new { my ($c, $a) = @_; my $self = { V0 => $a->{V0}, n => $a->{n} } } # point / normal

 

my $P = Plane->new({ V0=>[0,0,5 ], n=>[0, 0, 1]});

print 'Intersection at point: ', join(' ', line_plane_intersection($L, $P)) . "\n";

{{out}}

<pre>Intersection at point: 0 -5 5</pre>

 

 

 

 

 

{{out}}

 

 

 

{{out}}

<pre>

</pre>

 

Based on the approach at geomalgorithms.com<ref>http://geomalgorithms.com/a05-_intersect-1.html</ref>

 

from __future__ import print_function

import numpy as np

 

Psi = LinePlaneCollision(planeNormal, planePoint, rayDirection, rayPoint)

 

{{out}}

<pre>intersection at [ 0 -5 5]</pre>

 

=={{header|Racket}}==

{{trans|Sidef}}

;; {{trans|Sidef}}

;; vectors are represented by lists

(line-plane-intersection (Line '(0 0 10) '(0 -1 -1))

(Plane '(0 0 5) '(0 0 1)))

 

{{out}}

No output -- all tests passed!

 

=={{header|REXX}}==

===version 1===

This program does NOT handle the case when the line is parallel to or within the plane.

Parse Value '0 0 1' With n.1 n.2 n.3 /* Normal Vector of the plane */

Parse Value '0 0 5' With p.1 p.2 p.3 /* Point in the plane */

z=a.3+t*v.3

 

 

{{out}}

===version 2===

handle the case that the line is parallel to the plane or lies within it.

Parse Value '1 2 3' With n.1 n.2 n.3

Parse Value '3 3 3' With p.1 p.2 p.3

End

End

{{out}}

<pre>Plane definition: x+2*y+3*z=18

Line definition: x=3*t ; y=2+2*t ; z=4+t

Intersection: P(0.6,2.4,4.2)</pre>

 

=={{header|Rust}}==

{{trans|Kotlin}}

 

 

#[derive(Copy, Clone, Debug, PartialEq)]

println!("{:?}", intersect(rv, rp, pn, pp));

}

 

=={{header|Scala}}==

val (rv, rp, pn, pp) =

(Vector3D(0.0, -1.0, -1.0), Vector3D(0.0, 0.0, 10.0), Vector3D(0.0, 0.0, 1.0), Vector3D(0.0, 0.0, 5.0))

println(s"The ray intersects the plane at $ip")

{{Out}}See it in running in your browser by [https://scalafiddle.io/sf/oLTlNZk/0 ScalaFiddle (JavaScript)].

=={{header|Sidef}}==

P0, # point

u⃗, # ray

Line(P0: [0,0,10], u⃗: [0,-1,-1]),

Plane(V0: [0,0, 5], n⃗: [0, 0, 1]),

{{out}}

<pre>Intersection at point: [0, -5, 5]</pre>

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

{{trans|C#}}

 

Class Vector3D

End Sub

 

{{out}}

<pre>The ray intersects the plane at (0.00, -5.00, 5.00)</pre>

 

=={{header|zkl}}==

class Plane{ fcn init(pxyz, normal_xyz){ var pt=pxyz, normal=normal_xyz; } }

 

//w.zipWith('+,line.ray.apply('*,si)).zipWith('+,plane.pt); // or

w.zipWith('wrap(w,r,pt){ w + r*si + pt },line.ray,plane.pt);

Line( T(0.0, 0.0, 10.0), T(0.0, -1.0, -1.0) ),

Plane(T(0.0, 0.0, 5.0), T(0.0, 0.0, 1.0) ))

{{out}}

<pre>