AutoOpenLine3D (Euclid)

AutoOpenLine3D Module

Namespace: Euclid
Assembly: Euclid.dll

When Euclid is opened this module will be auto-opened. It only contains extension members for type Line3D.

Type extensions

Type extension	Description
`this.ClosestParameter` Full Usage: `this.ClosestParameter` Parameters: p : `Pnt` Returns: `float` Modifiers: inline	Returns the parameter at which a point is closest to the (finite) line. The result is between 0.0 and 1.0. Does not fails on very short curves. Extended Type: `Line3D` p : `Pnt` Returns: `float`
`this.ClosestParameterInfinite` Full Usage: `this.ClosestParameterInfinite` Parameters: p : `Pnt` Returns: `float` Modifiers: inline	Assumes Line3D to be infinite. Returns the parameter at which a point is closest to the infinite line. If it is smaller than 0.0 or bigger than 1.0 it is outside of the finite line. Fails on curves shorter than 1e-9 units. (ln.ClosestParameter does not) Extended Type: `Line3D` p : `Pnt` Returns: `float`
`this.ClosestPoint` Full Usage: `this.ClosestPoint` Parameters: p : `Pnt` Returns: `Pnt` Modifiers: inline	Returns closest point on (finite) line. Does not fails on very short curves. Extended Type: `Line3D` p : `Pnt` Returns: `Pnt`
`this.ClosestPointInfinite` Full Usage: `this.ClosestPointInfinite` Parameters: p : `Pnt` Returns: `Pnt` Modifiers: inline	Assumes Line3D to be infinite. Returns closest point on infinite line. Fails on curves shorter than 1e-9 units. (ln.ClosestPoint does not.) Extended Type: `Line3D` p : `Pnt` Returns: `Pnt`
`this.DistanceSqToPnt` Full Usage: `this.DistanceSqToPnt` Parameters: p : `Pnt` Returns: `float` Modifiers: inline	Returns square distance from point to finite line. Extended Type: `Line3D` p : `Pnt` Returns: `float`
`this.DistanceSqToPntInfinite` Full Usage: `this.DistanceSqToPntInfinite` Parameters: p : `Pnt` Returns: `float`	Assumes Line3D to be infinite. Returns square distance from point to infinite line. Fails on curves shorter than 1e-6 units. (ln.DistanceSqToPnt does not.) Extended Type: `Line3D` p : `Pnt` Returns: `float`
`this.DistanceToPnt` Full Usage: `this.DistanceToPnt` Parameters: p : `Pnt` Returns: `float` Modifiers: inline	Returns distance from point to (finite) line. Extended Type: `Line3D` p : `Pnt` Returns: `float`
`this.DistanceToPntInfinite` Full Usage: `this.DistanceToPntInfinite` Parameters: p : `Pnt` Returns: `float` Modifiers: inline	Assumes Line3D to be infinite. Returns distance from point to infinite line. Fails on curves shorter than 1e-9 units. (ln.DistanceToPnt does not.) Extended Type: `Line3D` p : `Pnt` Returns: `float`
`this.EvaluateAt` Full Usage: `this.EvaluateAt` Parameters: p : `float` Returns: `Pnt` Modifiers: inline	Evaluate 3D line at a given parameter. Parameters 0.0 to 1.0 are on the line. Extended Type: `Line3D` p : `float` Returns: `Pnt`
`this.Extend` Full Usage: `this.Extend` Parameters: distAtStart : `float` distAtEnd : `float` Returns: `Line3D` Modifiers: inline	Extend 3D line by absolute amount at start and end. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` distAtStart : `float` distAtEnd : `float` Returns: `Line3D`
`this.ExtendEnd` Full Usage: `this.ExtendEnd` Parameters: distAtEnd : `float` Returns: `Line3D` Modifiers: inline	Extend 3D line by absolute amount at end. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` distAtEnd : `float` Returns: `Line3D`
`this.ExtendEndRel` Full Usage: `this.ExtendEndRel` Parameters: relAtEnd : `float` Returns: `Line3D` Modifiers: inline	Extend 3D line by relative amount at end. A relative amount of 0.5 extends the line by half its length. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` relAtEnd : `float` Returns: `Line3D`
`this.ExtendRel` Full Usage: `this.ExtendRel` Parameters: relAtStart : `float` relAtEnd : `float` Returns: `Line3D` Modifiers: inline	Extend 3D line by relative amount at start and end. A relative amount of 0.5 extends the line by half its length on each side. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` relAtStart : `float` relAtEnd : `float` Returns: `Line3D`
`this.ExtendStart` Full Usage: `this.ExtendStart` Parameters: distAtStart : `float` Returns: `Line3D` Modifiers: inline	Extend 3D line by absolute amount at start. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` distAtStart : `float` Returns: `Line3D`
`this.ExtendStartRel` Full Usage: `this.ExtendStartRel` Parameters: relAtStart : `float` Returns: `Line3D` Modifiers: inline	Extend 3D line by relative amount at start. A relative amount of 0.5 extends the line by half its length. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` relAtStart : `float` Returns: `Line3D`
`this.IsCoincidentTo` Full Usage: `this.IsCoincidentTo` Parameters: other : `Line3D` distanceTolerance : `float` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool` Modifiers: inline	Checks if two 3D lines are coincident within the distance tolerance. 1e-6 by default. This means that lines are parallel within the angle tolerance. and the distance of second start to the first line is less than the distance tolerance. Also returns false on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). The default angle tolerance is 0.25 degrees. This tolerance can be customized by an optional minium cosine value. See Euclid.Cosine module. Extended Type: `Line3D` other : `Line3D` distanceTolerance : `float` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool`
`this.IsHorizontal` Full Usage: `this.IsHorizontal` Parameters: () : `unit` Returns: `bool` Modifiers: inline	Checks if 3D line is horizontal. The absolute deviation tolerance along Z axis is 1e-9. Fails on lines shorter than 1e-6. Extended Type: `Line3D` () : `unit` Returns: `bool`
`this.IsHorizontal` Full Usage: `this.IsHorizontal` Returns: `bool` Modifiers: inline	Checks if 3D line is horizontal. The absolute deviation tolerance along Z axis is 1e-9. Fails on lines shorter than 1e-6. Extended Type: `Line3D` Returns: `bool`
`this.IsParallelAndOrientedTo` Full Usage: `this.IsParallelAndOrientedTo` Parameters: other : `Line3D` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool` Modifiers: inline	Checks if two 3D lines are parallel. Takes the line orientation into account too. The default angle tolerance is 0.25 degrees. This tolerance can be customized by an optional minium cosine value. See Euclid.Cosine module. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` other : `Line3D` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool`
`this.IsParallelAndOrientedTo` Full Usage: `this.IsParallelAndOrientedTo` Parameters: other : `Vec` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool` Modifiers: inline	Checks if a 3D lines is parallel to a 3D vector. Takes the line orientation into account too. The default angle tolerance is 0.25 degrees. This tolerance can be customized by an optional minium cosine value. See Euclid.Cosine module. Fails on lines or vectors shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` other : `Vec` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool`
`this.IsParallelAndOrientedTo` Full Usage: `this.IsParallelAndOrientedTo` Parameters: other : `UnitVec` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool` Modifiers: inline	Checks if a 3D lines is parallel to a 3D unit-vector. Takes the line orientation into account too. The default angle tolerance is 0.25 degrees. This tolerance can be customized by an optional minium cosine value. See Euclid.Cosine module. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` other : `UnitVec` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool`
`this.IsParallelTo` Full Usage: `this.IsParallelTo` Parameters: other : `Line3D` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool` Modifiers: inline	Checks if two 3D lines are parallel. Ignores the line orientation. The default angle tolerance is 0.25 degrees. This tolerance can be customized by an optional minium cosine value. See Euclid.Cosine module. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` other : `Line3D` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool`
`this.IsParallelTo` Full Usage: `this.IsParallelTo` Parameters: other : `Vec` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool` Modifiers: inline	Checks if a 3D lines is parallel to a 3D vector. Ignores the line orientation. The default angle tolerance is 0.25 degrees. This tolerance can be customized by an optional minium cosine value. See Euclid.Cosine module. Fails on lines or vectors shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` other : `Vec` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool`
`this.IsParallelTo` Full Usage: `this.IsParallelTo` Parameters: other : `UnitVec` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool` Modifiers: inline	Checks if a 3D lines is parallel to a 3D unit-vector. Ignores the line orientation. The default angle tolerance is 0.25 degrees. This tolerance can be customized by an optional minium cosine value. See Euclid.Cosine module. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` other : `UnitVec` minCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool`
`this.IsPerpendicularTo` Full Usage: `this.IsPerpendicularTo` Parameters: other : `Line3D` maxCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool` Modifiers: inline	Checks if two 3D lines are perpendicular to each other. The default angle tolerance is 89.75 to 90.25 degrees. This tolerance can be customized by an optional minium cosine value. The default cosine is 0.0043633 ( = 89.75 deg) See Euclid.Cosine module. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` other : `Line3D` maxCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool`
`this.IsPerpendicularTo` Full Usage: `this.IsPerpendicularTo` Parameters: other : `Vec` maxCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool` Modifiers: inline	Checks if a 3D lines is perpendicular to a 3D vector. The default angle tolerance is 89.75 to 90.25 degrees. This tolerance can be customized by an optional minium cosine value. The default cosine is 0.0043633 ( = 89.75 deg) See Euclid.Cosine module. Fails on lines or vectors shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` other : `Vec` maxCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool`
`this.IsPerpendicularTo` Full Usage: `this.IsPerpendicularTo` Parameters: other : `UnitVec` maxCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool` Modifiers: inline	Checks if a 3D lines is perpendicular to a 3D unit-vector. The default angle tolerance is 89.75 to 90.25 degrees. This tolerance can be customized by an optional minium cosine value. The default cosine is 0.0043633 ( = 89.75 deg) See Euclid.Cosine module. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` other : `UnitVec` maxCosine : `float<MeasureProduct<cosine, MeasureOne>>` Returns: `bool`
`this.IsTiny` Full Usage: `this.IsTiny` Parameters: tol : `float` Returns: `bool` Modifiers: inline	Check if 3D line is shorter than tolerance. Or contains a NaN value Extended Type: `Line3D` tol : `float` Returns: `bool`
`this.IsTinySq` Full Usage: `this.IsTinySq` Parameters: tol : `float` Returns: `bool` Modifiers: inline	Check if 3D line is shorter than the squared tolerance. Or contains a NaN value Extended Type: `Line3D` tol : `float` Returns: `bool`
`this.IsVertical` Full Usage: `this.IsVertical` Parameters: () : `unit` Returns: `bool` Modifiers: inline	Checks if 3D line is parallel to the world Z axis. Ignoring orientation. The absolute deviation tolerance along X and Y axis is 1e-9. Fails on lines shorter than 1e-6. Same as ln.IsZAligned Extended Type: `Line3D` () : `unit` Returns: `bool`
`this.IsVertical` Full Usage: `this.IsVertical` Returns: `bool` Modifiers: inline	Checks if 3D line is parallel to the world Z axis. Ignoring orientation. The absolute deviation tolerance along X and Y axis is 1e-9. Fails on lines shorter than 1e-6. Same as ln.IsZAligned Extended Type: `Line3D` Returns: `bool`
`this.IsXAligned` Full Usage: `this.IsXAligned` Parameters: () : `unit` Returns: `bool` Modifiers: inline	Checks if line is parallel to the world X axis. Ignoring orientation. The absolute deviation tolerance along Y and Z axis is 1e-9. Fails on lines shorter than 1e-6. Extended Type: `Line3D` () : `unit` Returns: `bool`
`this.IsXAligned` Full Usage: `this.IsXAligned` Returns: `bool` Modifiers: inline	Checks if line is parallel to the world X axis. Ignoring orientation. The absolute deviation tolerance along Y and Z axis is 1e-9. Fails on lines shorter than 1e-6. Extended Type: `Line3D` Returns: `bool`
`this.IsYAligned` Full Usage: `this.IsYAligned` Parameters: () : `unit` Returns: `bool` Modifiers: inline	Checks if 3D line is parallel to the world Y axis. Ignoring orientation. The absolute deviation tolerance along X and Z axis is 1e-9. Fails on lines shorter than 1e-6. Extended Type: `Line3D` () : `unit` Returns: `bool`
`this.IsYAligned` Full Usage: `this.IsYAligned` Returns: `bool` Modifiers: inline	Checks if 3D line is parallel to the world Y axis. Ignoring orientation. The absolute deviation tolerance along X and Z axis is 1e-9. Fails on lines shorter than 1e-6. Extended Type: `Line3D` Returns: `bool`
`this.IsZAligned` Full Usage: `this.IsZAligned` Parameters: () : `unit` Returns: `bool` Modifiers: inline	Checks if 3D line is parallel to the world Z axis. Ignoring orientation. The absolute deviation tolerance along X and Y axis is 1e-9. Fails on lines shorter than 1e-6. Same as ln.IsVertical Extended Type: `Line3D` () : `unit` Returns: `bool`
`this.IsZAligned` Full Usage: `this.IsZAligned` Returns: `bool` Modifiers: inline	Checks if 3D line is parallel to the world Z axis. Ignoring orientation. The absolute deviation tolerance along X and Y axis is 1e-9. Fails on lines shorter than 1e-6. Same as ln.IsVertical Extended Type: `Line3D` Returns: `bool`
`this.IsZeroLength` Full Usage: `this.IsZeroLength` Parameters: () : `unit` Returns: `bool` Modifiers: inline	Check if the 3D line has exactly the same starting and ending point. Extended Type: `Line3D` () : `unit` Returns: `bool`
`this.IsZeroLength` Full Usage: `this.IsZeroLength` Returns: `bool` Modifiers: inline	Check if the 3D line has exactly the same starting and ending point. Extended Type: `Line3D` Returns: `bool`
`this.LengthFromParam` Full Usage: `this.LengthFromParam` Parameters: t : `float` Returns: `float` Modifiers: inline	Returns the length of the line segment from the given parameter till the line End. This length is negative if the parameter is bigger than 1.0. Extended Type: `Line3D` t : `float` Returns: `float`
`this.LengthTillParam` Full Usage: `this.LengthTillParam` Parameters: p : `float` Returns: `float` Modifiers: inline	Returns the length of the line segment from the start point to the given parameter. This length is negative if the parameter is negative. Extended Type: `Line3D` p : `float` Returns: `float`
`this.MatchesOrientation180` Full Usage: `this.MatchesOrientation180` Parameters: otherLn : `Line3D` Returns: `bool` Modifiers: inline	Checks if the angle between the two 3D lines is less than 180 degrees. Calculates the dot product of two 3D lines. Then checks if it is bigger than 1e-12. Extended Type: `Line3D` otherLn : `Line3D` Returns: `bool`
`this.MatchesOrientation180` Full Usage: `this.MatchesOrientation180` Parameters: v : `Vec` Returns: `bool` Modifiers: inline	Checks if the angle between the a 3D line and a 3D vector is less than 180 degrees. Calculates the dot product of both. Then checks if it is bigger than 1e-12. Extended Type: `Line3D` v : `Vec` Returns: `bool`
`this.MatchesOrientation180` Full Usage: `this.MatchesOrientation180` Parameters: v : `UnitVec` Returns: `bool` Modifiers: inline	Checks if the angle between the a 3D line and a 3D unit-vector is less than 180 degrees. Calculates the dot product of both. Then checks if it is bigger than 1e-12. Extended Type: `Line3D` v : `UnitVec` Returns: `bool`
`this.MatchesOrientation90` Full Usage: `this.MatchesOrientation90` Parameters: otherLn : `Line3D` Returns: `bool` Modifiers: inline	Checks if the angle between the two 3D lines is less than 90 degrees. Calculates the dot product of the unit-vectors of the two 3D lines. Then checks if it is bigger than 0.707107 (cosine of 90 degrees). Extended Type: `Line3D` otherLn : `Line3D` Returns: `bool`
`this.Mid` Full Usage: `this.Mid` Parameters: () : `unit` Returns: `Pnt` Modifiers: inline	Returns the midpoint of the 3D line, Extended Type: `Line3D` () : `unit` Returns: `Pnt`
`this.Mid` Full Usage: `this.Mid` Returns: `Pnt` Modifiers: inline	Returns the midpoint of the 3D line, Extended Type: `Line3D` Returns: `Pnt`
`this.Move` Full Usage: `this.Move` Parameters: v : `Vec` Returns: `Line3D` Modifiers: inline	Returns a Line3D moved by a vector. Extended Type: `Line3D` v : `Vec` Returns: `Line3D`
`this.MoveX` Full Usage: `this.MoveX` Parameters: distance : `float` Returns: `Line3D` Modifiers: inline	Returns a Line3D moved by a given distance in X direction. Extended Type: `Line3D` distance : `float` Returns: `Line3D`
`this.MoveY` Full Usage: `this.MoveY` Parameters: distance : `float` Returns: `Line3D` Modifiers: inline	Returns a Line3D moved by a given distance in Y direction. Extended Type: `Line3D` distance : `float` Returns: `Line3D`
`this.MoveZ` Full Usage: `this.MoveZ` Parameters: distance : `float` Returns: `Line3D` Modifiers: inline	Returns a Line3D moved by a given distance in Z direction. Extended Type: `Line3D` distance : `float` Returns: `Line3D`
`this.Reversed` Full Usage: `this.Reversed` Parameters: () : `unit` Returns: `Line3D` Modifiers: inline	Returns the 3D line reversed. Extended Type: `Line3D` () : `unit` Returns: `Line3D`
`this.Reversed` Full Usage: `this.Reversed` Returns: `Line3D` Modifiers: inline	Returns the 3D line reversed. Extended Type: `Line3D` Returns: `Line3D`
`this.Segment` Full Usage: `this.Segment` Parameters: a : `float` b : `float` Returns: `Line3D` Modifiers: inline	Returns a Line3D from point at Parameter a to point at Parameter b. Extended Type: `Line3D` a : `float` b : `float` Returns: `Line3D`
`this.Shrink` Full Usage: `this.Shrink` Parameters: distAtStart : `float` distAtEnd : `float` Returns: `Line3D` Modifiers: inline	Shrink 3D line by absolute amount at start and end. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` distAtStart : `float` distAtEnd : `float` Returns: `Line3D`
`this.ShrinkEnd` Full Usage: `this.ShrinkEnd` Parameters: distAtEnd : `float` Returns: `Line3D` Modifiers: inline	Shrink 3D line by absolute amount at end. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` distAtEnd : `float` Returns: `Line3D`
`this.ShrinkStart` Full Usage: `this.ShrinkStart` Parameters: distAtStart : `float` Returns: `Line3D` Modifiers: inline	Shrink 3D line by absolute amount at start. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` distAtStart : `float` Returns: `Line3D`
`this.SubLine` Full Usage: `this.SubLine` Parameters: start : `float` ende : `float` Returns: `Line3D` Modifiers: inline	Evaluate line at a given parameters (parameters 0.0 to 1.0 are on the line), Return a new line from evaluated points. Extended Type: `Line3D` start : `float` ende : `float` Returns: `Line3D`
`this.Transform` Full Usage: `this.Transform` Parameters: m : `Matrix` Returns: `Line3D` Modifiers: inline	Applies or multiplies a 4x4 transformation matrix to a 3D line. Extended Type: `Line3D` m : `Matrix` Returns: `Line3D`
`this.TransformRigid` Full Usage: `this.TransformRigid` Parameters: m : `RigidMatrix` Returns: `Line3D` Modifiers: inline	Multiplies (or applies) a RigidMatrix to a 3D line . Extended Type: `Line3D` m : `RigidMatrix` Returns: `Line3D`
`Line3D.areCoincident a b` Full Usage: `Line3D.areCoincident a b` Parameters: a : `Line3D` b : `Line3D` Returns: `bool` Modifiers: inline	Checks if two 3D lines are coincident within tolerance. This means that lines are parallel within 0.25 degrees. and the distance of second start point to the first line is less than 1e-6. Extended Type: `Line3D` a : `Line3D` b : `Line3D` Returns: `bool`
`Line3D.areParallel l ln` Full Usage: `Line3D.areParallel l ln` Parameters: l : `Line3D` ln : `Line3D` Returns: `bool` Modifiers: inline	Checks if two 3D lines are parallel. Ignoring orientation. Calculates the Cross Product of the two line vectors. (= the area of the parallelogram) And checks if it is smaller than 1e-9 (NOTE: for very long lines a higher tolerance might be needed) Extended Type: `Line3D` l : `Line3D` ln : `Line3D` Returns: `bool`
`Line3D.areParallelAndMatchOrientation l ln` Full Usage: `Line3D.areParallelAndMatchOrientation l ln` Parameters: l : `Line3D` ln : `Line3D` Returns: `bool` Modifiers: inline	Checks if two 3D lines are parallel and orientated the same way. Calculates the Cross Product of the two line vectors. (= the area of the parallelogram) And checks if it is smaller than 1e-9 Then calculates the dot product and checks if it is positive. (NOTE: for very long lines a higher tolerance might be needed) Extended Type: `Line3D` l : `Line3D` ln : `Line3D` Returns: `bool`
`Line3D.arePerpendicular l ln` Full Usage: `Line3D.arePerpendicular l ln` Parameters: l : `Line3D` ln : `Line3D` Returns: `bool` Modifiers: inline	Checks if two 3D lines are perpendicular. Calculates the dot product and checks if it is smaller than 1e-9. (NOTE: for very long lines a higher tolerance might be needed) Extended Type: `Line3D` l : `Line3D` ln : `Line3D` Returns: `bool`
`Line3D.areTouchingAny tol a b` Full Usage: `Line3D.areTouchingAny tol a b` Parameters: tol : `float` - The tolerance for the distance between the end points. a : `Line3D` - The first line. b : `Line3D` - The second line. Returns: `int` An integer value indicating the touching case: 0 if not touching, 1 if touching at End of A and Start of B, 2 if touching at Start of A and End of B, 3 if touching at Start of A and Start of B, 4 if touching at End of A and End of B	Checks if the two finite 3D lines are touching each other at any of end points within the given tolerance. This will also return found result if the lines are touching on both points. Extended Type: `Line3D` tol : `float` The tolerance for the distance between the end points. a : `Line3D` The first line. b : `Line3D` The second line. Returns: `int` An integer value indicating the touching case: 0 if not touching, 1 if touching at End of A and Start of B, 2 if touching at Start of A and End of B, 3 if touching at Start of A and Start of B, 4 if touching at End of A and End of B
`Line3D.areTouchingEither tol a b` Full Usage: `Line3D.areTouchingEither tol a b` Parameters: tol : `float` - The tolerance for the distance between the end points. a : `Line3D` - The first line. b : `Line3D` - The second line. Returns: `int` An integer value indicating the touching case: 0 if not touching, 1 if touching at End of A and Start of B, 2 if touching at Start of A and End of B, 3 if touching at Start of A and Start of B, 4 if touching at End of A and End of B, 5 if touching at both Start and End. Lines are identical and in same orientation. 6 if touching at both at the other Start or End. Lines are identical but in opposite orientation.	Checks if the two finite 3D lines are touching each other at exactly one of their end points within the given tolerance. This will return a separate case (5 or 6) if the lines are touching on both points. Extended Type: `Line3D` tol : `float` The tolerance for the distance between the end points. a : `Line3D` The first line. b : `Line3D` The second line. Returns: `int` An integer value indicating the touching case: 0 if not touching, 1 if touching at End of A and Start of B, 2 if touching at Start of A and End of B, 3 if touching at Start of A and Start of B, 4 if touching at End of A and End of B, 5 if touching at both Start and End. Lines are identical and in same orientation. 6 if touching at both at the other Start or End. Lines are identical but in opposite orientation.
`Line3D.closestParameter p ln` Full Usage: `Line3D.closestParameter p ln` Parameters: p : `Pnt` ln : `Line3D` Returns: `float` Modifiers: inline	Returns the parameter at which a point is closest to the (finite) line. The result is between 0.0 and 1.0. Extended Type: `Line3D` p : `Pnt` ln : `Line3D` Returns: `float`
`Line3D.closestParameterInfinite p ln` Full Usage: `Line3D.closestParameterInfinite p ln` Parameters: p : `Pnt` ln : `Line3D` Returns: `float` Modifiers: inline	Assumes Line3D to be infinite. Returns the parameter at which a point is closest to the infinite line. If it is smaller than 0.0 or bigger than 1.0 it is outside of the finite line. Extended Type: `Line3D` p : `Pnt` ln : `Line3D` Returns: `float`
`Line3D.closestPoint p ln` Full Usage: `Line3D.closestPoint p ln` Parameters: p : `Pnt` ln : `Line3D` Returns: `Pnt` Modifiers: inline	Returns closest point on (finite) line. Extended Type: `Line3D` p : `Pnt` ln : `Line3D` Returns: `Pnt`
`Line3D.closestPointInfinite p ln` Full Usage: `Line3D.closestPointInfinite p ln` Parameters: p : `Pnt` ln : `Line3D` Returns: `Pnt` Modifiers: inline	Assumes Line3D to be infinite. Returns closest point on infinite line. Extended Type: `Line3D` p : `Pnt` ln : `Line3D` Returns: `Pnt`
`Line3D.createFromLine2D ln` Full Usage: `Line3D.createFromLine2D ln` Parameters: ln : `Line2D` Returns: `Line3D` Modifiers: inline	Creates a 3D line from 2D line. Setting Z to 0.0 Extended Type: `Line3D` ln : `Line2D` Returns: `Line3D`
`Line3D.createFromLine2DwithZ zLevel ln` Full Usage: `Line3D.createFromLine2DwithZ zLevel ln` Parameters: zLevel : `float` ln : `Line2D` Returns: `Line3D` Modifiers: inline	Creates a 3D line from 2D line. Setting Z to given value. Extended Type: `Line3D` zLevel : `float` ln : `Line2D` Returns: `Line3D`
`Line3D.createFromPntAndVec (p, v)` Full Usage: `Line3D.createFromPntAndVec (p, v)` Parameters: p : `Pnt` v : `Vec` Returns: `Line3D` Modifiers: inline	Creates a line starting at given point and going to along the given vector. Extended Type: `Line3D` p : `Pnt` v : `Vec` Returns: `Line3D`
`Line3D.createFromVec v` Full Usage: `Line3D.createFromVec v` Parameters: v : `Vec` Returns: `Line3D` Modifiers: inline	Creates a line starting at World Origin and going to along the given vector. Extended Type: `Line3D` v : `Vec` Returns: `Line3D`
`Line3D.direction ln` Full Usage: `Line3D.direction ln` Parameters: ln : `Line3D` Returns: `Vec` Modifiers: inline	Same as Line3D.vector or Line3D.tangent. The returned vector has the same length as the Line3D. Extended Type: `Line3D` ln : `Line3D` Returns: `Vec`
`Line3D.distanceBetweenInfiniteLines (lnA, lnB)` Full Usage: `Line3D.distanceBetweenInfiniteLines (lnA, lnB)` Parameters: lnA : `Line3D` lnB : `Line3D` Returns: `float` Modifiers: inline	Assumes Lines to be infinite. Returns the distance between two infinite 3D lines. At their closest point. Fails if one or both lines are shorter than 1e-6. Unless the lines are skew or parallel this returns 0.0. Uses the default tolerances from the Line3D.intersectionParamInfinite function. to detect parallel and coincident lines. Extended Type: `Line3D` lnA : `Line3D` lnB : `Line3D` Returns: `float`
`Line3D.distanceBetweenLines (lnA, lnB)` Full Usage: `Line3D.distanceBetweenLines (lnA, lnB)` Parameters: lnA : `Line3D` lnB : `Line3D` Returns: `float` Modifiers: inline	Returns the distance between two finite 3D lines. For parallel lines the distance is calculate form the actual finit elements. (like in the other cases.) So it is maybe bigger than the parallel offset. For Coincident and intersecting lines below a tolerance of 1e-16 this always returns 0.0. Extended Type: `Line3D` lnA : `Line3D` lnB : `Line3D` Returns: `float`
`Line3D.distanceSqToPnt p ln` Full Usage: `Line3D.distanceSqToPnt p ln` Parameters: p : `Pnt` ln : `Line3D` Returns: `float` Modifiers: inline	Returns the square distance from point to (finite) line. Extended Type: `Line3D` p : `Pnt` ln : `Line3D` Returns: `float`
`Line3D.distanceSqToPntInfinite p ln` Full Usage: `Line3D.distanceSqToPntInfinite p ln` Parameters: p : `Pnt` ln : `Line3D` Returns: `float` Modifiers: inline	Assumes Line3D to be infinite. Returns the square distance from point to infinite line. Extended Type: `Line3D` p : `Pnt` ln : `Line3D` Returns: `float`
`Line3D.distanceToPnt p ln` Full Usage: `Line3D.distanceToPnt p ln` Parameters: p : `Pnt` ln : `Line3D` Returns: `float` Modifiers: inline	Returns distance from point to (finite) line. Extended Type: `Line3D` p : `Pnt` ln : `Line3D` Returns: `float`
`Line3D.distanceToPntInfinite p ln` Full Usage: `Line3D.distanceToPntInfinite p ln` Parameters: p : `Pnt` ln : `Line3D` Returns: `float` Modifiers: inline	Assumes Line3D to be infinite. Returns distance from point to infinite line. Extended Type: `Line3D` p : `Pnt` ln : `Line3D` Returns: `float`
`Line3D.divide segments ln` Full Usage: `Line3D.divide segments ln` Parameters: segments : `int` ln : `Line3D` Returns: `Pnt[]`	Divides a 3D line into given amount of segments. Returns an array of 3D points of length: segment count + 1. Includes start and endpoint of line. Extended Type: `Line3D` segments : `int` ln : `Line3D` Returns: `Pnt[]`
`Line3D.divideEvery dist l` Full Usage: `Line3D.divideEvery dist l` Parameters: dist : `float` l : `Line3D` Returns: `ResizeArray<Pnt>`	Divides a 2D line into segments of given length. Includes start and end point Adds end point only if there is a remainder bigger than 1% of the segment length. Extended Type: `Line3D` dist : `float` l : `Line3D` Returns: `ResizeArray<Pnt>`
`Line3D.divideInsideEvery dist l` Full Usage: `Line3D.divideInsideEvery dist l` Parameters: dist : `float` l : `Line3D` Returns: `ResizeArray<Pnt>`	Divides a 2D line into segments of given length. Excludes start and end point Adds last div point before end only if there is a remainder bigger than 1% of the segment length. Extended Type: `Line3D` dist : `float` l : `Line3D` Returns: `ResizeArray<Pnt>`
`Line3D.divideMaxLength maxSegmentLength ln` Full Usage: `Line3D.divideMaxLength maxSegmentLength ln` Parameters: maxSegmentLength : `float` ln : `Line3D` Returns: `Pnt[]`	Divides a 3D line into as few as segments as possible respecting the maximum segment length. Returned Array includes start and endpoint of line. The input maxSegmentLength is multiplied by factor 0.999999 of to avoid numerical errors. That means in an edge case there are fewer segments returned, not more. Extended Type: `Line3D` maxSegmentLength : `float` ln : `Line3D` Returns: `Pnt[]`
`Line3D.divideMinLength minSegmentLength ln` Full Usage: `Line3D.divideMinLength minSegmentLength ln` Parameters: minSegmentLength : `float` ln : `Line3D` Returns: `Pnt[]`	Divides a 3D line into as many as segments as possible respecting the minimum segment length. Returned Array includes start and endpoint of line. The input minSegmentLength is multiplied by factor 1.000001 of to avoid numerical errors. That means in an edge case there are more segments returned, not fewer. Extended Type: `Line3D` minSegmentLength : `float` ln : `Line3D` Returns: `Pnt[]`
`Line3D.ende l` Full Usage: `Line3D.ende l` Parameters: l : `Line3D` Returns: `Pnt` Modifiers: inline	Returns the End point of the line. Same as Line3D.to' Extended Type: `Line3D` l : `Line3D` Returns: `Pnt`
`Line3D.equals tol a b` Full Usage: `Line3D.equals tol a b` Parameters: tol : `float` a : `Line3D` b : `Line3D` Returns: `bool` Modifiers: inline	Checks if two 3D Lines are equal within tolerance. Identical Lines in opposite directions are not considered equal. Use a tolerance of 0.0 to check for an exact match. Extended Type: `Line3D` tol : `float` a : `Line3D` b : `Line3D` Returns: `bool`
`Line3D.evaluateAt t ln` Full Usage: `Line3D.evaluateAt t ln` Parameters: t : `float` ln : `Line3D` Returns: `Pnt` Modifiers: inline	Evaluate line at a given parameter (parameters 0.0 to 1.0 are on the line) Extended Type: `Line3D` t : `float` ln : `Line3D` Returns: `Pnt`
`Line3D.extend distAtStart distAtEnd ln` Full Usage: `Line3D.extend distAtStart distAtEnd ln` Parameters: distAtStart : `float` distAtEnd : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Extend 3D line by absolute amount at start and end. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` distAtStart : `float` distAtEnd : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.extendEnd distAtEnd ln` Full Usage: `Line3D.extendEnd distAtEnd ln` Parameters: distAtEnd : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Extend 3D line by absolute amount at end. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` distAtEnd : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.extendEndRel relAtEnd ln` Full Usage: `Line3D.extendEndRel relAtEnd ln` Parameters: relAtEnd : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Extend 3D line by relative amount at end. A relative amount of 0.5 extends the line by half its length. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` relAtEnd : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.extendRel relAtStart relAtEnd ln` Full Usage: `Line3D.extendRel relAtStart relAtEnd ln` Parameters: relAtStart : `float` relAtEnd : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Extend 3D line by relative amount at start and end. A relative amount of 0.5 extends the line by half its length on each side. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` relAtStart : `float` relAtEnd : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.extendStart distAtStart ln` Full Usage: `Line3D.extendStart distAtStart ln` Parameters: distAtStart : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Extend 3D line by absolute amount at start. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` distAtStart : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.extendStartRel relAtStart ln` Full Usage: `Line3D.extendStartRel relAtStart ln` Parameters: relAtStart : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Extend 3D line by relative amount at start. A relative amount of 0.5 extends the line by half its length. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` relAtStart : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.flip ln` Full Usage: `Line3D.flip ln` Parameters: ln : `Line3D` Returns: `Line3D` Modifiers: inline	Reverse or flip the 3D line (same as Line3D.reverse) Extended Type: `Line3D` ln : `Line3D` Returns: `Line3D`
`Line3D.from l` Full Usage: `Line3D.from l` Parameters: l : `Line3D` Returns: `Pnt` Modifiers: inline	Returns the Start point of the line. Same as Line3D.start. Extended Type: `Line3D` l : `Line3D` Returns: `Pnt`
`Line3D.fromX l` Full Usage: `Line3D.fromX l` Parameters: l : `Line3D` Returns: `float` Modifiers: inline	Returns the Start point's X coordinate of the line. Extended Type: `Line3D` l : `Line3D` Returns: `float`
`Line3D.fromY l` Full Usage: `Line3D.fromY l` Parameters: l : `Line3D` Returns: `float` Modifiers: inline	Returns the Start point's Y coordinate of the line. Extended Type: `Line3D` l : `Line3D` Returns: `float`
`Line3D.fromZ l` Full Usage: `Line3D.fromZ l` Parameters: l : `Line3D` Returns: `float` Modifiers: inline	Returns the Start point's Z coordinate of the line. Extended Type: `Line3D` l : `Line3D` Returns: `float`
`Line3D.intersection (lnA, lnB, skewTolerance, relAngleDiscriminant, coincidentTolerance, tooShortTolerance)` Full Usage: `Line3D.intersection (lnA, lnB, skewTolerance, relAngleDiscriminant, coincidentTolerance, tooShortTolerance)` Parameters: lnA : `Line3D` - The first line. lnB : `Line3D` - The second line. skewTolerance : `float` - Is an optional distance tolerance. 1e-6 by default. If skew lines are closer than this distance they are considered intersecting in one point. The returned point is on line A. relAngleDiscriminant : `float<MeasureProduct<relAngDiscr, MeasureOne>>` - This is an optional tolerance for the internally calculated relative Angle Discriminant. The default value is '0.00000952' this corresponds to approx 0.25 degree. Below this angle the 'Parallel' or 'Coincident' union case is returned. Use the module Euclid.UtilEuclid.RelAngleDiscriminant to set another tolerance here. coincidentTolerance : `float` - Is an optional distance tolerance. 1e-6 by default. If parallel lines are closer than this, then the 'Coincident' union case is returned. 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: `IntersectionKind * Pnt * Pnt` Modifiers: inline	Returns the intersection kind and the points at which two (finite) 3D Lines are intersecting or closest to each other. The threshold for skew intersection can be given as an optional tolerance input. The default is 1e-6. If the two points ar within this distance one of the Intersecting Cases is returned. (or Continuation Case if lines are colinear in one point) one of the Intersecting Cases is returned. (or Continuation Case if lines are colinear in one point) The returned points are on the respective lines. For parallel and coincident lines it still returns the two end points that are closest to each other or a point in the middle of their overlap. First point is on lnA, second point is on lnB. The possible result cases are: \| Intersecting : The finite lines are intersecting each other in one point. \| IntersectingEndsBoth: The finite lines are intersecting each other at one of their end or start points point. \| IntersectingEndsFirst: The finite lines are intersecting. The first line is touching the second one with its end or start point. \| IntersectingEndsSecond: The finite lines are intersecting. The second line is touching the first one with its end or start point. \| Skew: The finite lines are skew to each other. Their closest points to each other are within the line. The returned points are between 0.0 and 1.0 \| Apart: The finite lines are not intersecting nor skew. At least one of the points of closets points would be outside of the range 0.0 and 1.0. The returned points still indicate where the finite lines are closest to each other. ------- Parallel and other special cases for finite lines: --------------- \| Parallel : The finite lines are parallel. Within 0.25 degrees. The returned points are in the middle of their overlap, or the two end points that are closest to each other. \| Overlapping The lines are coincident, overlapping and parallel within 0.25 degrees. The returned points are at start and end of overlap. \| CoincidentApart: The lines are coincident, parallel within 0.25 degrees. But ends are apart. The returned points still indicate where the lines are closest to each other. \| Continuation : The lines are coincident, parallel within 0.25 degrees. The ends are meeting in exactly one point. And Oriented the same way. The returned points indicate which ends these are. \| ContinuationFlipped: The lines are coincident, parallel within 0.25 degrees. The ends are meeting in exactly one point. But orientation is flipped. The returned points indicate which ends these are. \| Identical: The lines are identical, in orientation too with in 1e-6 tolerance. The returned points still indicate where the lines start and end. \| IdenticalFlipped: The lines are identical. But orientation is flipped. The returned points still indicate where the lines start and end. ------------------------------Error Cases: ----------------------------- \| TooShortA Input line A is shorter than the given minimum Length tolerance. The returned points are the middle of line A and the closets point to it on line B. \| TooShortB Input line B is shorter than the given minimum Length tolerance. The returned points are the closets point to lineA from the middle of line B and the middle of line B. \| TooShortBoth Both input lines are shorter than the given minimum Length tolerance. The returned points are in the middle of both lines. Extended Type: `Line3D` lnA : `Line3D` The first line. lnB : `Line3D` The second line. skewTolerance : `float` Is an optional distance tolerance. 1e-6 by default. If skew lines are closer than this distance they are considered intersecting in one point. The returned point is on line A. relAngleDiscriminant : `float<MeasureProduct<relAngDiscr, MeasureOne>>` This is an optional tolerance for the internally calculated relative Angle Discriminant. The default value is '0.00000952' this corresponds to approx 0.25 degree. Below this angle the 'Parallel' or 'Coincident' union case is returned. Use the module Euclid.UtilEuclid.RelAngleDiscriminant to set another tolerance here. coincidentTolerance : `float` Is an optional distance tolerance. 1e-6 by default. If parallel lines are closer than this, then the 'Coincident' union case is returned. 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: `IntersectionKind * Pnt * Pnt`
`Line3D.intersectionInfinite (lnA, lnB, skewTolerance, relAngleDiscriminant, coincidentTolerance, tooShortTolerance)` Full Usage: `Line3D.intersectionInfinite (lnA, lnB, skewTolerance, relAngleDiscriminant, coincidentTolerance, tooShortTolerance)` Parameters: lnA : `Line3D` - The first line. lnB : `Line3D` - The second line. skewTolerance : `float` - Is an optional distance tolerance. 1e-6 by default. If skew lines are closer than this distance they are considered intersecting in one point. The returned point is on line A. relAngleDiscriminant : `float<MeasureProduct<relAngDiscr, MeasureOne>>` - This is an optional tolerance for the internally calculated relative Angle Discriminant. The default value is '0.00000952' this corresponds to approx 0.25 degree. Below this angle the 'Parallel' or 'Coincident' union case is returned. Use the module Euclid.UtilEuclid.RelAngleDiscriminant to set another tolerance here. coincidentTolerance : `float` - Is an optional distance tolerance. 1e-6 by default. If parallel lines are closer than this, then the 'Coincident' union case is returned. 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: `IntersectionPoints3D` An IntersectionPoints3D Discriminated Union with the following cases: \| TwoPoints of skewPoints : struct(Pnt*Pnt) The lines are skew by mor than 1e-6. or the given tolerance Contains the points on the first and second line where they are closest to each other. \| OnePoint of xPoint : Pnt The 3D lines are intersection in exactly one point. Or the points are closer than the skewTolerance. 1e-6 by default. The returned point is on line A. \| Parallel: The lines are parallel, within the given tolerance. \| Coincident: The lines are coincident or maybe even identical. As infinite lines they have infinitely many points in common. \| TooShort: One or both input lines is shorter than the given minimum Length tolerance. Modifiers: inline	Gets the points at which two infinite 3D lines intersect. Or are closest to each other. Extended Type: `Line3D` lnA : `Line3D` The first line. lnB : `Line3D` The second line. skewTolerance : `float` Is an optional distance tolerance. 1e-6 by default. If skew lines are closer than this distance they are considered intersecting in one point. The returned point is on line A. relAngleDiscriminant : `float<MeasureProduct<relAngDiscr, MeasureOne>>` This is an optional tolerance for the internally calculated relative Angle Discriminant. The default value is '0.00000952' this corresponds to approx 0.25 degree. Below this angle the 'Parallel' or 'Coincident' union case is returned. Use the module Euclid.UtilEuclid.RelAngleDiscriminant to set another tolerance here. coincidentTolerance : `float` Is an optional distance tolerance. 1e-6 by default. If parallel lines are closer than this, then the 'Coincident' union case is returned. 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: `IntersectionPoints3D` An IntersectionPoints3D Discriminated Union with the following cases: \| TwoPoints of skewPoints : struct(Pnt*Pnt) The lines are skew by mor than 1e-6. or the given tolerance Contains the points on the first and second line where they are closest to each other. \| OnePoint of xPoint : Pnt The 3D lines are intersection in exactly one point. Or the points are closer than the skewTolerance. 1e-6 by default. The returned point is on line A. \| Parallel: The lines are parallel, within the given tolerance. \| Coincident: The lines are coincident or maybe even identical. As infinite lines they have infinitely many points in common. \| TooShort: One or both input lines is shorter than the given minimum Length tolerance.
`Line3D.intersectionParam (lnA, lnB, skewTolerance, relAngleDiscriminant, coincidentTolerance, tooShortTolerance)` Full Usage: `Line3D.intersectionParam (lnA, lnB, skewTolerance, relAngleDiscriminant, coincidentTolerance, tooShortTolerance)` Parameters: lnA : `Line3D` - The first line. lnB : `Line3D` - The second line. skewTolerance : `float` - Is an optional distance tolerance. 1e-6 by default. If skew lines are closer than this distance they are considered intersecting in one point. The returned point is on line A. relAngleDiscriminant : `float<MeasureProduct<relAngDiscr, MeasureOne>>` - This is an optional tolerance for the internally calculated relative Angle Discriminant. The default value is '0.00000952' this corresponds to approx 0.25 degree. Below this angle the 'Parallel' or 'Coincident' union case is returned. Use the module Euclid.UtilEuclid.RelAngleDiscriminant to set another tolerance here. coincidentTolerance : `float` - Is an optional distance tolerance. 1e-6 by default. If parallel lines are closer than this, then the 'Coincident' union case is returned. 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: `IntersectionKind * float * float` Modifiers: inline	Returns the intersection kind and the parameters at which two (finite) 3D Lines are intersecting or closest to each other. The threshold for skew intersection can be given as an optional tolerance input. The default is 1e-6. If the two points ar within this distance one of the Intersecting Cases is returned. (or Continuation Case if lines are colinear in one point) The returned parameters are both between 0.0 and 1.0. For parallel and coincident lines it still returns the two end points that are closest to each other or a point in the middle of their overlap. First parameter is on lnA, second parameter is on lnB. The possible result cases are: \| Intersecting : The finite lines are intersecting each other in one point inside both lines. \| IntersectingEndsBoth: The finite lines are intersecting each other at one of their end or start points point. \| IntersectingEndsFirst: The finite lines are intersecting. The first line is touching the second one with its end or start point. \| IntersectingEndsSecond: The finite lines are intersecting. The second line is touching the first one with its end or start point. \| Skew: The finite lines are skew to each other. Their closest points to each other are within the line. The returned parameters are between 0.0 and 1.0 \| Apart: The finite lines are not intersecting nor skew. At least one of the parameters of closets points would be outside of the range 0.0 and 1.0. The returned parameters still indicate where the finite lines are closest to each other. ------- Parallel and other special cases for finite lines: --------------- \| Parallel : The finite lines are parallel. Within 0.25 degrees. The returned parameters are in the middle of their overlap, or the two end points that are closest to each other. \| Overlapping The lines are coincident, overlapping and parallel within 0.25 degrees. The returned parameters are at start and end of overlap. \| CoincidentApart: The lines are coincident, parallel within 0.25 degrees. But ends are apart. The returned parameters still indicate where the lines are closest to each other. \| Continuation : The lines are coincident, parallel within 0.25 degrees. The ends are meeting in exactly one point. And Oriented the same way. The returned parameters indicate which ends these are. \| ContinuationFlipped: The lines are coincident, parallel within 0.25 degrees. The ends are meeting in exactly one point. But orientation is flipped. The returned parameters indicate which ends these are. \| Identical: The lines are identical, in orientation too with in 1e-6 tolerance. The returned parameters still indicate where the lines start and end. \| IdenticalFlipped: The lines are identical. But orientation is flipped. The returned parameters still indicate where the lines start and end. ------------------------------Error Cases: ----------------------------- \| TooShortA Input line A is shorter than the given minimum Length tolerance. The returned parameters are 0.5 for line A and the closets point to lineB from the middle of line A. \| TooShortB Input line B is shorter than the given minimum Length tolerance. The returned parameters are the closets point to lineA from the middle of line B and 0.5 for line B. \| TooShortBoth Both input lines are shorter than the given minimum Length tolerance. The returned parameters are 0.5 and 0.5 for both lines. Extended Type: `Line3D` lnA : `Line3D` The first line. lnB : `Line3D` The second line. skewTolerance : `float` Is an optional distance tolerance. 1e-6 by default. If skew lines are closer than this distance they are considered intersecting in one point. The returned point is on line A. relAngleDiscriminant : `float<MeasureProduct<relAngDiscr, MeasureOne>>` This is an optional tolerance for the internally calculated relative Angle Discriminant. The default value is '0.00000952' this corresponds to approx 0.25 degree. Below this angle the 'Parallel' or 'Coincident' union case is returned. Use the module Euclid.UtilEuclid.RelAngleDiscriminant to set another tolerance here. coincidentTolerance : `float` Is an optional distance tolerance. 1e-6 by default. If parallel lines are closer than this, then the 'Coincident' union case is returned. 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: `IntersectionKind * float * float`
`Line3D.intersectionParamInfinite (lnA, lnB, relAngleDiscriminant, coincidentTolerance, tooShortTolerance)` Full Usage: `Line3D.intersectionParamInfinite (lnA, lnB, relAngleDiscriminant, coincidentTolerance, tooShortTolerance)` Parameters: lnA : `Line3D` - The first line. lnB : `Line3D` - The second line. relAngleDiscriminant : `float<MeasureProduct<relAngDiscr, MeasureOne>>` - This is an optional tolerance for the internally calculated relative Angle Discriminant. The default value is '0.00000952' this corresponds to approx 0.25 degree. Below this angle the 'Parallel' or 'Coincident' union case is returned. Use the module Euclid.UtilEuclid.RelAngleDiscriminant to set another tolerance here. coincidentTolerance : `float` - Is an optional distance tolerance. 1e-6 by default. If parallel lines are closer than this, then the 'Coincident' union case is returned. 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: `IntersectionParam` An IntersectionParam Discriminated Union with the following cases: \| TwoParam of twoParams : struct(float*float): The infinite lines are intersecting or skew. They have each one point where they are intersecting each other. Or are closest to each other in skew case. The tuple's order corresponds to the input order. \| Parallel: The lines are parallel within 0.25 degrees. They have no points in common. \| Coincident: The lines are coincident (or maybe even identical) . As infinite lines they have infinitely many points in common. They might still not have the same start and end points in their finit definition. \| TooShort: One or both input lines is shorter than the given minimum Length tolerance. Modifiers: inline	Gets the parameters at which two infinite 3D lines intersect. Or are closest to each other. Extended Type: `Line3D` lnA : `Line3D` The first line. lnB : `Line3D` The second line. relAngleDiscriminant : `float<MeasureProduct<relAngDiscr, MeasureOne>>` This is an optional tolerance for the internally calculated relative Angle Discriminant. The default value is '0.00000952' this corresponds to approx 0.25 degree. Below this angle the 'Parallel' or 'Coincident' union case is returned. Use the module Euclid.UtilEuclid.RelAngleDiscriminant to set another tolerance here. coincidentTolerance : `float` Is an optional distance tolerance. 1e-6 by default. If parallel lines are closer than this, then the 'Coincident' union case is returned. 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: `IntersectionParam` An IntersectionParam Discriminated Union with the following cases: \| TwoParam of twoParams : struct(float*float): The infinite lines are intersecting or skew. They have each one point where they are intersecting each other. Or are closest to each other in skew case. The tuple's order corresponds to the input order. \| Parallel: The lines are parallel within 0.25 degrees. They have no points in common. \| Coincident: The lines are coincident (or maybe even identical) . As infinite lines they have infinitely many points in common. They might still not have the same start and end points in their finit definition. \| TooShort: One or both input lines is shorter than the given minimum Length tolerance.
`Line3D.intersectionPoint (lnA, lnB, skewTolerance, relAngleDiscriminant, coincidentTolerance, tooShortTolerance)` Full Usage: `Line3D.intersectionPoint (lnA, lnB, skewTolerance, relAngleDiscriminant, coincidentTolerance, tooShortTolerance)` Parameters: lnA : `Line3D` - The first line. lnB : `Line3D` - The second line. skewTolerance : `float` - Is an optional distance tolerance. 1e-6 by default. If skew lines are closer than this distance they are considered intersecting in one point. The returned point is on line A. relAngleDiscriminant : `float<MeasureProduct<relAngDiscr, MeasureOne>>` - This is an optional tolerance for the internally calculated relative Angle Discriminant. The default value is '0.00000952' this corresponds to approx 0.25 degree. Below this angle the 'Parallel' or 'Coincident' union case is returned. Use the module Euclid.UtilEuclid.RelAngleDiscriminant to set another tolerance here. coincidentTolerance : `float` - Is an optional distance tolerance. 1e-6 by default. If parallel lines are closer than this, then the 'Coincident' union case is returned. 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: `Pnt option`	Returns the single points where these two finite lines actually intersect each other. Or None The threshold for skew intersection can be given as an optional tolerance input. If the two points are within this distance a point is returned. This might also be the Continuation Case if lines are colinear in one point. Extended Type: `Line3D` lnA : `Line3D` The first line. lnB : `Line3D` The second line. skewTolerance : `float` Is an optional distance tolerance. 1e-6 by default. If skew lines are closer than this distance they are considered intersecting in one point. The returned point is on line A. relAngleDiscriminant : `float<MeasureProduct<relAngDiscr, MeasureOne>>` This is an optional tolerance for the internally calculated relative Angle Discriminant. The default value is '0.00000952' this corresponds to approx 0.25 degree. Below this angle the 'Parallel' or 'Coincident' union case is returned. Use the module Euclid.UtilEuclid.RelAngleDiscriminant to set another tolerance here. coincidentTolerance : `float` Is an optional distance tolerance. 1e-6 by default. If parallel lines are closer than this, then the 'Coincident' union case is returned. 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: `Pnt option`
`Line3D.intersectionPointInfinite (lnA, lnB, skewTolerance, relAngleDiscriminant, coincidentTolerance, tooShortTolerance)` Full Usage: `Line3D.intersectionPointInfinite (lnA, lnB, skewTolerance, relAngleDiscriminant, coincidentTolerance, tooShortTolerance)` Parameters: lnA : `Line3D` - The first line. lnB : `Line3D` - The second line. skewTolerance : `float` - Is an optional distance tolerance. 1e-6 by default. If skew lines are closer than this distance they are considered intersecting in one point. The returned point is on line A. relAngleDiscriminant : `float<MeasureProduct<relAngDiscr, MeasureOne>>` - This is an optional tolerance for the internally calculated relative Angle Discriminant. The default value is '0.00000952' this corresponds to approx 0.25 degree. Below this angle an EuclidException is raised. Use the module Euclid.UtilEuclid.RelAngleDiscriminant to set another tolerance here. coincidentTolerance : `float` - Is an optional distance tolerance. 1e-6 by default. If parallel lines are closer than this, then an EuclidException is raised. tooShortTolerance : `float` - Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then an EuclidException is raised. Returns: `Pnt` A single 3D point	Gets the single points where these two infinite 3D lines actually intersect each other. The returned point is on line A. Extended Type: `Line3D` lnA : `Line3D` The first line. lnB : `Line3D` The second line. skewTolerance : `float` Is an optional distance tolerance. 1e-6 by default. If skew lines are closer than this distance they are considered intersecting in one point. The returned point is on line A. relAngleDiscriminant : `float<MeasureProduct<relAngDiscr, MeasureOne>>` This is an optional tolerance for the internally calculated relative Angle Discriminant. The default value is '0.00000952' this corresponds to approx 0.25 degree. Below this angle an EuclidException is raised. Use the module Euclid.UtilEuclid.RelAngleDiscriminant to set another tolerance here. coincidentTolerance : `float` Is an optional distance tolerance. 1e-6 by default. If parallel lines are closer than this, then an EuclidException is raised. tooShortTolerance : `float` Is an optional length tolerance. 1e-6 by default. If one or both lines are shorter than this, then an EuclidException is raised. Returns: `Pnt` A single 3D point
`Line3D.isHorizontal l` Full Usage: `Line3D.isHorizontal l` Parameters: l : `Line3D` Returns: `bool` Modifiers: inline	Checks if 3D line is horizontal (Z component is almost zero). Tolerance is 1e-6. Fails on lines shorter than 1e-6. Extended Type: `Line3D` l : `Line3D` Returns: `bool`
`Line3D.isTiny tol l` Full Usage: `Line3D.isTiny tol l` Parameters: tol : `float` l : `Line3D` Returns: `bool` Modifiers: inline	Check if line is shorter than tolerance. Also checks if any component is a NaN. Extended Type: `Line3D` tol : `float` l : `Line3D` Returns: `bool`
`Line3D.isTinySq tol l` Full Usage: `Line3D.isTinySq tol l` Parameters: tol : `float` l : `Line3D` Returns: `bool` Modifiers: inline	Check if the lines square length is shorter than squared tolerance. Also checks if any component is a NaN. Extended Type: `Line3D` tol : `float` l : `Line3D` Returns: `bool`
`Line3D.isVertical l` Full Usage: `Line3D.isVertical l` Parameters: l : `Line3D` Returns: `bool` Modifiers: inline	Checks if 3D line is parallel to the world Z axis. Ignoring orientation. Tolerance is 1e-6. Fails on lines shorter than 1e-6. Same as ln.IsZAligned Extended Type: `Line3D` l : `Line3D` Returns: `bool`
`Line3D.isXAligned l` Full Usage: `Line3D.isXAligned l` Parameters: l : `Line3D` Returns: `bool` Modifiers: inline	Checks if 3D line is parallel to the world X axis. Ignoring orientation. Tolerance is 1e-6. Fails on lines shorter than 1e-6. Extended Type: `Line3D` l : `Line3D` Returns: `bool`
`Line3D.isYAligned l` Full Usage: `Line3D.isYAligned l` Parameters: l : `Line3D` Returns: `bool` Modifiers: inline	Checks if 3D line is parallel to the world Y axis. Ignoring orientation. Tolerance is 1e-6. Fails on lines shorter than 1e-6. Extended Type: `Line3D` l : `Line3D` Returns: `bool`
`Line3D.isZAligned l` Full Usage: `Line3D.isZAligned l` Parameters: l : `Line3D` Returns: `bool` Modifiers: inline	Checks if 3D line is parallel to the world Z axis. Ignoring orientation. Tolerance is 1e-6. Fails on lines shorter than 1e-6. Same as ln.IsVertical Extended Type: `Line3D` l : `Line3D` Returns: `bool`
`Line3D.isZeroLength l` Full Usage: `Line3D.isZeroLength l` Parameters: l : `Line3D` Returns: `bool` Modifiers: inline	Check if the line has same starting and ending point. Extended Type: `Line3D` l : `Line3D` Returns: `bool`
`Line3D.length l` Full Usage: `Line3D.length l` Parameters: l : `Line3D` Returns: `float` Modifiers: inline	Returns the length of the line. Extended Type: `Line3D` l : `Line3D` Returns: `float`
`Line3D.lengthSq l` Full Usage: `Line3D.lengthSq l` Parameters: l : `Line3D` Returns: `float` Modifiers: inline	Returns the square length of the line. Extended Type: `Line3D` l : `Line3D` Returns: `float`
`Line3D.lengthToPtOnLine ln pt` Full Usage: `Line3D.lengthToPtOnLine ln pt` Parameters: ln : `Line3D` pt : `Pnt` Returns: `float` Modifiers: inline	Get distance from start of line to point projected onto line, may be negative. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` ln : `Line3D` pt : `Pnt` Returns: `float`
`Line3D.matchOrientation orientationToMatch lineToFlip` Full Usage: `Line3D.matchOrientation orientationToMatch lineToFlip` Parameters: orientationToMatch : `Line3D` lineToFlip : `Line3D` Returns: `Line3D` Modifiers: inline	Ensure 3D line has a positive dot product with given orientation line. Extended Type: `Line3D` orientationToMatch : `Line3D` lineToFlip : `Line3D` Returns: `Line3D`
`Line3D.matchUnitVecOrientation orientationToMatch lineToFlip` Full Usage: `Line3D.matchUnitVecOrientation orientationToMatch lineToFlip` Parameters: orientationToMatch : `UnitVec` lineToFlip : `Line3D` Returns: `Line3D` Modifiers: inline	Ensure 3D line has a positive dot product with given 3D vector. Extended Type: `Line3D` orientationToMatch : `UnitVec` lineToFlip : `Line3D` Returns: `Line3D`
`Line3D.matchVecOrientation orientationToMatch lineToFlip` Full Usage: `Line3D.matchVecOrientation orientationToMatch lineToFlip` Parameters: orientationToMatch : `Vec` lineToFlip : `Line3D` Returns: `Line3D` Modifiers: inline	Ensure 3D line has a positive dot product with given 3D vector. Extended Type: `Line3D` orientationToMatch : `Vec` lineToFlip : `Line3D` Returns: `Line3D`
`Line3D.matchesOrientation180 l ln` Full Usage: `Line3D.matchesOrientation180 l ln` Parameters: l : `Line3D` ln : `Line3D` Returns: `bool` Modifiers: inline	Checks if the angle between the two 3D lines is less than 180 degrees. Calculates the dot product of two 3D lines. Then checks if it is positive. Extended Type: `Line3D` l : `Line3D` ln : `Line3D` Returns: `bool`
`Line3D.matchesOrientation90 l ln` Full Usage: `Line3D.matchesOrientation90 l ln` Parameters: l : `Line3D` ln : `Line3D` Returns: `bool` Modifiers: inline	Checks if the angle between the two 3D lines is less than 90 degrees. Calculates the dot product of the unit-vectors of the two 3D lines. Then checks if it is bigger than 0.707107 (cosine of 90 degrees). Extended Type: `Line3D` l : `Line3D` ln : `Line3D` Returns: `bool`
`Line3D.mid ln` Full Usage: `Line3D.mid ln` Parameters: ln : `Line3D` Returns: `Pnt` Modifiers: inline	Get point at center of line. Extended Type: `Line3D` ln : `Line3D` Returns: `Pnt`
`Line3D.move v ln` Full Usage: `Line3D.move v ln` Parameters: v : `Vec` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Move a 3D line by a vector. (same as Line3D.translate) Extended Type: `Line3D` v : `Vec` ln : `Line3D` Returns: `Line3D`
`Line3D.moveX distance ln` Full Usage: `Line3D.moveX distance ln` Parameters: distance : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Returns a 3D line moved by a given distance in X direction. Extended Type: `Line3D` distance : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.moveY distance ln` Full Usage: `Line3D.moveY distance ln` Parameters: distance : `double` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Returns a 3D line moved by a given distance in Y direction. Extended Type: `Line3D` distance : `double` ln : `Line3D` Returns: `Line3D`
`Line3D.moveZ distance ln` Full Usage: `Line3D.moveZ distance ln` Parameters: distance : `double` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Returns a 3D line moved by a given distance in Z direction. Extended Type: `Line3D` distance : `double` ln : `Line3D` Returns: `Line3D`
`Line3D.notEquals tol a b` Full Usage: `Line3D.notEquals tol a b` Parameters: tol : `float` a : `Line3D` b : `Line3D` Returns: `bool`	Check if two 3D Lines are not equal within a given tolerance. Use a tolerance of 0.0 to check if the two rectangles are not exactly equal. Extended Type: `Line3D` tol : `float` a : `Line3D` b : `Line3D` Returns: `bool`
`Line3D.offsetXY amount ln` Full Usage: `Line3D.offsetXY amount ln` Parameters: amount : `float` ln : `Line3D` Returns: `Line3D`	Offset line parallel to XY-Plane to left side in line direction. Z values are not changed. Fails on vertical lines or lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). If amount is 0.0 no offset is computed and the input line is returned. Extended Type: `Line3D` amount : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.pointAtDistance dist ln` Full Usage: `Line3D.pointAtDistance dist ln` Parameters: dist : `float` ln : `Line3D` Returns: `Pnt` Modifiers: inline	Finds point at given distance from line start. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` dist : `float` ln : `Line3D` Returns: `Pnt`
`Line3D.reverse ln` Full Usage: `Line3D.reverse ln` Parameters: ln : `Line3D` Returns: `Line3D` Modifiers: inline	Reverse or flip the 3D line (same as Line3D.flip) Extended Type: `Line3D` ln : `Line3D` Returns: `Line3D`
`Line3D.rotate q ln` Full Usage: `Line3D.rotate q ln` Parameters: q : `Quaternion` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Multiplies (or applies) a Quaternion to a 3D line. The resulting line has the same length as the input. Extended Type: `Line3D` q : `Quaternion` ln : `Line3D` Returns: `Line3D`
`Line3D.rotate2D r ln` Full Usage: `Line3D.rotate2D r ln` Parameters: r : `Rotation2D` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Rotation a 3D line around Z-Axis. Extended Type: `Line3D` r : `Rotation2D` ln : `Line3D` Returns: `Line3D`
`Line3D.rotate2dOn cen r ln` Full Usage: `Line3D.rotate2dOn cen r ln` Parameters: cen : `Pnt` r : `Rotation2D` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Rotation a 3D line round given Center point an a local Z-axis. Extended Type: `Line3D` cen : `Pnt` r : `Rotation2D` ln : `Line3D` Returns: `Line3D`
`Line3D.rotateWithCenter cen q ln` Full Usage: `Line3D.rotateWithCenter cen q ln` Parameters: cen : `Pnt` q : `Quaternion` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Multiplies (or applies) a Quaternion to a 3D line around a given center point. The resulting line has the same length as the input. Extended Type: `Line3D` cen : `Pnt` q : `Quaternion` ln : `Line3D` Returns: `Line3D`
`Line3D.segment a b ln` Full Usage: `Line3D.segment a b ln` Parameters: a : `float` b : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Returns new 3D line from point at Parameter a to point at Parameter b. Extended Type: `Line3D` a : `float` b : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.setEnd pt ln` Full Usage: `Line3D.setEnd pt ln` Parameters: pt : `Pnt` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Set Line3D end point, returns a new line. Extended Type: `Line3D` pt : `Pnt` ln : `Line3D` Returns: `Line3D`
`Line3D.setStart pt ln` Full Usage: `Line3D.setStart pt ln` Parameters: pt : `Pnt` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Set Line3D start point, returns a new line. Extended Type: `Line3D` pt : `Pnt` ln : `Line3D` Returns: `Line3D`
`Line3D.shrink distAtStart distAtEnd ln` Full Usage: `Line3D.shrink distAtStart distAtEnd ln` Parameters: distAtStart : `float` distAtEnd : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Shrink 3D line by absolute amount at start and end. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` distAtStart : `float` distAtEnd : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.shrinkEnd distAtEnd ln` Full Usage: `Line3D.shrinkEnd distAtEnd ln` Parameters: distAtEnd : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Shrink 3D line by absolute amount at end. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` distAtEnd : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.shrinkStart distAtStart ln` Full Usage: `Line3D.shrinkStart distAtStart ln` Parameters: distAtStart : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Shrink 3D line by absolute amount at start. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` distAtStart : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.split gap segments ln` Full Usage: `Line3D.split gap segments ln` Parameters: gap : `float` segments : `int` ln : `Line3D` Returns: `Line3D[]`	Divides a 3D line into given amount of segments. Includes a gap between the segments. But not at the start or end. Returns an array of 3D Lines. Returns an empty array if the length of the line is less than gap-size x segment-count-minus-1. Extended Type: `Line3D` gap : `float` segments : `int` ln : `Line3D` Returns: `Line3D[]`
`Line3D.splitMaxLength gap maxSegmentLength ln` Full Usage: `Line3D.splitMaxLength gap maxSegmentLength ln` Parameters: gap : `float` maxSegmentLength : `float` ln : `Line3D` Returns: `Line3D[]`	Divides a 3D line into as few as segments as possible respecting the maximum segment length and the gap. Includes a gap between the segments. But not at the start or end. Returns an array ofe3D Lines The input maxSegmentLength is multiplied by factor 0.999999 of to avoid numerical errors. That means in an edge case there are fewer segments returned, not more. Extended Type: `Line3D` gap : `float` maxSegmentLength : `float` ln : `Line3D` Returns: `Line3D[]`
`Line3D.splitMinLength gap minSegmentLength ln` Full Usage: `Line3D.splitMinLength gap minSegmentLength ln` Parameters: gap : `float` minSegmentLength : `float` ln : `Line3D` Returns: `Line3D[]`	Divides a 3D line into as many as segments as possible respecting the minimum segment length and the gap. Includes a gap between the segments. But not at the start or end. Returns an array ofe3D Lines The input minSegmentLength is multiplied by factor 1.000001 of to avoid numerical errors. That means in an edge case there are more segments returned, not fewer. Extended Type: `Line3D` gap : `float` minSegmentLength : `float` ln : `Line3D` Returns: `Line3D[]`
`Line3D.start l` Full Usage: `Line3D.start l` Parameters: l : `Line3D` Returns: `Pnt` Modifiers: inline	Returns the Start point of the line. Same as Line3D.from. Extended Type: `Line3D` l : `Line3D` Returns: `Pnt`
`Line3D.tangent ln` Full Usage: `Line3D.tangent ln` Parameters: ln : `Line3D` Returns: `Vec` Modifiers: inline	Same as Line3D.vector or Line3D.direction. The returned vector has the same length as the Line3D. Extended Type: `Line3D` ln : `Line3D` Returns: `Vec`
`Line3D.to' l` Full Usage: `Line3D.to' l` Parameters: l : `Line3D` Returns: `Pnt` Modifiers: inline	Returns the End point of the line. Same as Line3D.ende. Extended Type: `Line3D` l : `Line3D` Returns: `Pnt`
`Line3D.toLine2D ln` Full Usage: `Line3D.toLine2D ln` Parameters: ln : `Line3D` Returns: `Line2D` Modifiers: inline	Creates a 2D line from 3D line. Ignoring Z value. Extended Type: `Line3D` ln : `Line3D` Returns: `Line2D`
`Line3D.toX l` Full Usage: `Line3D.toX l` Parameters: l : `Line3D` Returns: `float` Modifiers: inline	Returns the End point's X coordinate of the line. Extended Type: `Line3D` l : `Line3D` Returns: `float`
`Line3D.toY l` Full Usage: `Line3D.toY l` Parameters: l : `Line3D` Returns: `float` Modifiers: inline	Returns the End point's Y coordinate of the line. Extended Type: `Line3D` l : `Line3D` Returns: `float`
`Line3D.toZ l` Full Usage: `Line3D.toZ l` Parameters: l : `Line3D` Returns: `float` Modifiers: inline	Returns the End point's Z coordinate of the line. Extended Type: `Line3D` l : `Line3D` Returns: `float`
`Line3D.transform m ln` Full Usage: `Line3D.transform m ln` Parameters: m : `Matrix` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Applies or multiplies a 4x4 transformation matrix to a 3D line. Extended Type: `Line3D` m : `Matrix` ln : `Line3D` Returns: `Line3D`
`Line3D.transformRigid m ln` Full Usage: `Line3D.transformRigid m ln` Parameters: m : `RigidMatrix` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Multiplies (or applies) a RigidMatrix to a 3D line . Extended Type: `Line3D` m : `RigidMatrix` ln : `Line3D` Returns: `Line3D`
`Line3D.translate v ln` Full Usage: `Line3D.translate v ln` Parameters: v : `Vec` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Move a 3D line by a vector. (same as Line3D.move) Extended Type: `Line3D` v : `Vec` ln : `Line3D` Returns: `Line3D`
`Line3D.unitTangent ln` Full Usage: `Line3D.unitTangent ln` Parameters: ln : `Line3D` Returns: `UnitVec` Modifiers: inline	Returns a unit-vector of the line Direction. Extended Type: `Line3D` ln : `Line3D` Returns: `UnitVec`
`Line3D.vector ln` Full Usage: `Line3D.vector ln` Parameters: ln : `Line3D` Returns: `Vec` Modifiers: inline	Same as Line3D.tangent or Line3D.direction. The returned vector has the same length as the Line3D. Extended Type: `Line3D` ln : `Line3D` Returns: `Vec`
`Line3D.withLengthFromMid len ln` Full Usage: `Line3D.withLengthFromMid len ln` Parameters: len : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Returns new Line3D with given length. Fixed in the midpoint. Missing length is added to or subtracted from both the end and start of the line. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` len : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.withLengthFromStart len ln` Full Usage: `Line3D.withLengthFromStart len ln` Parameters: len : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Returns new Line3D with given length, going out from start in direction of end. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` len : `float` ln : `Line3D` Returns: `Line3D`
`Line3D.withLengthToEnd len ln` Full Usage: `Line3D.withLengthToEnd len ln` Parameters: len : `float` ln : `Line3D` Returns: `Line3D` Modifiers: inline	Returns new Line3D ending at current LineEnd with given length coming from direction of start. Fails on lines shorter than UtilEuclid.zeroLengthTolerance (1e-12). Extended Type: `Line3D` len : `float` ln : `Line3D` Returns: `Line3D`