XLine2D (Euclid)

XLine2D Type

Namespace: Euclid
Assembly: Euclid.dll
Base Type: obj

A type containing only static member functions for computing 2D line intersections. Some functions return Discriminated Unions from the XLine2D module.

Static members

Static member	Description
`XLine2D.doIntersect (lineA, lineB)` Full Usage: `XLine2D.doIntersect (lineA, lineB)` Parameters: lineA : `Line2D` - First line. lineB : `Line2D` - Second line. Returns: `bool` True if both lines have an intersection parameter in the range 0.0 to 1.0 (with 1e-6 tolerance). False if the lines are parallel, coincident or at least one intersection parameter is outside of the range. Modifiers: inline	Checks if two 2D-lines intersect within the parameter range 0.0 to 1.0 (with 1e-6 tolerance) on both lines. This does not check for an explicit angle tolerance, so overlapping almost parallel lines may return true. lineA : `Line2D` First line. lineB : `Line2D` Second line. Returns: `bool` True if both lines have an intersection parameter in the range 0.0 to 1.0 (with 1e-6 tolerance). False if the lines are parallel, coincident or at least one intersection parameter is outside of the range.
`XLine2D.doIntersect (pA, pB, vA, vB)` Full Usage: `XLine2D.doIntersect (pA, pB, vA, vB)` Parameters: pA : `Pt` - The start point of the first line. pB : `Pt` - The start point of the second line. vA : `Vc` - The direction vector of the first line. vB : `Vc` - The direction vector of the second line. Returns: `bool` True if both lines have an intersection parameter in the range 0.0 to 1.0 (with 1e-6 tolerance). False if the lines are parallel, coincident or at least one intersection parameter is outside of the range. Modifiers: inline	Checks if two 2D-lines intersect within the parameter range 0.0 to 1.0 (with 1e-6 tolerance) on both lines. This does not check for an explicit angle tolerance, so overlapping almost parallel lines may return true. pA : `Pt` The start point of the first line. pB : `Pt` The start point of the second line. vA : `Vc` The direction vector of the first line. vB : `Vc` The direction vector of the second line. Returns: `bool` True if both lines have an intersection parameter in the range 0.0 to 1.0 (with 1e-6 tolerance). False if the lines are parallel, coincident or at least one intersection parameter is outside of the range.
`XLine2D.doIntersect (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy)` Full Usage: `XLine2D.doIntersect (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy)` Parameters: pAx : `float` - The X coordinate of the start point on the first line. pAy : `float` - The Y coordinate of the start point on the first line. pBx : `float` - The X coordinate of the start point on the second line. pBy : `float` - The Y coordinate of the start point on the second line. vAx : `float` - The X component of the vector of the first line. vAy : `float` - The Y component of the vector of the first line. vBx : `float` - The X component of the vector of the second line. vBy : `float` - The Y component of the vector of the second line. Returns: `bool` True if both lines have an intersection parameter in the range 0.0 to 1.0 (with 1e-6 tolerance). False if the lines are parallel, coincident or at least one intersection parameter is outside of the range. Modifiers: inline	Checks if two 2D-lines intersect within the parameter range 0.0 to 1.0 (with 1e-6 tolerance) on both lines. This does not check for an explicit angle tolerance, so overlapping almost parallel lines may return true. pAx : `float` The X coordinate of the start point on the first line. pAy : `float` The Y coordinate of the start point on the first line. pBx : `float` The X coordinate of the start point on the second line. pBy : `float` The Y coordinate of the start point on the second line. vAx : `float` The X component of the vector of the first line. vAy : `float` The Y component of the vector of the first line. vBx : `float` The X component of the vector of the second line. vBy : `float` The Y component of the vector of the second line. Returns: `bool` True if both lines have an intersection parameter in the range 0.0 to 1.0 (with 1e-6 tolerance). False if the lines are parallel, coincident or at least one intersection parameter is outside of the range.
`XLine2D.doOverlap (lineA, lineB, ?tolerance)` Full Usage: `XLine2D.doOverlap (lineA, lineB, ?tolerance)` Parameters: lineA : `Line2D` - The first line. lineB : `Line2D` - The second line. ?tolerance : `float` - Is an optional squared distance tolerance. 1e-6 by default. Used for checking if the distance between parallel lines is less than this value. Returns: `bool` Modifiers: inline	Checks if 2D lines are not only parallel and coincident but are also overlapping or at least touching at their ends. lineA : `Line2D` The first line. lineB : `Line2D` The second line. ?tolerance : `float` Is an optional squared distance tolerance. 1e-6 by default. Used for checking if the distance between parallel lines is less than this value. Returns: `bool`
`XLine2D.doOverlap (pA, pB, vA, vB, ?tolerance)` Full Usage: `XLine2D.doOverlap (pA, pB, vA, vB, ?tolerance)` Parameters: pA : `Pt` - The start point on the first line. pB : `Pt` - The start point on the second line. vA : `Vc` - The direction vector of the first line. vB : `Vc` - The direction vector of the second line. ?tolerance : `float` - Is an optional squared distance tolerance. 1e-6 by default. Used for checking if the distance between parallel lines is less than this value. Returns: `bool` Modifiers: inline	Checks if 2D lines are not only parallel and coincident but are also overlapping or at least touching at their ends. pA : `Pt` The start point on the first line. pB : `Pt` The start point on the second line. vA : `Vc` The direction vector of the first line. vB : `Vc` The direction vector of the second line. ?tolerance : `float` Is an optional squared distance tolerance. 1e-6 by default. Used for checking if the distance between parallel lines is less than this value. Returns: `bool`
`XLine2D.doOverlap (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tolerance)` Full Usage: `XLine2D.doOverlap (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tolerance)` Parameters: pAx : `float` - The X coordinate of the start point on the first line. pAy : `float` - The Y coordinate of the start point on the first line. pBx : `float` - The X coordinate of the start point on the second line. pBy : `float` - The Y coordinate of the start point on the second line. vAx : `float` - The X component of the vector of the first line. vAy : `float` - The Y component of the vector of the first line. vBx : `float` - The X component of the vector of the second line. vBy : `float` - The Y component of the vector of the second line. ?tolerance : `float` - Is an optional squared distance tolerance. 1e-6 by default. Used for checking if the distance between parallel lines is less than this value. Returns: `bool` TRUE if the lines are coincident and overlap or touch. FALSE if the lines are not coincident or do not overlap nor touch.	Checks if 2D lines are not only parallel and coincident but are also overlapping or at least touching at their ends. pAx : `float` The X coordinate of the start point on the first line. pAy : `float` The Y coordinate of the start point on the first line. pBx : `float` The X coordinate of the start point on the second line. pBy : `float` The Y coordinate of the start point on the second line. vAx : `float` The X component of the vector of the first line. vAy : `float` The Y component of the vector of the first line. vBx : `float` The X component of the vector of the second line. vBy : `float` The Y component of the vector of the second line. ?tolerance : `float` Is an optional squared distance tolerance. 1e-6 by default. Used for checking if the distance between parallel lines is less than this value. Returns: `bool` TRUE if the lines are coincident and overlap or touch. FALSE if the lines are not coincident or do not overlap nor touch.
`XLine2D.getClosestParameters (lineA, lineB, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getClosestParameters (lineA, lineB, ?tangent, ?tooShortTolerance)` Parameters: lineA : `Line2D` - The first finite line segment. lineB : `Line2D` - The second finite line segment. ?tangent : `MeasureProduct<tangent, MeasureOne>` - This is an optional tolerance for considering lines parallel. This is a precomputed tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this the middle point of any overlapping segment is returned. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then a 'TooShort' union case is returned. Returns: `ClParams` An ClParams Discriminated Union with the following cases: \| Intersect of floatfloat \| Apart of parameterA:float parameterB:float * squareDistance:float \| Parallel of float*float \| TooShortA \| TooShortB \| TooShortBoth Modifiers: inline	Gets the parameters on the finite lines where the lines are closest to each other. For parallel or coincident lines, this returns the midpoint of the interval spanned by the projected endpoints (which coincides with the middle of any overlapping segment when one exists). lineA : `Line2D` The first finite line segment. lineB : `Line2D` The second finite line segment. ?tangent : `MeasureProduct<tangent, MeasureOne>` This is an optional tolerance for considering lines parallel. This is a precomputed tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this the middle point of any overlapping segment is returned. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then a 'TooShort' union case is returned. Returns: `ClParams` An ClParams Discriminated Union with the following cases: \| Intersect of floatfloat \| Apart of parameterA:float parameterB:float * squareDistance:float \| Parallel of float*float \| TooShortA \| TooShortB \| TooShortBoth
`XLine2D.getClosestParameters (pA, pB, vA, vB, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getClosestParameters (pA, pB, vA, vB, ?tangent, ?tooShortTolerance)` Parameters: pA : `Pt` - The start point on the first line. pB : `Pt` - The start point on the second line. vA : `Vc` - The direction vector of the first line. vB : `Vc` - The direction vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` - This is an optional tolerance for considering lines parallel. This is a precomputed tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this the middle point of any overlapping segment is returned. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then a 'TooShort' union case is returned. Returns: `ClParams` An ClParams Discriminated Union with the following cases: \| Intersect of floatfloat \| Apart of parameterA:float parameterB:float * squareDistance:float \| Parallel of float*float \| TooShortA \| TooShortB \| TooShortBoth Modifiers: inline	Gets the parameters on the finite lines where the lines are closest to each other. For parallel or coincident lines, this returns the midpoint of the interval spanned by the projected endpoints (which coincides with the middle of any overlapping segment when one exists). pA : `Pt` The start point on the first line. pB : `Pt` The start point on the second line. vA : `Vc` The direction vector of the first line. vB : `Vc` The direction vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` This is an optional tolerance for considering lines parallel. This is a precomputed tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this the middle point of any overlapping segment is returned. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then a 'TooShort' union case is returned. Returns: `ClParams` An ClParams Discriminated Union with the following cases: \| Intersect of floatfloat \| Apart of parameterA:float parameterB:float * squareDistance:float \| Parallel of float*float \| TooShortA \| TooShortB \| TooShortBoth
`XLine2D.getClosestParameters (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getClosestParameters (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tangent, ?tooShortTolerance)` Parameters: pAx : `float` - The X coordinate of the start point on the first line. pAy : `float` - The Y coordinate of the start point on the first line. pBx : `float` - The X coordinate of the start point on the second line. pBy : `float` - The Y coordinate of the start point on the second line. vAx : `float` - The X component of the vector of the first line. vAy : `float` - The Y component of the vector of the first line. vBx : `float` - The X component of the vector of the second line. vBy : `float` - The Y component of the vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` - This is an optional tolerance for considering lines parallel. This is a precomputed tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this the middle point of any overlapping segment is returned. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then a 'TooShort' union case is returned. Returns: `ClParams` An ClParams Discriminated Union with the following cases: \| Intersect of floatfloat \| Apart of parameterA:float parameterB:float * squareDistance:float \| Parallel of float*float \| TooShortA \| TooShortB \| TooShortBoth	Gets the parameters on the finite lines where the lines are closest to each other. For parallel or coincident lines, this returns the midpoint of the interval spanned by the projected endpoints (which coincides with the middle of any overlapping segment when one exists). pAx : `float` The X coordinate of the start point on the first line. pAy : `float` The Y coordinate of the start point on the first line. pBx : `float` The X coordinate of the start point on the second line. pBy : `float` The Y coordinate of the start point on the second line. vAx : `float` The X component of the vector of the first line. vAy : `float` The Y component of the vector of the first line. vBx : `float` The X component of the vector of the second line. vBy : `float` The Y component of the vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` This is an optional tolerance for considering lines parallel. This is a precomputed tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this the middle point of any overlapping segment is returned. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then a 'TooShort' union case is returned. Returns: `ClParams` An ClParams Discriminated Union with the following cases: \| Intersect of floatfloat \| Apart of parameterA:float parameterB:float * squareDistance:float \| Parallel of float*float \| TooShortA \| TooShortB \| TooShortBoth
`XLine2D.getClosestPoints (lineA, lineB, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getClosestPoints (lineA, lineB, ?tangent, ?tooShortTolerance)` Parameters: lineA : `Line2D` - The first line. lineB : `Line2D` - The second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` - This is an optional tolerance for considering lines parallel. This is a precomputed tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this the middle point of any overlapping segment is returned. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `ClPts` An ClPts Discriminated Union with the following cases: \| Intersect of Pt \| Apart of Pt * Pt * squareDistance:float \| Parallel of Pt * Pt \| TooShortA \| TooShortB \| TooShortBoth Modifiers: inline	Gets the point or points on the finite lines where the lines are closest to each other. For parallel or coincident lines, this returns the midpoint of the interval spanned by the projected endpoints (matching the middle of the overlapping segment when one exists). This method uses a small tolerance of 1e-6 to account for numerical inaccuracies when checking the 0..1 range. lineA : `Line2D` The first line. lineB : `Line2D` The second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` This is an optional tolerance for considering lines parallel. This is a precomputed tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this the middle point of any overlapping segment is returned. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `ClPts` An ClPts Discriminated Union with the following cases: \| Intersect of Pt \| Apart of Pt * Pt * squareDistance:float \| Parallel of Pt * Pt \| TooShortA \| TooShortB \| TooShortBoth
`XLine2D.getClosestPoints (pA, pB, vA, vB, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getClosestPoints (pA, pB, vA, vB, ?tangent, ?tooShortTolerance)` Parameters: pA : `Pt` - The start point on the first line. pB : `Pt` - The start point on the second line. vA : `Vc` - The direction vector of the first line. vB : `Vc` - The direction vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` - This is an optional tolerance for considering lines parallel. This is a precomputed tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this the middle point of any overlapping segment is returned. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `ClPts` An ClPts Discriminated Union with the following cases: \| Intersect of Pt \| Apart of Pt * Pt * squareDistance:float \| Parallel of Pt * Pt \| TooShortA \| TooShortB \| TooShortBoth Modifiers: inline	Gets the point or points on the finite lines where the lines are closest to each other. For parallel or coincident lines, this returns the midpoint of the interval spanned by the projected endpoints (matching the middle of the overlapping segment when one exists). This method uses a small tolerance of 1e-6 to account for numerical inaccuracies when checking the 0..1 range. pA : `Pt` The start point on the first line. pB : `Pt` The start point on the second line. vA : `Vc` The direction vector of the first line. vB : `Vc` The direction vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` This is an optional tolerance for considering lines parallel. This is a precomputed tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this the middle point of any overlapping segment is returned. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `ClPts` An ClPts Discriminated Union with the following cases: \| Intersect of Pt \| Apart of Pt * Pt * squareDistance:float \| Parallel of Pt * Pt \| TooShortA \| TooShortB \| TooShortBoth
`XLine2D.getClosestPoints (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getClosestPoints (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tangent, ?tooShortTolerance)` Parameters: pAx : `float` - The X coordinate of the start point on the first line. pAy : `float` - The Y coordinate of the start point on the first line. pBx : `float` - The X coordinate of the start point on the second line. pBy : `float` - The Y coordinate of the start point on the second line. vAx : `float` - The X component of the vector of the first line. vAy : `float` - The Y component of the vector of the first line. vBx : `float` - The X component of the vector of the second line. vBy : `float` - The Y component of the vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` - This is an optional tolerance for considering lines parallel. This is a precomputed tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this the middle point of any overlapping segment is returned. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then a 'TooShort' union case is returned. Returns: `ClPts` An ClPts Discriminated Union with the following cases: \| Intersect of Pt \| Apart of Pt * Pt * squareDistance:float \| Parallel of Pt * Pt \| TooShortA \| TooShortB \| TooShortBoth	Gets the point or points on the finite lines where the lines are closest to each other. For parallel or coincident lines, this returns the midpoint of the interval spanned by the projected endpoints (matching the middle of the overlapping segment when one exists). This method uses a small tolerance of 1e-6 to account for numerical inaccuracies when checking the 0..1 range. pAx : `float` The X coordinate of the start point on the first line. pAy : `float` The Y coordinate of the start point on the first line. pBx : `float` The X coordinate of the start point on the second line. pBy : `float` The Y coordinate of the start point on the second line. vAx : `float` The X component of the vector of the first line. vAy : `float` The Y component of the vector of the first line. vBx : `float` The X component of the vector of the second line. vBy : `float` The Y component of the vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` This is an optional tolerance for considering lines parallel. This is a precomputed tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this the middle point of any overlapping segment is returned. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then a 'TooShort' union case is returned. Returns: `ClPts` An ClPts Discriminated Union with the following cases: \| Intersect of Pt \| Apart of Pt * Pt * squareDistance:float \| Parallel of Pt * Pt \| TooShortA \| TooShortB \| TooShortBoth
`XLine2D.getEndsTouching (a, b, ?tolerance)` Full Usage: `XLine2D.getEndsTouching (a, b, ?tolerance)` Parameters: a : `Line2D` - The first line. b : `Line2D` - The second line. ?tolerance : `float` - Is an optional distance tolerance. 1e-6 by default. Returns: `XEnds` A Discriminated Union Line2D.XEnds that describes the possible cases of two finite 2D lines touching at their ends: \| NotTouching \| StartA_StartB \| EndA_EndB \| EndA_StartB \| StartA_EndB \| Identical \| IdenticalFlipped	Checks if the two finite 2D lines are touching each other at exactly one of their end points within the given tolerance. a : `Line2D` The first line. b : `Line2D` The second line. ?tolerance : `float` Is an optional distance tolerance. 1e-6 by default. Returns: `XEnds` A Discriminated Union Line2D.XEnds that describes the possible cases of two finite 2D lines touching at their ends: \| NotTouching \| StartA_StartB \| EndA_EndB \| EndA_StartB \| StartA_EndB \| Identical \| IdenticalFlipped
`XLine2D.getIntersection (lineA, lineB, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getIntersection (lineA, lineB, ?tangent, ?tooShortTolerance)` Parameters: lineA : `Line2D` - First finite line segment. lineB : `Line2D` - Second finite line segment. ?tangent : `MeasureProduct<tangent, MeasureOne>` - Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XPt` An XPt Discriminated Union with the following cases: \| Intersect of Pt \| Parallel \| TooShortBoth \| TooShortA \| TooShortB Modifiers: inline	Tries to get intersection point of two finite 2D lines. lineA : `Line2D` First finite line segment. lineB : `Line2D` Second finite line segment. ?tangent : `MeasureProduct<tangent, MeasureOne>` Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XPt` An XPt Discriminated Union with the following cases: \| Intersect of Pt \| Parallel \| TooShortBoth \| TooShortA \| TooShortB
`XLine2D.getIntersection (pA, pB, vA, vB, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getIntersection (pA, pB, vA, vB, ?tangent, ?tooShortTolerance)` Parameters: pA : `Pt` - The start point of the first line. pB : `Pt` - The start point of the second line. vA : `Vc` - The direction vector of the first line. vB : `Vc` - The direction vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` - Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XPt` An XPt Discriminated Union with the following cases: \| Intersect of Pt \| Parallel \| TooShortBoth \| TooShortA \| TooShortB Modifiers: inline	Tries to get intersection point of two finite 2D lines. pA : `Pt` The start point of the first line. pB : `Pt` The start point of the second line. vA : `Vc` The direction vector of the first line. vB : `Vc` The direction vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XPt` An XPt Discriminated Union with the following cases: \| Intersect of Pt \| Parallel \| TooShortBoth \| TooShortA \| TooShortB
`XLine2D.getIntersection (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getIntersection (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tangent, ?tooShortTolerance)` Parameters: pAx : `float` - The X coordinate of the start point on the first line. pAy : `float` - The Y coordinate of the start point on the first line. pBx : `float` - The X coordinate of the start point on the second line. pBy : `float` - The Y coordinate of the start point on the second line. vAx : `float` - The X component of the vector of the first line. vAy : `float` - The Y component of the vector of the first line. vBx : `float` - The X component of the vector of the second line. vBy : `float` - The Y component of the vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` - Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XPt` An XPt Discriminated Union with the following cases: \| Intersect of Pt \| Parallel \| TooShortBoth \| TooShortA \| TooShortB	Tries to get intersection point of two finite 2D lines. pAx : `float` The X coordinate of the start point on the first line. pAy : `float` The Y coordinate of the start point on the first line. pBx : `float` The X coordinate of the start point on the second line. pBy : `float` The Y coordinate of the start point on the second line. vAx : `float` The X component of the vector of the first line. vAy : `float` The Y component of the vector of the first line. vBx : `float` The X component of the vector of the second line. vBy : `float` The Y component of the vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XPt` An XPt Discriminated Union with the following cases: \| Intersect of Pt \| Parallel \| TooShortBoth \| TooShortA \| TooShortB
`XLine2D.getIntersectionParam (lnA, lnB, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getIntersectionParam (lnA, lnB, ?tangent, ?tooShortTolerance)` Parameters: lnA : `Line2D` - First line. lnB : `Line2D` - Second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` - Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XParam` An XParam Discriminated Union with the following cases: \| Intersect of float*float \| Parallel \| TooShortBoth \| TooShortA \| TooShortB Modifiers: inline	Tries to get intersection parameters of two finite 2D-lines. lnA : `Line2D` First line. lnB : `Line2D` Second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XParam` An XParam Discriminated Union with the following cases: \| Intersect of float*float \| Parallel \| TooShortBoth \| TooShortA \| TooShortB
`XLine2D.getIntersectionParam (pA, pB, vA, vB, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getIntersectionParam (pA, pB, vA, vB, ?tangent, ?tooShortTolerance)` Parameters: pA : `Pt` - The start point of the first line. pB : `Pt` - The start point of the second line. vA : `Vc` - The direction vector of the first line. vB : `Vc` - The direction vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` - Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XParam` An XParam Discriminated Union with the following cases: \| Intersect of float*float \| Parallel \| TooShortBoth \| TooShortA \| TooShortB Modifiers: inline	Tries to get intersection parameters of two finite 2D-lines. pA : `Pt` The start point of the first line. pB : `Pt` The start point of the second line. vA : `Vc` The direction vector of the first line. vB : `Vc` The direction vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XParam` An XParam Discriminated Union with the following cases: \| Intersect of float*float \| Parallel \| TooShortBoth \| TooShortA \| TooShortB
`XLine2D.getIntersectionParam (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getIntersectionParam (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tangent, ?tooShortTolerance)` Parameters: pAx : `float` - The X coordinate of the start point on the first line. pAy : `float` - The Y coordinate of the start point on the first line. pBx : `float` - The X coordinate of the start point on the second line. pBy : `float` - The Y coordinate of the start point on the second line. vAx : `float` - The X component of the vector of the first line. vAy : `float` - The Y component of the vector of the first line. vBx : `float` - The X component of the vector of the second line. vBy : `float` - The Y component of the vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` - Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XParam` An XParam Discriminated Union with the following cases: \| Intersect of float*float \| Parallel \| TooShortBoth \| TooShortA \| TooShortB	Tries to get intersection parameters of two finite 2D-lines. pAx : `float` The X coordinate of the start point on the first line. pAy : `float` The Y coordinate of the start point on the first line. pBx : `float` The X coordinate of the start point on the second line. pBy : `float` The Y coordinate of the start point on the second line. vAx : `float` The X component of the vector of the first line. vAy : `float` The Y component of the vector of the first line. vBx : `float` The X component of the vector of the second line. vBy : `float` The Y component of the vector of the second line. ?tangent : `MeasureProduct<tangent, MeasureOne>` Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XParam` An XParam Discriminated Union with the following cases: \| Intersect of float*float \| Parallel \| TooShortBoth \| TooShortA \| TooShortB
`XLine2D.getRayIntersection (lineA, lineB, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getRayIntersection (lineA, lineB, ?tangent, ?tooShortTolerance)` Parameters: lineA : `Line2D` - First ray. lineB : `Line2D` - Second ray. ?tangent : `MeasureProduct<tangent, MeasureOne>` - Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XRay` An XRay Discriminated Union with the following cases: \| Intersect of Pt \| Parallel \| TooShortBoth \| TooShortA \| TooShortB Modifiers: inline	Tries to get intersection point of two rays (rays are 2D lines extended infinitely). lineA : `Line2D` First ray. lineB : `Line2D` Second ray. ?tangent : `MeasureProduct<tangent, MeasureOne>` Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XRay` An XRay Discriminated Union with the following cases: \| Intersect of Pt \| Parallel \| TooShortBoth \| TooShortA \| TooShortB
`XLine2D.getRayIntersection (pA, pB, vA, vB, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getRayIntersection (pA, pB, vA, vB, ?tangent, ?tooShortTolerance)` Parameters: pA : `Pt` - The start point of the first ray. pB : `Pt` - The start point of the second ray. vA : `Vc` - The direction vector of the first ray. vB : `Vc` - The direction vector of the second ray. ?tangent : `MeasureProduct<tangent, MeasureOne>` - Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XRay` An XRay Discriminated Union with the following cases: \| Intersect of Pt \| Parallel \| TooShortBoth \| TooShortA \| TooShortB Modifiers: inline	Tries to get intersection point of two rays (rays are 2D lines extended infinitely). pA : `Pt` The start point of the first ray. pB : `Pt` The start point of the second ray. vA : `Vc` The direction vector of the first ray. vB : `Vc` The direction vector of the second ray. ?tangent : `MeasureProduct<tangent, MeasureOne>` Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XRay` An XRay Discriminated Union with the following cases: \| Intersect of Pt \| Parallel \| TooShortBoth \| TooShortA \| TooShortB
`XLine2D.getRayIntersection (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getRayIntersection (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tangent, ?tooShortTolerance)` Parameters: pAx : `float` - The X coordinate of the start point on the first ray. pAy : `float` - The Y coordinate of the start point on the first ray. pBx : `float` - The X coordinate of the start point on the second ray. pBy : `float` - The Y coordinate of the start point on the second ray. vAx : `float` - The X component of the vector of the first ray. vAy : `float` - The Y component of the vector of the first ray. vBx : `float` - The X component of the vector of the second ray. vBy : `float` - The Y component of the vector of the second ray. ?tangent : `MeasureProduct<tangent, MeasureOne>` - Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XRay` An XRay Discriminated Union with the following cases: \| Intersect of Pt \| Parallel \| TooShortBoth \| TooShortA \| TooShortB	Tries to get intersection point of two rays (rays are 2D lines extended infinitely). pAx : `float` The X coordinate of the start point on the first ray. pAy : `float` The Y coordinate of the start point on the first ray. pBx : `float` The X coordinate of the start point on the second ray. pBy : `float` The Y coordinate of the start point on the second ray. vAx : `float` The X component of the vector of the first ray. vAy : `float` The Y component of the vector of the first ray. vBx : `float` The X component of the vector of the second ray. vBy : `float` The Y component of the vector of the second ray. ?tangent : `MeasureProduct<tangent, MeasureOne>` Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XRay` An XRay Discriminated Union with the following cases: \| Intersect of Pt \| Parallel \| TooShortBoth \| TooShortA \| TooShortB
`XLine2D.getRayIntersectionParam (lineA, lineB, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getRayIntersectionParam (lineA, lineB, ?tangent, ?tooShortTolerance)` Parameters: lineA : `Line2D` - First ray. lineB : `Line2D` - Second ray. ?tangent : `MeasureProduct<tangent, MeasureOne>` - Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XRayParam` An XRayParam discriminated union with the following cases: \| Intersect of float*float \| Parallel \| TooShortA \| TooShortB \| TooShortBoth Modifiers: inline	Tries to get intersection parameters of two rays (rays are 2D lines extended infinitely). lineA : `Line2D` First ray. lineB : `Line2D` Second ray. ?tangent : `MeasureProduct<tangent, MeasureOne>` Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then the 'TooShort' union case is returned. Returns: `XRayParam` An XRayParam discriminated union with the following cases: \| Intersect of float*float \| Parallel \| TooShortA \| TooShortB \| TooShortBoth
`XLine2D.getRayIntersectionParam (pA, pB, vA, vB, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getRayIntersectionParam (pA, pB, vA, vB, ?tangent, ?tooShortTolerance)` Parameters: pA : `Pt` - The start point of the first ray. pB : `Pt` - The start point of the second ray. vA : `Vc` - The direction vector of the first ray. vB : `Vc` - The direction vector of the second ray. ?tangent : `MeasureProduct<tangent, MeasureOne>` - Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then a 'TooShort' union case is returned. Returns: `XRayParam` An XRayParam discriminated union with the following cases: \| Intersect of float*float \| Parallel \| TooShortA \| TooShortB \| TooShortBoth Modifiers: inline	Tries to get intersection parameters of two rays (rays are 2D lines extended infinitely). pA : `Pt` The start point of the first ray. pB : `Pt` The start point of the second ray. vA : `Vc` The direction vector of the first ray. vB : `Vc` The direction vector of the second ray. ?tangent : `MeasureProduct<tangent, MeasureOne>` Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then a 'TooShort' union case is returned. Returns: `XRayParam` An XRayParam discriminated union with the following cases: \| Intersect of float*float \| Parallel \| TooShortA \| TooShortB \| TooShortBoth
`XLine2D.getRayIntersectionParam (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tangent, ?tooShortTolerance)` Full Usage: `XLine2D.getRayIntersectionParam (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, ?tangent, ?tooShortTolerance)` Parameters: pAx : `float` - The X coordinate of the start point on the first ray. pAy : `float` - The Y coordinate of the start point on the first ray. pBx : `float` - The X coordinate of the start point on the second ray. pBy : `float` - The Y coordinate of the start point on the second ray. vAx : `float` - The X component of the vector of the first ray. vAy : `float` - The Y component of the vector of the first ray. vBx : `float` - The X component of the vector of the second ray. vBy : `float` - The Y component of the vector of the second ray. ?tangent : `MeasureProduct<tangent, MeasureOne>` - Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then a 'TooShort' union case is returned. Returns: `XRayParam` An XRayParam discriminated union with the following cases: \| Intersect of float*float \| Parallel \| TooShortA \| TooShortB \| TooShortBoth	Tries to get intersection parameters of two rays (rays are 2D lines extended infinitely). pAx : `float` The X coordinate of the start point on the first ray. pAy : `float` The Y coordinate of the start point on the first ray. pBx : `float` The X coordinate of the start point on the second ray. pBy : `float` The Y coordinate of the start point on the second ray. vAx : `float` The X component of the vector of the first ray. vAy : `float` The Y component of the vector of the first ray. vBx : `float` The X component of the vector of the second ray. vBy : `float` The Y component of the vector of the second ray. ?tangent : `MeasureProduct<tangent, MeasureOne>` Is an optional tangent of the maximum allowed angle between the two line vectors. The default value is '0.00436' this corresponds to approx 0.25 degree. Below this angle the lines are considered parallel. Use the module Euclid.UtilEuclid.Tangent to set another tolerance here. ?tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then a 'TooShort' union case is returned. Returns: `XRayParam` An XRayParam discriminated union with the following cases: \| Intersect of float*float \| Parallel \| TooShortA \| TooShortB \| TooShortBoth
`XLine2D.getSqDistance (lineA, lineB)` Full Usage: `XLine2D.getSqDistance (lineA, lineB)` Parameters: lineA : `Line2D` - The first line. lineB : `Line2D` - The second line. Returns: `float` The squared distance between the two lines. Modifiers: inline	Gets the square distance between two finite lines. Works on Parallel lines too. lineA : `Line2D` The first line. lineB : `Line2D` The second line. Returns: `float` The squared distance between the two lines.
`XLine2D.getSqDistance (pA, pB, vA, vB)` Full Usage: `XLine2D.getSqDistance (pA, pB, vA, vB)` Parameters: pA : `Pt` - The start point of the first line. pB : `Pt` - The start point of the second line. vA : `Vc` - The direction vector of the first line. vB : `Vc` - The direction vector of the second line. Returns: `float` The squared distance between the two lines. Modifiers: inline	Gets the square distance between two finite lines. Works on Parallel lines too. pA : `Pt` The start point of the first line. pB : `Pt` The start point of the second line. vA : `Vc` The direction vector of the first line. vB : `Vc` The direction vector of the second line. Returns: `float` The squared distance between the two lines.
`XLine2D.getSqDistance (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy)` Full Usage: `XLine2D.getSqDistance (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy)` Parameters: pAx : `float` - The X coordinate of the start point on the first line. pAy : `float` - The Y coordinate of the start point on the first line. pBx : `float` - The X coordinate of the start point on the second line. pBy : `float` - The Y coordinate of the start point on the second line. vAx : `float` - The X component of the vector of the first line. vAy : `float` - The Y component of the vector of the first line. vBx : `float` - The X component of the vector of the second line. vBy : `float` - The Y component of the vector of the second line. Returns: `float` The squared distance between the two lines.	Gets the square distance between two finite lines. Works on Parallel lines too. pAx : `float` The X coordinate of the start point on the first line. pAy : `float` The Y coordinate of the start point on the first line. pBx : `float` The X coordinate of the start point on the second line. pBy : `float` The Y coordinate of the start point on the second line. vAx : `float` The X component of the vector of the first line. vAy : `float` The Y component of the vector of the first line. vBx : `float` The X component of the vector of the second line. vBy : `float` The Y component of the vector of the second line. Returns: `float` The squared distance between the two lines.
`XLine2D.isWithinRanges (lineA, lineB, minParameterA, maxParameterA, minParameterB, maxParameterB)` Full Usage: `XLine2D.isWithinRanges (lineA, lineB, minParameterA, maxParameterA, minParameterB, maxParameterB)` Parameters: lineA : `Line2D` - First line. lineB : `Line2D` - Second line. minParameterA : `float` - The minimum parameter value of the range, inclusive. maxParameterA : `float` - The maximum parameter value of the range, inclusive. minParameterB : `float` - The minimum parameter value of the range, inclusive. maxParameterB : `float` - The maximum parameter value of the range, inclusive. Returns: `bool` True if both lines have an intersection parameter in the range (inclusive min and max value). False if the lines are parallel, coincident or at least one intersection parameter is outside of the range. Modifiers: inline	Checks if two 2D-lines both have intersection parameters within the given ranges for each line lineA : `Line2D` First line. lineB : `Line2D` Second line. minParameterA : `float` The minimum parameter value of the range, inclusive. maxParameterA : `float` The maximum parameter value of the range, inclusive. minParameterB : `float` The minimum parameter value of the range, inclusive. maxParameterB : `float` The maximum parameter value of the range, inclusive. Returns: `bool` True if both lines have an intersection parameter in the range (inclusive min and max value). False if the lines are parallel, coincident or at least one intersection parameter is outside of the range.
`XLine2D.isWithinRanges (pA, pB, vA, vB, minParameterA, maxParameterA, minParameterB, maxParameterB)` Full Usage: `XLine2D.isWithinRanges (pA, pB, vA, vB, minParameterA, maxParameterA, minParameterB, maxParameterB)` Parameters: pA : `Pt` - The start point of the first line. pB : `Pt` - The start point of the second line. vA : `Vc` - The direction vector of the first line. vB : `Vc` - The direction vector of the second line. minParameterA : `float` - The minimum parameter value of the range, inclusive. maxParameterA : `float` - The maximum parameter value of the range, inclusive. minParameterB : `float` - The minimum parameter value of the range, inclusive. maxParameterB : `float` - The maximum parameter value of the range, inclusive. Returns: `bool` True if both lines have an intersection parameter in the range (inclusive min and max value). False if the lines are parallel, coincident or at least one intersection parameter is outside of the range. Modifiers: inline	Checks if two 2D-lines both have intersection parameters within the given ranges for each line pA : `Pt` The start point of the first line. pB : `Pt` The start point of the second line. vA : `Vc` The direction vector of the first line. vB : `Vc` The direction vector of the second line. minParameterA : `float` The minimum parameter value of the range, inclusive. maxParameterA : `float` The maximum parameter value of the range, inclusive. minParameterB : `float` The minimum parameter value of the range, inclusive. maxParameterB : `float` The maximum parameter value of the range, inclusive. Returns: `bool` True if both lines have an intersection parameter in the range (inclusive min and max value). False if the lines are parallel, coincident or at least one intersection parameter is outside of the range.
`XLine2D.isWithinRanges (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, minParameterA, maxParameterA, minParameterB, maxParameterB)` Full Usage: `XLine2D.isWithinRanges (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy, minParameterA, maxParameterA, minParameterB, maxParameterB)` Parameters: pAx : `float` - The X coordinate of the start point on the first line. pAy : `float` - The Y coordinate of the start point on the first line. pBx : `float` - The X coordinate of the start point on the second line. pBy : `float` - The Y coordinate of the start point on the second line. vAx : `float` - The X component of the vector of the first line. vAy : `float` - The Y component of the vector of the first line. vBx : `float` - The X component of the vector of the second line. vBy : `float` - The Y component of the vector of the second line. minParameterA : `float` - The minimum parameter value of the range, inclusive. maxParameterA : `float` - The maximum parameter value of the range, inclusive. minParameterB : `float` - The minimum parameter value of the range, inclusive. maxParameterB : `float` - The maximum parameter value of the range, inclusive. Returns: `bool` True if both lines have an intersection parameter in the range (inclusive min and max value). False if the lines are parallel, coincident or at least one intersection parameter is outside of the range. Modifiers: inline	Checks if two 2D-lines both have intersection parameters within the given ranges for each line pAx : `float` The X coordinate of the start point on the first line. pAy : `float` The Y coordinate of the start point on the first line. pBx : `float` The X coordinate of the start point on the second line. pBy : `float` The Y coordinate of the start point on the second line. vAx : `float` The X component of the vector of the first line. vAy : `float` The Y component of the vector of the first line. vBx : `float` The X component of the vector of the second line. vBy : `float` The Y component of the vector of the second line. minParameterA : `float` The minimum parameter value of the range, inclusive. maxParameterA : `float` The maximum parameter value of the range, inclusive. minParameterB : `float` The minimum parameter value of the range, inclusive. maxParameterB : `float` The maximum parameter value of the range, inclusive. Returns: `bool` True if both lines have an intersection parameter in the range (inclusive min and max value). False if the lines are parallel, coincident or at least one intersection parameter is outside of the range.
`XLine2D.parameterA (lineA, lineB)` Full Usage: `XLine2D.parameterA (lineA, lineB)` Parameters: lineA : `Line2D` - First ray. lineB : `Line2D` - Second ray. Returns: `float` The parameter on lineA at the intersection with lineB. NaN if both start points coincide and vectors are exactly parallel (0.0/0.0). Positive/Negative Infinity for almost parallel lines. Modifiers: inline	Returns the intersection parameter on the first ray (A) where ray A and ray B intersect. Returns NaN or Infinity for zero length or parallel lines. lineA : `Line2D` First ray. lineB : `Line2D` Second ray. Returns: `float` The parameter on lineA at the intersection with lineB. NaN if both start points coincide and vectors are exactly parallel (0.0/0.0). Positive/Negative Infinity for almost parallel lines.
`XLine2D.parameterA (pA, pB, vA, vB)` Full Usage: `XLine2D.parameterA (pA, pB, vA, vB)` Parameters: pA : `Pt` - The start point of the first ray. pB : `Pt` - The start point of the second ray. vA : `Vc` - The direction vector of the first ray. vB : `Vc` - The direction vector of the second ray. Returns: `float` The parameter on line A at the intersection with line B. NaN if both points coincide and vectors are exactly parallel (0.0/0.0). Positive/Negative Infinity for almost parallel lines. Modifiers: inline	Returns the intersection parameter on the first ray (A) where ray A and ray B intersect. Returns NaN or Infinity for zero length or parallel lines. pA : `Pt` The start point of the first ray. pB : `Pt` The start point of the second ray. vA : `Vc` The direction vector of the first ray. vB : `Vc` The direction vector of the second ray. Returns: `float` The parameter on line A at the intersection with line B. NaN if both points coincide and vectors are exactly parallel (0.0/0.0). Positive/Negative Infinity for almost parallel lines.
`XLine2D.parameterA (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy)` Full Usage: `XLine2D.parameterA (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy)` Parameters: pAx : `float` - The X coordinate of the start point on the first ray. pAy : `float` - The Y coordinate of the start point on the first ray. pBx : `float` - The X coordinate of the start point on the second ray. pBy : `float` - The Y coordinate of the start point on the second ray. vAx : `float` - The X component of the vector of the first ray. vAy : `float` - The Y component of the vector of the first ray. vBx : `float` - The X component of the vector of the second ray. vBy : `float` - The Y component of the vector of the second ray. Returns: `float` The parameter at which the two rays intersect on line A, This is NaN if A and B points are identical and the vectors are exactly parallel (zero divided by zero). This is positive or negative Infinity for almost parallel lines. Modifiers: inline	Returns the intersection parameter on the first ray (A) where ray A and ray B intersect. Returns NaN or Infinity for zero length or parallel lines. pAx : `float` The X coordinate of the start point on the first ray. pAy : `float` The Y coordinate of the start point on the first ray. pBx : `float` The X coordinate of the start point on the second ray. pBy : `float` The Y coordinate of the start point on the second ray. vAx : `float` The X component of the vector of the first ray. vAy : `float` The Y component of the vector of the first ray. vBx : `float` The X component of the vector of the second ray. vBy : `float` The Y component of the vector of the second ray. Returns: `float` The parameter at which the two rays intersect on line A, This is NaN if A and B points are identical and the vectors are exactly parallel (zero divided by zero). This is positive or negative Infinity for almost parallel lines.
`XLine2D.parameters (lineA, lineB)` Full Usage: `XLine2D.parameters (lineA, lineB)` Parameters: lineA : `Line2D` - First ray. lineB : `Line2D` - Second ray. Returns: `float * float` A (t,u) tuple where t is the parameter on line A and u on line B at their intersection. These are NaN if A and B points are identical and the vectors are exactly parallel (zero divided by zero). These are positive or negative Infinity for almost parallel lines. Modifiers: inline	Returns the intersection parameters on both rays. Returns NaN or Infinity for zero length or parallel lines. lineA : `Line2D` First ray. lineB : `Line2D` Second ray. Returns: `float * float` A (t,u) tuple where t is the parameter on line A and u on line B at their intersection. These are NaN if A and B points are identical and the vectors are exactly parallel (zero divided by zero). These are positive or negative Infinity for almost parallel lines.
`XLine2D.parameters (pA, pB, vA, vB)` Full Usage: `XLine2D.parameters (pA, pB, vA, vB)` Parameters: pA : `Pt` - The start point of the first ray. pB : `Pt` - The start point of the second ray. vA : `Vc` - The direction vector of the first ray. vB : `Vc` - The direction vector of the second ray. Returns: `float * float` A (t,u) tuple where t is the parameter on line A and u on line B at their intersection. These are NaN if A and B points are identical and the vectors are exactly parallel (zero divided by zero). These are positive or negative Infinity for almost parallel lines. Modifiers: inline	Returns the intersection parameters on both rays A and B. Returns NaN or Infinity for zero length or parallel lines. pA : `Pt` The start point of the first ray. pB : `Pt` The start point of the second ray. vA : `Vc` The direction vector of the first ray. vB : `Vc` The direction vector of the second ray. Returns: `float * float` A (t,u) tuple where t is the parameter on line A and u on line B at their intersection. These are NaN if A and B points are identical and the vectors are exactly parallel (zero divided by zero). These are positive or negative Infinity for almost parallel lines.
`XLine2D.parameters (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy)` Full Usage: `XLine2D.parameters (pAx, pAy, pBx, pBy, vAx, vAy, vBx, vBy)` Parameters: pAx : `float` - The X coordinate of the start point on the first ray. pAy : `float` - The Y coordinate of the start point on the first ray. pBx : `float` - The X coordinate of the start point on the second ray. pBy : `float` - The Y coordinate of the start point on the second ray. vAx : `float` - The X component of the vector of the first ray. vAy : `float` - The Y component of the vector of the first ray. vBx : `float` - The X component of the vector of the second ray. vBy : `float` - The Y component of the vector of the second ray. Returns: `float * float` A (t,u) tuple where t is the parameter on line A and u on line B at their intersection. These are NaN if A and B points are identical and the vectors are exactly parallel (zero divided by zero). These are positive or negative Infinity for almost parallel lines. Modifiers: inline	Returns the intersection parameters on both rays A and B. Returns NaN or Infinity for zero length or parallel lines. pAx : `float` The X coordinate of the start point on the first ray. pAy : `float` The Y coordinate of the start point on the first ray. pBx : `float` The X coordinate of the start point on the second ray. pBy : `float` The Y coordinate of the start point on the second ray. vAx : `float` The X component of the vector of the first ray. vAy : `float` The Y component of the vector of the first ray. vBx : `float` The X component of the vector of the second ray. vBy : `float` The Y component of the vector of the second ray. Returns: `float * float` A (t,u) tuple where t is the parameter on line A and u on line B at their intersection. These are NaN if A and B points are identical and the vectors are exactly parallel (zero divided by zero). These are positive or negative Infinity for almost parallel lines.
`XLine2D.tryIntersect (lineA, lineB)` Full Usage: `XLine2D.tryIntersect (lineA, lineB)` Parameters: lineA : `Line2D` - First finite line segment. lineB : `Line2D` - Second finite line segment. Returns: `Pt option` The intersection point if both parameters are within 0.0 to 1.0; None otherwise or if parallel/coincident. Modifiers: inline	Returns the intersection point of two finite line segments if they intersect. This method uses a small tolerance of 1e-6 to account for numerical inaccuracies when checking the 0..1 range. lineA : `Line2D` First finite line segment. lineB : `Line2D` Second finite line segment. Returns: `Pt option` The intersection point if both parameters are within 0.0 to 1.0; None otherwise or if parallel/coincident.
`XLine2D.tryIntersect (pA, pB, vA, vB)` Full Usage: `XLine2D.tryIntersect (pA, pB, vA, vB)` Parameters: pA : `Pt` - The start point of the first line. pB : `Pt` - The start point of the second line. vA : `Vc` - Vector from pA to the other end of line A (its length defines the domain 0..1). vB : `Vc` - Vector from pB to the other end of line B (its length defines the domain 0..1). Returns: `Pt option` The intersection point if both parameters are within 0.0 to 1.0; None otherwise or if parallel/coincident. Modifiers: inline	Returns the intersection point of two finite line segments if they intersect. This method uses a small tolerance of 1e-6 to account for numerical inaccuracies when checking the 0..1 range. pA : `Pt` The start point of the first line. pB : `Pt` The start point of the second line. vA : `Vc` Vector from pA to the other end of line A (its length defines the domain 0..1). vB : `Vc` Vector from pB to the other end of line B (its length defines the domain 0..1). Returns: `Pt option` The intersection point if both parameters are within 0.0 to 1.0; None otherwise or if parallel/coincident.