GeometryFun

Provides various methods for middle point computations.

Static members

Static member	Description
`BresenhamLineIterator(p0, p1)` Signature: (p0:V2i * p1:V2i) -> IEnumerable<V2i>	Iterates along Bresenham Discrete Line Raster from P0 to P1. Yields each integer position V2i.
`BresenhamLineIterator(p0, p1)` Signature: (p0:V2l * p1:V2l) -> IEnumerable<V2l>	Iterates along Bresenham discrete line raster from p0 to p1. Yields each integer position V2l.
`ClippedBy(p0, p1, relativeEpsilon)` Signature: (p0:Polygon2d * p1:Polygon2d * relativeEpsilon:float) -> IEnumerable<Polygon2d>	Clips one Polygon with an other. Returns a Polygon-Set representing the Intersections of the two. Works only with all (convex/concave) Polygons !!!! UNTESTED !!!!
`ClippedByConvex(poly, second)` Signature: (poly:Polygon2d * second:Polygon2d) -> Polygon2d	Clips one Polygon with an other. Returns a Polygon representing the Intersection of the two. Works only with Convex Polygons. (For non-convex Polygons use Polygon2d.ClipWith(Polygon2d)) !!!! UNTESTED !!!!
`ClipWith(line, poly)` Signature: (line:Line2d * poly:Polygon2d) -> IEnumerable<Line2d>	Returns the Line-Segments of line inside the Polygon (CCW ordered). Works with all (convex and non-convex) Polygons
`ClipWithConvex(line, poly)` Signature: (line:Line2d * poly:Polygon2d) -> Line2d	Returns the Line-Segments of line inside the Polygon (CCW ordered). Works only with Convex-Polygons
`ClosestIntersection(...)` Signature: (poly:Polygon2d * start:V2d * end:V2d * enter:byref<bool> * otherIndex:byref<int> * p:byref<V2d>) -> bool
`ComputeBoxContaining(points, percentile)` Signature: (points:IEnumerable<V3d> * percentile:float) -> Box3d	Compute a box containing approximately the supplied percentile of points, by performing a separate sorting operation on each coordinate.
`Contains(triangle, point)` Signature: (triangle:Triangle2d * point:V2d) -> bool
`Contains(box, quad)` Signature: (box:Box3d * quad:Quad3d) -> bool
`Contains(box, triangle)` Signature: (box:Box3d * triangle:Triangle3d) -> bool
`Contains(box, sphere)` Signature: (box:Box3d * sphere:Sphere3d) -> bool
`Contains(box, cylinder)` Signature: (box:Box3d * cylinder:Cylinder3d) -> bool
`Contains(hull, point)` Signature: (hull:Hull3d * point:V3d) -> bool	Hull normals are expected to point outside.
`Contains(quad, point)` Signature: (quad:Quad2d * point:V2d) -> bool	returns true if the Quad2d contains the Point
`Contains(poly, point)` Signature: (poly:Polygon2d * point:V2d) -> bool	Returns true if the Polygon2d contains the given point. Works with all (convex and non-convex) Polygons. Assumes that the Vertices of the Polygon are sorted counter clockwise
`Contains(poly, point, CCW)` Signature: (poly:Polygon2d * point:V2d * CCW:bool) -> bool	Returns true if the Polygon2d contains the given point. Works with all (convex and non-convex) Polygons. CCW represents the sorting order of the Polygon-Vertices (true -> CCW, false -> CW)
`ConvexHullIndexPolygon(...)` Signature: (indexArray:int [] * pointArray:V2d []) -> IndexPolygon2d	Returns those indices of the supplied index array to the supplied points set that constitute the convex hull. The returned indices emumerate the convex hull in counter-clockwise fashion. Implemented via Andrew's monotone chain 2d convex hull algorithm.
`ConvexHullIndexPolygon(...)` Signature: (pointArray:V2d [] * pointCount:int) -> IndexPolygon2d	Returns the indices of the points of the supplied point set that constitute the convex hull. The returned indices emumerate the convex hull in counter-clockwise fashion. Implemented via Andrew's monotone chain 2d convex hull algorithm.
`Divides(plane, data)` Signature: (plane:Plane2d * data:IEnumerable<V2d>) -> bool	returns true if the Plane2d divides the Point-Cloud
`GetClosestPointOn(query, line)` Signature: (query:V2d * line:Line2d) -> V2d
`GetClosestPointOn(line, query)` Signature: (line:Line2d * query:V2d) -> V2d
`GetClosestPointOn(query, line, t)` Signature: (query:V2d * line:Line2d * t:byref<float>) -> V2d
`GetClosestPointOn(line, query, t)` Signature: (line:Line2d * query:V2d * t:byref<float>) -> V2d
`GetClosestPointOn(query, ray)` Signature: (query:V2d * ray:Ray2d) -> V2d
`GetClosestPointOn(ray, query)` Signature: (ray:Ray2d * query:V2d) -> V2d
`GetClosestPointOn(query, ray, t)` Signature: (query:V2d * ray:Ray2d * t:byref<float>) -> V2d
`GetClosestPointOn(ray, query, t)` Signature: (ray:Ray2d * query:V2d * t:byref<float>) -> V2d
`GetClosestPointOn(point, line)` Signature: (point:V2d * line:Plane2d) -> V2d
`GetClosestPointOn(line, point)` Signature: (line:Plane2d * point:V2d) -> V2d
`GetClosestPointOn(query, box)` Signature: (query:V2d * box:Box2d) -> V2d
`GetClosestPointOn(box, query)` Signature: (box:Box2d * query:V2d) -> V2d
`GetClosestPointOn(vec, quad)` Signature: (vec:V2d * quad:Quad2d) -> V2d
`GetClosestPointOn(quad, vec)` Signature: (quad:Quad2d * vec:V2d) -> V2d
`GetClosestPointOn(vec, poly)` Signature: (vec:V2d * poly:Polygon2d) -> V2d
`GetClosestPointOn(poly, vec)` Signature: (poly:Polygon2d * vec:V2d) -> V2d
`GetClosestPointOn(query, circle)` Signature: (query:V2d * circle:Circle2d) -> V2d
`GetClosestPointOn(circle, query)` Signature: (circle:Circle2d * query:V2d) -> V2d
`GetClosestPointOn(query, triangle)` Signature: (query:V2d * triangle:Triangle2d) -> V2d
`GetClosestPointOn(triangle, query)` Signature: (triangle:Triangle2d * query:V2d) -> V2d
`GetClosestPointOn(query, box)` Signature: (query:V3d * box:Box3d) -> V3d
`GetClosestPointOn(box, query)` Signature: (box:Box3d * query:V3d) -> V3d
`GetClosestPointOn(query, line)` Signature: (query:V3d * line:Line3d) -> V3d
`GetClosestPointOn(line, query)` Signature: (line:Line3d * query:V3d) -> V3d
`GetClosestPointOn(query, line, t)` Signature: (query:V3d * line:Line3d * t:byref<float>) -> V3d
`GetClosestPointOn(line, query, t)` Signature: (line:Line3d * query:V3d * t:byref<float>) -> V3d
`GetClosestPointOn(query, plane)` Signature: (query:V3d * plane:Plane3d) -> V3d
`GetClosestPointOn(plane, query)` Signature: (plane:Plane3d * query:V3d) -> V3d
`GetClosestPointOn(query, ray)` Signature: (query:V3d * ray:Ray3d) -> V3d
`GetClosestPointOn(ray, query)` Signature: (ray:Ray3d * query:V3d) -> V3d
`GetClosestPointOn(query, ray, t)` Signature: (query:V3d * ray:Ray3d * t:byref<float>) -> V3d
`GetClosestPointOn(ray, query, t)` Signature: (ray:Ray3d * query:V3d * t:byref<float>) -> V3d
`GetClosestPointOn(query, sphere)` Signature: (query:V3d * sphere:Sphere3d) -> V3d
`GetClosestPointOn(sphere, query)` Signature: (sphere:Sphere3d * query:V3d) -> V3d
`GetClosestPointOn(query, cylinder)` Signature: (query:V3d * cylinder:Cylinder3d) -> V3d	get closest point on cylinder with infinite length
`GetClosestPointOn(cylinder, query)` Signature: (cylinder:Cylinder3d * query:V3d) -> V3d	get closest point on cylinder with infinite length
`GetClosestPointOn(query, triangle)` Signature: (query:V3d * triangle:Triangle3d) -> V3d	Tested by rft on 2008-08-06.
`GetClosestPointOn(triangle, query)` Signature: (triangle:Triangle3d * query:V3d) -> V3d
`GetClosestPointOn(ray0, ray1)` Signature: (ray0:Ray3d * ray1:Ray3d) -> V3d
`GetClosestPointOn(line0, line1)` Signature: (line0:Line3d * line1:Line3d) -> V3d	Returns the point on line1 which is closest to line0.
`GetClosestPointOn(plane, line)` Signature: (plane:Plane3d * line:Line3d) -> V3d	Returns the closest point from a line to a plane (point on line).
`GetClosestPointOn(line, triangle)` Signature: (line:Line3d * triangle:Triangle3d) -> V3d	Returns the closest point from a triangle to a line (point on triangle). Note: untested
`GetClosestPointOnLine(query, p0, p1)` Signature: (query:V3d * p0:V3d * p1:V3d) -> V3d
`GetClosestPointOnLine(query, p0, p1, t)` Signature: (query:V3d * p0:V3d * p1:V3d * t:byref<float>) -> V3d
`GetClosestPointOnTriangle(...)` Signature: (query:V3d * p0:V3d * p1:V3d * p2:V3d) -> V3d	Tested by rft on 2008-08-06.
`GetClosestPointTOn(query, ray)` Signature: (query:V2d * ray:Ray2d) -> float	Returns the t-parameter along at which the closest point to is.
`GetClosestPointTOn(ray, query)` Signature: (ray:Ray2d * query:V2d) -> float	Returns the t-parameter along at which the closest point to is.
`GetDistanceSquared(q, b)` Signature: (q:V3d * b:Box3d) -> float
`GetDistanceSquared(...)` Signature: (q:V3d * boxAndFlags:Box3dAndFlags * d2Flags:Flags * d2v:V3d * d2Flags0:byref<Flags> * d2v0:byref<V3d> * d2Flags1:byref<Flags> * d2v1:byref<V3d>) -> Pair<float>
`GetIntersectionSigns(box, plane, eps)` Signature: (box:Box3d * plane:Plane3d * eps:float) -> Signs	Classify the position of all the eight vertices of a box with respect to a supplied plane.
`GetIntersectionSigns(...)` Signature: (box:Box3d * plane:Plane3d * eps:float * negBox:byref<Box3d> * zeroBox:byref<Box3d> * posBox:byref<Box3d>) -> Signs	Returns true if the box intersects the supplied plane. The bounding boxes of the resulting parts are returned in the out parameters.
`GetIntersectionSigns(...)` Signature: (box:Box3d * normal:V3d * distance:float * eps:float * negBox:byref<Box3d> * zeroBox:byref<Box3d> * posBox:byref<Box3d>) -> Signs	Returns true if the box intersects the supplied plane. The bounding boxes of the resulting parts are returned in the out parameters.
`GetIntersectionSignsWithPlane(...)` Signature: (box:Box3d * normal:V3d * distance:float * eps:float) -> Signs	Classify the position of all the eight vertices of a box with respect to a supplied plane.
`GetMiddlePoint(ray0, ray1)` Signature: (ray0:Ray3d * ray1:Ray3d) -> V3d
`GetMiddlePoint(rays)` Signature: rays:IEnumerable<Ray3d> -> V3d
`GetMinimalDistanceTo(range0, range1)` Signature: (range0:Range1d * range1:Range1d) -> float
`GetMinimalDistanceTo(box0, box1)` Signature: (box0:Box2d * box1:Box2d) -> float
`GetMinimalDistanceTo(point, line)` Signature: (point:V3d * line:Line3d) -> float	returns the minimal distance between the point and the Line
`GetMinimalDistanceTo(line, point)` Signature: (line:Line3d * point:V3d) -> float	Returns the minimal distance between the point and the Line.
`GetMinimalDistanceTo(point, ray)` Signature: (point:V3d * ray:Ray3d) -> float	returns the minimal distance between the point and the Ray.
`GetMinimalDistanceTo(ray, point)` Signature: (ray:Ray3d * point:V3d) -> float	returns the minimal distance between the point and the Ray.
`GetMinimalDistanceTo(point, ray, t)` Signature: (point:V3d * ray:Ray3d * t:byref<float>) -> float	returns the minimal distance between the point and the Ray. t holds the ray parameter for the closest point.
`GetMinimalDistanceTo(ray, point, t)` Signature: (ray:Ray3d * point:V3d * t:byref<float>) -> float	returns the minimal distance between the point and the Ray. t holds the ray parameter for the closest point.
`GetMinimalDistanceTo(point, plane)` Signature: (point:V3d * plane:Plane3d) -> float	Returns the minimal distance (unsigned) between the point and the plane. Use Plane3d.Height to compute the signed height of the point over the plane.
`GetMinimalDistanceTo(plane, point)` Signature: (plane:Plane3d * point:V3d) -> float	Returns the minimal distance (unsigned) between the point and the plane. Use Plane3d.Height to compute the signed height of the point over the plane.
`GetMinimalDistanceTo(point, box)` Signature: (point:V3d * box:Box3d) -> float	returns the minimal distance between the point and the box.
`GetMinimalDistanceTo(box, point)` Signature: (box:Box3d * point:V3d) -> float	returns the minimal distance between the point and the box.
`GetMinimalDistanceTo(l0, l1)` Signature: (l0:Line3d * l1:Line3d) -> float	returns the minimal distance between the given lines.
`GetMinimalDistanceTo(l0, l1, point)` Signature: (l0:Line3d * l1:Line3d * point:byref<V3d>) -> float	returns the minimal distance between the given lines. points holds the centroid of the shortest connection between the lines
`GetMinimalDistanceTo(line, plane)` Signature: (line:Line3d * plane:Plane3d) -> float
`GetMinimalDistanceTo(plane, line)` Signature: (plane:Plane3d * line:Line3d) -> float
`GetMinimalDistanceTo(ray, line)` Signature: (ray:Ray3d * line:Line3d) -> float	returns the minimal distance between the ray and the line.
`GetMinimalDistanceTo(line, ray)` Signature: (line:Line3d * ray:Ray3d) -> float	returns the minimal distance between the ray and the line.
`GetMinimalDistanceTo(ray, line, t)` Signature: (ray:Ray3d * line:Line3d * t:byref<float>) -> float	returns the minimal distance between the ray and the line. t holds the correspoinding ray parameter.
`GetMinimalDistanceTo(line, ray, t)` Signature: (line:Line3d * ray:Ray3d * t:byref<float>) -> float	returns the minimal distance between the ray and the line. t holds the correspoinding ray parameter.
`GetMinimalDistanceTo(ray0, ray1)` Signature: (ray0:Ray3d * ray1:Ray3d) -> float	returns the minimal distance between the given rays.
`GetMinimalDistanceTo(ray0, ray1, t0, t1)` Signature: (ray0:Ray3d * ray1:Ray3d * t0:byref<float> * t1:byref<float>) -> float	returns the minimal distance between the given rays. t0 and t1 hold the correspunding ray parameters. if both rays are parallel the t0 and t1 are from the origin of ray1
`Intersect(ray, plane)` Signature: (ray:Ray3d * plane:Plane3d) -> V3d	Returns the intersection point with the given plane, or V3d.PositiveInfinity if ray is parallel to plane.
`Intersects(l0, l1)` Signature: (l0:Line2d * l1:Line2d) -> bool	Returns true if the two Lines intersect If the lines overlap and are parallel there is no intersection returned
`Intersects(l0, l1, p)` Signature: (l0:Line2d * l1:Line2d * p:byref<V2d>) -> bool	Returns true if the two Lines intersect p holds the Intersection Point If the lines overlap and are parallel there is no intersection returned
`Intersects(l0, l1, absoluteEpsilon, p)` Signature: (l0:Line2d * l1:Line2d * absoluteEpsilon:float * p:byref<V2d>) -> bool	Returns true if the two Lines intersect with an absolute Tolerance p holds the Intersection Point If the lines overlap and are parallel there is no intersection returned
`Intersects(...)` Signature: (line0:Line2d * line1:Line2d * infiniteLines:bool * p:byref<V2d>) -> bool	Deprecated: use Plane2d.Intersects(Plane2d) or Ray2d.Intersects(Ray2d) instead
`Intersects(ray, line)` Signature: (ray:Ray2d * line:Line2d) -> bool	Returns true if the Ray and the Line intersect. ATTENTION: Both-Sided Ray
`Intersects(ray, line, t)` Signature: (ray:Ray2d * line:Line2d * t:byref<float>) -> bool	returns true if the Ray and the Line intersect. t holds the smallest Intersection-Parameter for the Ray ATTENTION: t can be negative
`Intersects(r0, r1)` Signature: (r0:Ray2d * r1:Ray2d) -> bool	Returns true if the Rays intersect ATTENTION: Both-Sided Rays
`Intersects(r0, r1, t0, t1)` Signature: (r0:Ray2d * r1:Ray2d * t0:byref<float> * t1:byref<float>) -> bool	Returns true if the Rays intersect t0 and t1 are the corresponding Ray-Parameters for the Intersection ATTENTION: Both-Sided Rays
`Intersects(r0, r1, t)` Signature: (r0:Ray2d * r1:Ray2d * t:byref<float>) -> bool	Returns true if the Rays intersect.
`Intersects(plane, line, absoluteEpsilon)` Signature: (plane:Plane2d * line:Line2d * absoluteEpsilon:float) -> bool	Returns true if the Plane2d and the Line2d intersect or the Line2d lies completely in the Plane's Epsilon-Range ATTENTION: Works only with Normalized Plane2ds
`Intersects(plane, line)` Signature: (plane:Plane2d * line:Line2d) -> bool	Returns true if the Plane2d and the Line2d intersect ATTENTION: Works only with Normalized Plane2ds
`Intersects(plane, line, point)` Signature: (plane:Plane2d * line:Line2d * point:byref<V2d>) -> bool	Returns true if the Plane2d and the Line2d intersect point holds the Intersection-Point. If no Intersection is found point is V2d.NaN ATTENTION: Works only with Normalized Plane2ds
`Intersects(...)` Signature: (plane:Plane2d * line:Line2d * absoluteEpsilon:float * point:byref<V2d>) -> bool	Returns true if the Plane2d and the Line2d intersect or the Line2d lies completely in the Plane's Epsilon-Range point holds the Intersection-Point. If the Line2d is inside Epsilon point holds the centroid of the Line2d If no Intersection is found point is V2d.NaN ATTENTION: Works only with Normalized Plane2ds
`Intersects(plane, ray)` Signature: (plane:Plane2d * ray:Ray2d) -> bool	Returns true if the Plane2d and the Ray2d intersect
`Intersects(plane, ray, point)` Signature: (plane:Plane2d * ray:Ray2d * point:byref<V2d>) -> bool	Returns true if the Plane2d and the Ray2d intersect point holds the Intersection-Point if an intersection is found (else V2d.NaN) ATTENTION: Works only with Normalized Plane2ds
`Intersects(p0, p1)` Signature: (p0:Plane2d * p1:Plane2d) -> bool	Returns true if the two Plane2ds intersect
`Intersects(p0, p1, point)` Signature: (p0:Plane2d * p1:Plane2d * point:byref<V2d>) -> bool	Returns true if the two Plane2ds intersect point holds the Intersection-Point if an Intersection is found (else V2d.NaN)
`Intersects(triangle, line)` Signature: (triangle:Triangle2d * line:Line2d) -> bool	Returns true if the triangle and the line intersect or the triangle contains the line
`Intersects(triangle, ray)` Signature: (triangle:Triangle2d * ray:Ray2d) -> bool	Returns true if the Triangle and the Ray intersect
`Intersects(triangle, plane)` Signature: (triangle:Triangle2d * plane:Plane2d) -> bool	returns true if the Triangle2d and the Plane2d intersect
`Intersects(t0, t1)` Signature: (t0:Triangle2d * t1:Triangle2d) -> bool	Returns true if the Triangles intersect or one contains the other
`Intersects(box, line)` Signature: (box:Box2d * line:Line2d) -> bool	Returns true if the box and the line intersect.
`Intersects(box, line, out0, out1)` Signature: (box:Box2d * line:Line2d * out0:Flags * out1:Flags) -> bool	Returns true if the box and the line intersect. The outside flags of the end points of the line with respect to the box have to be supplied as parameters.
`Intersects(box, ray)` Signature: (box:Box2d * ray:Ray2d) -> bool	Returns true if the box and the ray intersect
`Intersects(box, plane)` Signature: (box:Box2d * plane:Plane2d) -> bool	returns true if the box and the plane intersect
`Intersects(box, plane, line)` Signature: (box:Box2d * plane:Plane2d * line:byref<Line2d>) -> bool	NOT TESTED YET.
`Intersects(...)` Signature: (nx:float * ny:float * d:float * xmin:float * ymin:float * xmax:float * ymax:float * line:byref<Line2d>) -> bool	Intersects an infinite line given by its normal vector [nx, ny] and its distance to the origin d, with an axis aligned box given by it minimal point [xmin, ymin] and its maximal point [xmax, ymax]. Returns true if there is an intersection and computes the actual intersection line. NOT TESTED YET.
`Intersects(box, triangle)` Signature: (box:Box2d * triangle:Triangle2d) -> bool	Returns true if the Box and the Triagle intersect
`Intersects(quad, line)` Signature: (quad:Quad2d * line:Line2d) -> bool	returns true if the Quad and the line intersect or the quad contains the line
`Intersects(quad, ray)` Signature: (quad:Quad2d * ray:Ray2d) -> bool	returns true if the quad and the ray intersect
`Intersects(quad, plane)` Signature: (quad:Quad2d * plane:Plane2d) -> bool	returns true if the Quad2d and the Plane2d intersect
`Intersects(quad, triangle)` Signature: (quad:Quad2d * triangle:Triangle2d) -> bool	returns true if the Quad2d and the Triangle2d intersect or one contains the other
`Intersects(box, quad)` Signature: (box:Box2d * quad:Quad2d) -> bool	Returns true if the box and the Quad intersect or one contains the other
`Intersects(q0, quad)` Signature: (q0:Quad2d * quad:Quad2d) -> bool	returns true if the Quad2ds intersect or one contains the other
`Intersects(poly, line)` Signature: (poly:Polygon2d * line:Line2d) -> bool	returns true if the Polygon2d and the Line2d intersect or the Polygon contains the Line
`Intersects(poly, ray)` Signature: (poly:Polygon2d * ray:Ray2d) -> bool	returns true if the Polygon2d and the Ray2d intersect
`Intersects(poly, plane)` Signature: (poly:Polygon2d * plane:Plane2d) -> bool	returns true if the Polygon2d and the Plane2d itnersect
`Intersects(poly, triangle)` Signature: (poly:Polygon2d * triangle:Triangle2d) -> bool	returns true if the Polygon2d and the Triangle2d intersect or one contains the other
`Intersects(poly, box)` Signature: (poly:Polygon2d * box:Box2d) -> bool	returns true if the Polygon2d and the Box2d intersect or one contains the other
`Intersects(poly, quad)` Signature: (poly:Polygon2d * quad:Quad2d) -> bool	returns true if the Polygon2d and the Quad2d interset or one contains the other
`Intersects(poly0, poly1)` Signature: (poly0:Polygon2d * poly1:Polygon2d) -> bool	returns true if the Polygon2ds intersect or one contains the other
`Intersects(l0, l1)` Signature: (l0:Line3d * l1:Line3d) -> bool	Returns true if the minimal distance between the given lines is smaller than Constant.PositiveTinyValue.
`Intersects(l0, l1, absoluteEpsilon)` Signature: (l0:Line3d * l1:Line3d * absoluteEpsilon:float) -> bool	Returns true if the minimal distance between the given lines is smaller than absoluteEpsilon.
`Intersects(...)` Signature: (l0:Line3d * l1:Line3d * absoluteEpsilon:float * point:byref<V3d>) -> bool	Returns true if the minimal distance between the given lines is smaller than absoluteEpsilon.
`Intersects(line, plane, t)` Signature: (line:Line3d * plane:Plane3d * t:byref<float>) -> bool	Returns true if the line and the plane intersect.
`Intersects(line, plane, t, p)` Signature: (line:Line3d * plane:Plane3d * t:byref<float> * p:byref<V3d>) -> bool	Returns true if the line and the plane intersect.
`Intersects(line, triangle)` Signature: (line:Line3d * triangle:Triangle3d) -> bool	Returns true if the line and the triangle intersect.
`Intersects(line, triangle, point)` Signature: (line:Line3d * triangle:Triangle3d * point:byref<V3d>) -> bool	Returns true if the line and the triangle intersect. point holds the intersection point.
`Intersects(ray, line)` Signature: (ray:Ray3d * line:Line3d) -> bool	Returns true if the minimal distance between the line and the ray is smaller than Constant.PositiveTinyValue
`Intersects(ray, line, absoluteEpsilon)` Signature: (ray:Ray3d * line:Line3d * absoluteEpsilon:float) -> bool	Returns true if the minimal distance between the line and the ray is smaller than absoluteEpsilon
`Intersects(...)` Signature: (ray:Ray3d * line:Line3d * absoluteEpsilon:float * t:byref<float>) -> bool	Returns true if the minimal distance between the line and the ray is smaller than absoluteEpsilon t holds the corresponding ray parameter
`Intersects(r0, r1)` Signature: (r0:Ray3d * r1:Ray3d) -> bool	returns true if the minimal distance between the rays is smaller than Constant.PositiveTinyValue
`Intersects(r0, r1, t0, t1)` Signature: (r0:Ray3d * r1:Ray3d * t0:byref<float> * t1:byref<float>) -> bool	returns true if the minimal distance between the rays is smaller than Constant.PositiveTinyValue t0 and t1 hold the ray-parameters for the intersection
`Intersects(r0, r1, absoluteEpsilon)` Signature: (r0:Ray3d * r1:Ray3d * absoluteEpsilon:float) -> bool	returns true if the minimal distance between the rays is smaller than absoluteEpsilon
`Intersects(...)` Signature: (r0:Ray3d * r1:Ray3d * t0:byref<float> * t1:byref<float> * absoluteEpsilon:float) -> bool	returns true if the minimal distance between the rays is smaller than absoluteEpsilon t0 and t1 hold the ray-parameters for the intersection
`Intersects(ray, triangle)` Signature: (ray:Ray3d * triangle:Triangle3d) -> bool	Returns true if the ray and the triangle intersect. If you need information about the hit point see the Ray3d.Hits method.
`Intersects(ray, triangle, tmin, tmax)` Signature: (ray:Ray3d * triangle:Triangle3d * tmin:float * tmax:float) -> bool	Returns true if the ray and the triangle intersect within the supplied parameter interval of the ray. If you need information about the hit point see the Ray3d.Hits method.
`Intersects(ray, triangle, tmin, tmax, t)` Signature: (ray:Ray3d * triangle:Triangle3d * tmin:float * tmax:float * t:byref<float>) -> bool	Returns true if the ray and the triangle intersect within the supplied parameter interval of the ray. If you need information about the hit point see the Ray3d.Hits method. t holds the corresponding ray-parameter
`Intersects(ray, quad)` Signature: (ray:Ray3d * quad:Quad3d) -> bool	Returns true if the ray and the triangle intersect. If you need information about the hit point see the Ray3d.Hits method.
`Intersects(ray, quad, tmin, tmax)` Signature: (ray:Ray3d * quad:Quad3d * tmin:float * tmax:float) -> bool	Returns true if the ray and the quad intersect within the supplied parameter interval of the ray. If you need information about the hit point see the Ray3d.Hits method.
`Intersects(ray, poly, tmin, tmax)` Signature: (ray:Ray3d * poly:Polygon3d * tmin:float * tmax:float) -> bool	Returns true if the ray and the polygon intersect within the supplied parameter interval of the ray.
`Intersects(ray, poly, tmin, tmax, t)` Signature: (ray:Ray3d * poly:Polygon3d * tmin:float * tmax:float * t:byref<float>) -> bool	Returns true if the ray and the polygon intersect within the supplied parameter interval of the ray. t holds the correspoinding paramter.
`Intersects(...)` Signature: (ray:Ray3d * polygon:Polygon3d * triangulation:int [] * tmin:float * tmax:float) -> bool	Returns true if the ray and the polygon, which is given by vertices and triangulation, intersect within the supplied parameter interval of the ray.
`Intersects(ray, sphere)` Signature: (ray:Ray3d * sphere:Sphere3d) -> bool	Returns true if the ray and the triangle intersect. If you need information about the hit point see the Ray3d.Hits method.
`Intersects(ray, sphere, tmin, tmax)` Signature: (ray:Ray3d * sphere:Sphere3d * tmin:float * tmax:float) -> bool	Returns true if the ray and the triangle intersect within the supplied parameter interval of the ray. If you need information about the hit point see the Ray3d.Hits method.
`Intersects(sphere, triangle)` Signature: (sphere:Sphere3d * triangle:Triangle3d) -> bool
`Intersects(tri, line)` Signature: (tri:Triangle3d * line:Line3d) -> bool	Returns true if the triangle and the line intersect.
`Intersects(tri, line, point)` Signature: (tri:Triangle3d * line:Line3d * point:byref<V3d>) -> bool	Returns true if the triangle and the line intersect. point holds the intersection point.
`Intersects(tri, ray)` Signature: (tri:Triangle3d * ray:Ray3d) -> bool	Returns true if the triangle and the ray intersect.
`Intersects(tri, ray, tmin, tmax)` Signature: (tri:Triangle3d * ray:Ray3d * tmin:float * tmax:float) -> bool	Returns true if the triangle and the ray intersect within the given parameter interval
`Intersects(tri, ray, t)` Signature: (tri:Triangle3d * ray:Ray3d * t:byref<float>) -> bool	Returns true if the triangle and the ray intersect. t holds the intersection paramter.
`Intersects(tri, ray, tmin, tmax, t)` Signature: (tri:Triangle3d * ray:Ray3d * tmin:float * tmax:float * t:byref<float>) -> bool	Returns true if the triangle and the ray intersect within the given parameter interval t holds the intersection paramter.
`Intersects(t0, t1)` Signature: (t0:Triangle3d * t1:Triangle3d) -> bool	Returns true if the triangles intersect.
`Intersects(t0, t1, line)` Signature: (t0:Triangle3d * t1:Triangle3d * line:byref<Line3d>) -> bool	Returns true if the triangles intersect. line holds the cutting-line of the two triangles.
`Intersects(quad, line)` Signature: (quad:Quad3d * line:Line3d) -> bool	Returns true if the quad and the line, given by p0 and p1, intersect.
`Intersects(quad, line, point)` Signature: (quad:Quad3d * line:Line3d * point:byref<V3d>) -> bool	Returns true if the quad and the line, given by p0 and p1, intersect. point holds the intersection point.
`Intersects(quad, ray)` Signature: (quad:Quad3d * ray:Ray3d) -> bool	Returns true if the quad and the ray intersect.
`Intersects(quad, ray, t)` Signature: (quad:Quad3d * ray:Ray3d * t:byref<float>) -> bool	Returns true if the quad and the ray intersect. t holds the intersection parameter.
`Intersects(quad, ray, tmin, tmax)` Signature: (quad:Quad3d * ray:Ray3d * tmin:float * tmax:float) -> bool	Returns true if the quad and the ray intersect within the given paramter range
`Intersects(quad, ray, tmin, tmax, t)` Signature: (quad:Quad3d * ray:Ray3d * tmin:float * tmax:float * t:byref<float>) -> bool	Returns true if the quad and the ray intersect within the given paramter range t holds the intersection parameter.
`Intersects(quad, tri)` Signature: (quad:Quad3d * tri:Triangle3d) -> bool	Returns true if the quad and the triangle intersect.
`Intersects(q0, q1)` Signature: (q0:Quad3d * q1:Quad3d) -> bool	Returns true if the given quads intersect.
`Intersects(plane, line)` Signature: (plane:Plane3d * line:Line3d) -> bool
`Intersects(plane, line, absoluteEpsilon)` Signature: (plane:Plane3d * line:Line3d * absoluteEpsilon:float) -> bool
`Intersects(ray, plane, t)` Signature: (ray:Ray3d * plane:Plane3d * t:byref<float>) -> bool	Returns true if the ray and the plane intersect.
`Intersects(ray, plane, t, p)` Signature: (ray:Ray3d * plane:Plane3d * t:byref<float> * p:byref<V3d>) -> bool	Returns true if the ray and the plane intersect.
`Intersects(p0, p1)` Signature: (p0:Plane3d * p1:Plane3d) -> bool
`Intersects(p0, p1, ray)` Signature: (p0:Plane3d * p1:Plane3d * ray:byref<Ray3d>) -> bool
`Intersects(p0, p1, p2, point)` Signature: (p0:Plane3d * p1:Plane3d * p2:Plane3d * point:byref<V3d>) -> bool
`Intersects(plane, triangle)` Signature: (plane:Plane3d * triangle:Triangle3d) -> bool	Returns whether the given plane and triangle intersect.
`Intersects(plane, sphere)` Signature: (plane:Plane3d * sphere:Sphere3d) -> bool	Returns whether the given sphere and plane intersect.
`Intersects(plane, poly)` Signature: (plane:Plane3d * poly:Polygon3d) -> bool	returns true if the Plane3d and the Polygon3d intersect
`Intersects(...)` Signature: (plane:Plane3d * polygon:Polygon3d * absoluteEpsilon:float) -> bool	returns true if the Plane3d and the polygon, intersect within a tolerance of absoluteEpsilon
`Intersects(plane, cylinder)` Signature: (plane:Plane3d * cylinder:Cylinder3d) -> bool	Returns whether the given sphere and cylinder intersect.
`Intersects(plane, cylinder, ellipse)` Signature: (plane:Plane3d * cylinder:Cylinder3d * ellipse:byref<Ellipse3d>) -> bool	Returns true if the given plane and cylinder intersect in an ellipse. This is only true if the plane is neither orthogonal nor parallel to the cylinder axis. Otherwise the intersection methods returning a circle or rays have to be used.
`Intersects(plane, cylinder, circle)` Signature: (plane:Plane3d * cylinder:Cylinder3d * circle:byref<Circle3d>) -> bool	Returns true if the given plane and cylinder intersect in a circle. This is only true if the plane is orthogonal to the cylinder axis. Otherwise the intersection methods returning an ellipse or rays have to be used.
`Intersects(plane, cylinder, rays)` Signature: (plane:Plane3d * cylinder:Cylinder3d * rays:byref<Ray3d []>) -> bool	Returns true if the given plane and cylinder intersect in one or two rays. This is only true if the plane is parallel to the cylinder axis. Otherwise the intersection methods returning an ellipse or a circle have to be used.
`Intersects(box, line)` Signature: (box:Box3d * line:Line3d) -> bool	Returns true if the box and the line intersect.
`Intersects(box, ray, t)` Signature: (box:Box3d * ray:Ray3d * t:byref<float>) -> bool
`Intersects(box, plane, eps)` Signature: (box:Box3d * plane:Plane3d * eps:float) -> bool	Returns true if the box and the plane intersect or touch with a supplied epsilon tolerance.
`Intersects(box, sphere)` Signature: (box:Box3d * sphere:Sphere3d) -> bool
`Intersects(box, cylinder)` Signature: (box:Box3d * cylinder:Cylinder3d) -> bool
`Intersects(box, triangle)` Signature: (box:Box3d * triangle:Triangle3d) -> bool	Returns true if the box and the triangle intersect.
`Intersects(box, quad)` Signature: (box:Box3d * quad:Quad3d) -> bool
`Intersects(box, poly)` Signature: (box:Box3d * poly:Polygon3d) -> bool
`Intersects(hull, line)` Signature: (hull:Hull3d * line:Line3d) -> bool	returns true if the Hull3d and the Line3d intersect or the Hull3d contains the Line3d [Hull3d-Normals must point outside]
`Intersects(hull, ray)` Signature: (hull:Hull3d * ray:Ray3d) -> bool	returns true if the Hull3d and the Ray3d intersect [Hull3d-Normals must point outside]
`Intersects(hull, ray, t)` Signature: (hull:Hull3d * ray:Ray3d * t:byref<float>) -> bool	returns true if the Hull3d and the Ray3d intersect the out parameter t holds the ray-parameter where an intersection was found [Hull3d-Normals must point outside]
`Intersects(hull, ray, t_min, t_max, t)` Signature: (hull:Hull3d * ray:Ray3d * t_min:float * t_max:float * t:byref<float>) -> bool	returns true if the Hull3d and the Ray3d intersect and the ray-parameter for the intersection is between tmin and tmax the out parameter t holds the ray-parameter where an intersection was found [Hull3d-Normals must point outside]
`Intersects(hull, plane)` Signature: (hull:Hull3d * plane:Plane3d) -> bool	returns true if the Hull3d and the Plane3d intersect [Hull3d-Normals must point outside]
`Intersects(hull, box)` Signature: (hull:Hull3d * box:Box3d) -> bool	Returns true if the hull and the box intersect.
`Intersects(fastHull, box)` Signature: (fastHull:FastHull3d * box:Box3d) -> bool	Test hull against intersection of the supplied bounding box. Note that this is a conservative test, since in some cases around the edges of the hull it may return true although the hull does not intersect the box.
`Intersects(hull, sphere)` Signature: (hull:Hull3d * sphere:Sphere3d) -> bool	Returns true if the hull and the sphere intersect.
`IntersectsConvex(plane, poly, line)` Signature: (plane:Plane3d * poly:Polygon3d * line:byref<Line3d>) -> bool	returns true if the Plane3d and the Polygon3d intersect. line holds the intersection line ATTENTION: works only with non-concave polygons!
`IntersectsConvex(...)` Signature: (plane:Plane3d * polygon:Polygon3d * absoluteEpsilon:float * line:byref<Line3d>) -> bool	Returns true if the Plane3d and the polygon, given by points, intersect within a tolerance of absoluteEpsilon. Line holds the intersection line. ATTENTION: works only with non-concave polygons!
`IntersectsFrustum(box, projection)` Signature: (box:Box3d * projection:M44d) -> bool	returns true if the Box3d and the frustum described by the M44d intersect or the frustum contains the Box3d Assumes DirectX clip-space: -w < x < w -w < y < w 0 < z < w
`IntersectsLine(line, p0, p1)` Signature: (line:Line2d * p0:V2d * p1:V2d) -> bool	Returns true if the Line intersects the Line between p0 and p1 If the lines overlap and are parallel there is no intersection returned
`IntersectsLine(line, p0, p1, point)` Signature: (line:Line2d * p0:V2d * p1:V2d * point:byref<V2d>) -> bool	Returns true if the Line intersects the Line between p0 and p1 point holds the Intersection Point If the lines overlap and are parallel there is no intersection returned
`IntersectsLine(...)` Signature: (line:Line2d * p0:V2d * p1:V2d * overlapping:bool * point:byref<V2d>) -> bool	Returns true if the Line intersects the Line between p0 and p1 point holds the Intersection Point If the Overlapping-flag is true, the given Lines are parallel and intersect, point holds the Closest Point to p0 of the Intersection-Range
`IntersectsLine(...)` Signature: (line:Line2d * p0:V2d * p1:V2d * absoluteEpsilon:float * point:byref<V2d>) -> bool	Returns true if the Line intersects the Line between p0 and p1 with an absolute Tolerance point holds the Intersection Point If the lines overlap and are parallel there is no intersection returned
`IntersectsLine(...)` Signature: (line:Line2d * p0:V2d * p1:V2d * absoluteEpsilon:float * overlapping:bool * point:byref<V2d>) -> bool	Returns true if the Line intersects the Line between p0 and p1 with an absolute Tolerance point holds the Intersection Point If the Overlapping-flag is true, the given Lines are parallel and intersect, point holds the Closest Point to p0 of the Intersection-Range
`IntersectsLine(ray, p0, p1)` Signature: (ray:Ray2d * p0:V2d * p1:V2d) -> bool	returns true if the Ray and the Line(p0,p1) intersect. ATTENTION: Both-Sided Ray
`IntersectsLine(ray, p0, p1, t)` Signature: (ray:Ray2d * p0:V2d * p1:V2d * t:byref<float>) -> bool	returns true if the Ray and the Line(p0,p1) intersect. t holds the Intersection-Parameter for the Ray If both Line-Points are on the Ray no Intersection is returned ATTENTION: t can be negative
`IntersectsLine(...)` Signature: (ray:Ray2d * p0:V2d * p1:V2d * overlapping:bool * t:byref<float>) -> bool	returns true if the Ray and the Line(p0,p1) intersect. if overlapping is true t holds the smallest Intersection-Parameter for the Ray if overlagging is false and both Line-Points are on the Ray no Intersection is returned ATTENTION: t can be negative
`IntersectsLine(plane, p0, p1)` Signature: (plane:Plane2d * p0:V2d * p1:V2d) -> bool	Returns true if the Plane2d and the line between p0 and p1 intersect ATTENTION: Works only with Normalized Plane2ds
`IntersectsLine(triangle, p0, p1)` Signature: (triangle:Triangle2d * p0:V2d * p1:V2d) -> bool	Returns true if the triangle and the line between p0 and p1 intersect or the triangle contains the line
`IntersectsLine(quad, p0, p1)` Signature: (quad:Quad2d * p0:V2d * p1:V2d) -> bool	returns true if the Quad and the line between p0 and p1 intersect or the quad contains the line
`IntersectsLine(tri, p0, p1)` Signature: (tri:Triangle3d * p0:V3d * p1:V3d) -> bool	returns true if the triangle and the line, given by p0 and p1, intersect.
`IntersectsLine(tri, p0, p1, point)` Signature: (tri:Triangle3d * p0:V3d * p1:V3d * point:byref<V3d>) -> bool	returns true if the triangle and the line, given by p0 and p1, intersect. point holds the intersection point.
`IntersectsLine(quad, p0, p1)` Signature: (quad:Quad3d * p0:V3d * p1:V3d) -> bool	Returns true if the quad and the line, given by p0 and p1, intersect.
`IntersectsLine(quad, p0, p1, point)` Signature: (quad:Quad3d * p0:V3d * p1:V3d * point:byref<V3d>) -> bool	Returns true if the quad and the line, given by p0 and p1, intersect. point holds the intersection point.
`IntersectsLine(...)` Signature: (plane:Plane3d * p0:V3d * p1:V3d * absoluteEpsilon:float) -> bool
`IntersectsLine(...)` Signature: (plane:Plane3d * p0:V3d * p1:V3d * absoluteEpsilon:float * point:byref<V3d>) -> bool
`IntersectsLine(box, p0, p1)` Signature: (box:Box3d * p0:V3d * p1:V3d) -> bool	Returns true if the box and the line intersect.
`IntersectsLine(box, p0, p1, out0, out1)` Signature: (box:Box3d * p0:V3d * p1:V3d * out0:Flags * out1:Flags) -> bool	Returns true if the box and the line intersect. The outside flags of the end points of the line with respect to the box have to be supplied, and have to be already individually tested against intersection with the box.
`IntersectsLine(hull, p0, p1)` Signature: (hull:Hull3d * p0:V3d * p1:V3d) -> bool	returns true if the Hull3d and the Line between p0 and p1 intersect or the Hull3d contains the Line [Hull3d-Normals must point outside]
`IntersectsPolygon(...)` Signature: (ray:Ray3d * vertices:V3d [] * tmin:float * tmax:float) -> bool	Returns true if the ray and the polygon, which is given by vertices, intersect within the supplied parameter interval of the ray. (The Method triangulates the polygon)
`IntersectsPolygon(...)` Signature: (ray:Ray3d * vertices:V3d [] * triangulation:int [] * tmin:float * tmax:float) -> bool	Returns true if the ray and the polygon, which is given by vertices and triangulation, intersect within the supplied parameter interval of the ray.
`IntersectsQuad(...)` Signature: (ray:Ray3d * p0:V3d * p1:V3d * p2:V3d * p3:V3d * tmin:float * tmax:float) -> bool	Returns true if the ray and the quad intersect within the supplied parameter interval of the ray. If you need information about the hit point see the Ray3d.Hits method.
`IntersectsQuad(box, p0, p1, p2, p3)` Signature: (box:Box3d * p0:V3d * p1:V3d * p2:V3d * p3:V3d) -> bool
`IntersectsQuad(...)` Signature: (box:Box3d * p0:V3d * p1:V3d * p2:V3d * p3:V3d * out0:Flags * out1:Flags * out2:Flags * out3:Flags) -> bool
`IntersectsTriangle(box, p0, p1, p2)` Signature: (box:Box2d * p0:V2d * p1:V2d * p2:V2d) -> bool	Returns true if the Box and the Triagle intersect
`IntersectsTriangle(...)` Signature: (ray:Ray3d * p0:V3d * p1:V3d * p2:V3d * tmin:float * tmax:float) -> bool	Returns true if the ray and the triangle intersect within the supplied parameter interval of the ray. If you need information about the hit point see the Ray3d.Hits method.
`IntersectsTriangle(...)` Signature: (ray:Ray3d * p0:V3d * p1:V3d * p2:V3d * tmin:float * tmax:float * t:byref<float>) -> bool	Returns true if the ray and the triangle intersect within the supplied parameter interval of the ray. If you need information about the hit point see the Ray3d.Hits method. t holds the corresponding ray-parameter
`IntersectsTriangle(quad, p0, p1, p2)` Signature: (quad:Quad3d * p0:V3d * p1:V3d * p2:V3d) -> bool	Returns true if the quad and the triangle, given by p0/p1/p1, intersect.
`IntersectsTriangle(box, p0, p1, p2)` Signature: (box:Box3d * p0:V3d * p1:V3d * p2:V3d) -> bool	Returns true if the box and the triangle intersect.
`IntersectsTriangle(...)` Signature: (box:Box3d * p0:V3d * p1:V3d * p2:V3d * out0:Flags * out1:Flags * out2:Flags) -> bool	Returns true if the box and the triangle intersect. The outside flags of the triangle vertices with respect to the box have to be supplied, and already be individually tested for intersection with the box.
`IntersectsTrianglePointAndEdges(...)` Signature: (ray:Ray3d * p0:V3d * edge01:V3d * edge02:V3d * tmin:float * tmax:float) -> bool	Returns true if the ray and the triangle intersect within the supplied parameter interval of the ray. If you need information about the hit point see the Ray3d.Hits method.
`IntersectsTrianglePointAndEdges(...)` Signature: (ray:Ray3d * p0:V3d * edge01:V3d * edge02:V3d * tmin:float * tmax:float * t:byref<float>) -> bool	Returns true if the ray and the triangle intersect within the supplied parameter interval of the ray. If you need information about the hit point see the Ray3d.Hits method. t holds the corresponding ray-parameter
`IsOrthogonalToAxis(plane, cylinder)` Signature: (plane:Plane3d * cylinder:Cylinder3d) -> bool	Tests if the given plane is orthogonal to the cylinder axis (i.e. the plane's normal is parallel to the axis). The plane will intersect the cylinder in a circle.
`IsParallelToAxis(plane, cylinder)` Signature: (plane:Plane3d * cylinder:Cylinder3d) -> bool	Tests if the given plane is parallel to the cylinder axis (i.e. the plane's normal is orthogonal to the axis). The plane will intersect the cylinder in two rays or in one tangent line.
`Simplify(polyline, epsilon)` Signature: (polyline:V2d [] * epsilon:float) -> int []	Returns those indices of the supplied polyline that constitute the simplified polyline. A larger epsilon results in a simpler polyline. Implemented via the Ramer–Douglas–Peucker algorithm. http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm
`Triangulate(xSortedPoints)` Signature: (xSortedPoints:V2d []) -> int []	Compute the Delaunay triangulation of the supplied x-sorted point array and return a triangle index array with counter-clockwise triangles.
`TriangulateXY(xSortedPoints)` Signature: (xSortedPoints:V3d []) -> int []	Compute the Delaunay triangulation of the supplied x-sorted point array in the XY-plane and return a triangle index array with counter-clockwise triangles.
`Union(p)` Signature: p:List<Polygon2d> -> IEnumerable<Polygon2d>
`Union(p0, p1)` Signature: (p0:Polygon2d * p1:Polygon2d) -> IEnumerable<Polygon2d>	Returns the unified Polygon of the two given ones. Works only with convex-Polygons Returns an empty Polygon if the two do not intersect
`Union(b0, b1)` Signature: (b0:Box2d * b1:Box2d) -> IEnumerable<Polygon2d>

Aardvark.Base

GeometryFun

Static members