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

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

 

R ray_point - ray_direction * dot(ray_point - plane_point, plane_normal) / dot(ray_direction, plane_normal)

 

 

{{out}}

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

 

PROC PrintVector(VectorR POINTER v)

Vector(r5,r1,r0,planePoint)

Test(rayVector,rayPoint,planeNormal,planePoint)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Find_the_intersection_of_a_line_with_a_plane.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

with Ada.Text_IO;

 

Plane_Normal => (0.0, 0.0, 1.0),

Plane_Point => (0.0, 0.0, 5.0)));

{{out}}

<pre>( 0.000,-5.000, 5.000)</pre>

 

=={{header|APL}}==

⍝ The intersection I belongs to a line defined by point L and vector V, translates to:

⍝ A real parameter t exists, that satisfies I = L + tV

t ← ((P - L) dot N) ÷ V dot N

I ← L + t × V

{{out}}

<pre>

0 ¯5 5

</pre>

 

=={{header|AutoHotkey}}==

; https://en.wikipedia.org/wiki/Line%E2%80%93plane_intersection#Algebraic_form

l = line vector

Vector_Dot(v, w){

return v.1*w.1 + v.2*w.2 + v.3*w.3

l1 := [0, -1, -1]

lo1 := [0, 0, 10]

}

MsgBox % output

{{out}}

<pre>0.000000, -5.000000, 5.000000

=={{header|C}}==

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

#include<stdio.h>

 

return 0;

}

Invocation and output:

<pre>

 

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

 

namespace FindIntersection {

}

}

{{out}}

<pre>The ray intersects the plane at (0.00, -5.00, 5.00)</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|Factor}}==

{{trans|11l}}

 

:: intersection-point ( rdir rpt pnorm ppt -- loc )

 

"The ray intersects the plane at " write

{{out}}

<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}}

=={{header|Groovy}}==

{{trans|Java}}

private static class Vector3D {

private double x, y, z

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

}

{{out}}

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

{{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|Mathematica}} / {{header|Wolfram Language}}==

{{out}}

<pre>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|Nim}}==

type Vector = tuple[x, y, z: float]

 

planeVector = (0.0, 0.0, 1.0),

planePoint = (0.0, 0.0, 5.0))

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

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>

 

=={{header|Phix}}==

{{out}}

<pre>

"no intersection"

"no intersection"

</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}}

=={{header|R}}==

{{trans|MATLAB}}

 

pdiff <- ray_point - plane_point

 

return(point)

{{out}}

 

=={{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}}

{{trans|Python}}

 

has $.P0; # point

has $.u⃗; # ray

Line.new( :P0(0,0,10), :u⃗(0,-1,-1) ),

Plane.new( :V0(0,0, 5), :n⃗(0, 0, 1) )

{{out}}

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

 

=={{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|Ruby}}==

{{trans|C#}}

 

def intersectPoint(rayVector, rayPoint, planeNormal, planePoint)

end

 

{{out}}

<pre>The ray intersects the plane at Vector[0.0, -5.0, 5.0]</pre>

{{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}}==

{{trans|Raku}}

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|Wren}}==

{{trans|Kotlin}}

 

var intersectPoint = Fn.new { |rayVector, rayPoint, planeNormal, planePoint|

}

 

var ip = intersectPoint.call(rv, rp, pn, pp)

 

{{out}}

<pre>

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

</pre>

 

=={{header|zkl}}==

{{trans|Raku}}{{trans|Python}}

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>