Exports parts for use in external CAD programs.

Parameters:

• Double: Resolution in millimeters of a point sampling on the parts surfaces
• Box: Bounding box with dimensions in millimeters that encloses the parts

• File: Output file. Note that non-existent subdirectories of the path will be created and an existing file with the same name will be overwritten. The following formats are supported:

  • FileDSV: Sampled 3d points on the parts surfaces that are inside the bounding box are saved in a text file as delimiter separated values. The points are given in the global coordinate system. There is no separation between different parts in the exported file. Quantities must be named with "x", "y" and "z" and the quantity unit must be of base unit Meter.
  • FileSTP: Step file where parts are exported in their boundary representation. The part surfaces are stored in analytical form and the edges at surface intersections are stored as precisely calculated spline curves. A resolution around 0.001 times the bounding box diameter usually works fine. It can be decreased for parts with closely adjacent vertices or edges, but there are limitations due to longer computation times. You can also use a tighter bounding box on particular parts and export them separately. Please note that some CAD softwares can have problems with the STEP import. It was observed that sometimes the wrong side of a surface is clipped or revolved surfaces such as paraboloids are missing. There are two testfiles 'TestParts.stp' and 'FirstLens.stp' in the examples folder to test the import capabilities of other programs.
• [Part]: Parts to export
• IO (): Returned IO action

Example:

main :: IO ()
main = do
    let parts = undefined
    let box = undefined

    -- export as DSV:
    let resolution = 0.01 * calcBoxDiameter box
    let partsFileDSV = FileDSV
            { fdsvPath = "./partsExport.dsv"
            , fdsvDelimiter = ' '
            , fdsvQuantities =
                [ Quantity {qName = "x", qUnit = Meter 0.001}
                , Quantity {qName = "y", qUnit = Meter 0.001}
                , Quantity {qName = "z", qUnit = Meter 0.001}
                ]
            }
    exportParts resolution box partsFileDSV parts

    -- export as STP:
    let resolution = 0.001 * calcBoxDiameter box
    let partsFileSTP = FileSTP { fstpPath = "./partsExport.stp" }
    exportParts resolution box partsFileSTP parts

Available in: Pro

Exports a SellmeierCatalog. Note that non-existent subdirectories of the path will be created and an existing file with the same name will be overwritten.

Parameters:

• File: Output file with the following formats supported:

  • FileHS: Haskell file. Note that the module name must be entered manually at the beginning of the exported file so that the file can be imported by other scripts. The module name must be of alphanumeric characters, starts with an uppercase letter and corresponds to the directory in which the file is stored.
• SellmeierCatalog: SellmeierCatalog with SellmeierCoefficients.
• IO (): Returned IO action

Available in: Base | Pro

Import of rays from a rayfile with sets of raydata, also known as raysets. Each rayset must provide full single ray data, which means it includes origin, direction, wavelength and flux for each ray. The flux can be specified either radiometrically in watts or photometrically in lumens. In the Ray datatype, however, the flux is exclusively defined radiometrically. Therefore, when specifying the flux in lumens, a conversion to watts is performed via the photopic luminous efficiency function defined in CIE1924/CIE1931.

Rayfiles can be provided in various formats by light source manufacturers.

Parameters:

• Material: The information about the material of the ray origins are usually not provided in rayfiles but is needed to create rays. This parameter is used to assign the same material to all rays.

• File: Rayfile with one of the following constructors:

  • FileLEF: Constructor for a binary file with full ray data
• IO [Ray]: Returned rays in an IO action

The example shows how rays could be imported with the appropriate file specification.

Example:

main :: IO ()
main = do
    -- Import Rays for Speos ray file:
    let material = undefined
    let rayFileSpeos = FileLEF
            { flefPath = undefined
            , flefHeaderSize = 28
            , flefQuantities =
                [ Quantity "originX" (Meter 1e-3)
                , Quantity "originY" (Meter 1e-3)
                , Quantity "originZ" (Meter 1e-3)
                , Quantity "directionX" (Meter 1e-3)
                , Quantity "directionY" (Meter 1e-3)
                , Quantity "directionZ" (Meter 1e-3)
                , Quantity "wavelength" (Meter 1e-9)
                , Quantity "flux" (Lumen 1)]
            }
    rays <- importRays material rayFileSpeos

Available in: Base | Pro

Import of rays from a rayfile with sets of raydata, also known as raysets. Each rayset must provide standard single ray data, which means it includes origin, direction and flux for each ray. The flux can be specified either radiometrically in watts or photometrically in lumens (see explanation in importRays). Wavelength information is provided by a second file which contains a spectrum. Wavelengths for the rays are sampled according to a probability distribution derived from the spectrum. The spectrum intensities can have an arbitrary unit since they are normalized when the distribution is calculated.

Rayfiles and spectrum files can be provided in various formats by light source manufacturers.

Parameters:

• Material: The information about the material of the ray origins are usually not provided in rayfiles but is needed to create rays. This parameter is used to assign the same material to all rays.

• File: Spectrum file specified by one of the following constructors:

  • FileDSV: Constructor for a text file with spectrum data

• File: Rayfile specified by one of the following constructors:

  • FileDSV: Constructor for a text file with standard ray data.
  • FileLEF: Constructor for a binary file with standard ray data.
• IO [Ray]: Returned rays in an IO action

The example shows how rays could be imported with the appropriate file specification. Note that for some formats, the rayfile specification is not always unique. This means that the quantities must be defined according to information from the rayfile provider.

Example:

main :: IO ()
main = do
    -- Import Rays for ASCII spectrum file and ASAP ray file:
    let material = undefined
    let spectrumFile = FileDSV
            { fdsvPath = undefined
            , fdsvDelimiter = '\t'
            , fdsvQuantities =
                [ Quantity "wavelength" (Meter 1e-9)
                , Quantity "intensity" (One 1) ]
            }
    let rayFile = FileLEF
            { flefPath = undefined
            , flefHeaderSize = 140
            , flefQuantities =
                [ Quantity "originX" (Meter 1e-3)
                , Quantity "originY" (Meter 1e-3)
                , Quantity "originZ" (Meter 1e-3)
                , Quantity "directionX" (Meter 1e-3)
                , Quantity "directionY" (Meter 1e-3)
                , Quantity "directionZ" (Meter 1e-3)
                , Quantity "flux" (Lumen 1)]
            }
    raysASAP <- importRays2 material spectrumFile rayFile

    -------------------------------------------------------

    -- Import Rays for ASCII spectrum file and ASCII ray file:
    let material = undefined
    let spectrumFile = FileDSV
            { fdsvPath = undefined
            , fdsvDelimiter = '\t'
            , fdsvQuantities =
                [ Quantity "wavelength" (Meter 1e-9)
                , Quantity "intensity" (One 1) ]
            }
    let rayFile = FileDSV
            { fdsvPath = undefined
            , fdsvDelimiter = ' '
            , fdsvQuantities =
                [ Quantity "originX" (Meter 1e-3)
                , Quantity "originY" (Meter 1e-3)
                , Quantity "originZ" (Meter 1e-3)
                , Quantity "directionX" (Meter 1e-3)
                , Quantity "directionY" (Meter 1e-3)
                , Quantity "directionZ" (Meter 1e-3)
                , Quantity "flux" (Lumen 1)]
            }
    raysASCII <- importRays2 material spectrumFile rayFile

    -------------------------------------------------------

    -- Import Rays for ASCII spectrum file and LucidShape ray file:
    let material = undefined
    let spectrumFile = FileDSV
            { fdsvPath = undefined
            , fdsvDelimiter = '\t'
            , fdsvQuantities =
                [ Quantity "wavelength" (Meter 1e-9)
                , Quantity "intensity" (One 1) ]
            }
    let rayFile = FileLEF
            { flefPath = undefined
            , flefHeaderSize = 28
            , flefQuantities =
                [ Quantity "originX" (Meter 1e-3)
                , Quantity "originY" (Meter 1e-3)
                , Quantity "originZ" (Meter 1e-3)
                , Quantity "directionX" (Meter 1e-3)
                , Quantity "directionY" (Meter 1e-3)
                , Quantity "directionZ" (Meter 1e-3)
                , Quantity "flux" (Lumen 1)]
            }
    raysLucidShape <- importRays2 material spectrumFile rayFile

    -------------------------------------------------------

    -- Import Rays for ASCII spectrum file and Photopia ray file:
    let material = undefined
    let spectrumFile = FileDSV
            { fdsvPath = undefined
            , fdsvDelimiter = '\t'
            , fdsvQuantities =
                [ Quantity "wavelength" (Meter 1e-9)
                , Quantity "intensity" (One 1) ]
            }
    let rayFile = FileLEF
            { flefPath = undefined
            , flefHeaderSize = 208
            , flefQuantities =
                [ Quantity "originX" (Meter 1e-3)
                , Quantity "originY" (Meter 1e-3)
                , Quantity "originZ" (Meter 1e-3)
                , Quantity "directionX" (Meter 1e-3)
                , Quantity "directionY" (Meter 1e-3)
                , Quantity "directionZ" (Meter 1e-3)
                , Quantity "flux" (Lumen 1)]
            }
    raysPhotopia <- importRays2 material spectrumFile rayFile

    -------------------------------------------------------

    -- Import Rays for ASCII spectrum file and TraceProBinary ray file:
    let material = undefined
    let spectrumFile = FileDSV
            { fdsvPath = undefined
            , fdsvDelimiter = '\t'
            , fdsvQuantities =
                [ Quantity "wavelength" (Meter 1e-9)
                , Quantity "intensity" (One 1) ]
            }
    let rayFile = FileLEF
            { flefPath = undefined
            , flefHeaderSize = 208
            , flefQuantities =
                [ Quantity "originX" (Meter 1e-3)
                , Quantity "originY" (Meter 1e-3)
                , Quantity "originZ" (Meter 1e-3)
                , Quantity "directionX" (Meter 1e-3)
                , Quantity "directionY" (Meter 1e-3)
                , Quantity "directionZ" (Meter 1e-3)
                , Quantity "flux" (Lumen 1)]
            }
    raysTraceProBinary <- importRays2 material spectrumFile rayFile

    -------------------------------------------------------

    -- Import Rays for ASCII spectrum file and TraceProText ray file:
    let material = undefined
    let spectrumFile = FileDSV
            { fdsvPath = undefined
            , fdsvDelimiter = '\t'
            , fdsvQuantities =
                [ Quantity "wavelength" (Meter 1e-9)
                , Quantity "intensity" (One 1) ]
            }
    let rayFile = FileDSV
            { fdsvPath = undefined
            , fdsvDelimiter = ' '
            , fdsvQuantities =
                [ Quantity "originX" (Meter 1e-3)
                , Quantity "originY" (Meter 1e-3)
                , Quantity "originZ" (Meter 1e-3)
                , Quantity "directionX" (Meter 1e-3)
                , Quantity "directionY" (Meter 1e-3)
                , Quantity "directionZ" (Meter 1e-3)
                , Quantity "flux" (Lumen 1)]
            }
    raysTraceProText <- importRays2 material spectrumFile rayFile

    -------------------------------------------------------

    -- Import Rays for ASCII spectrum file and Zemax ray file:
    let material = undefined
    let spectrumFile = FileDSV
            { fdsvPath = undefined
            , fdsvDelimiter = '\t'
            , fdsvQuantities =
                [ Quantity "wavelength" (Meter 1e-6)
                , Quantity "intensity" (One 1) ]
            }
    let rayFile = FileLEF
            { flefPath = undefined
            , flefHeaderSize = 208
            , flefQuantities =
                [ Quantity "originX" (Meter 1e-3)
                , Quantity "originY" (Meter 1e-3)
                , Quantity "originZ" (Meter 1e-3)
                , Quantity "directionX" (Meter 1e-3)
                , Quantity "directionY" (Meter 1e-3)
                , Quantity "directionZ" (Meter 1e-3)
                , Quantity "flux" (Lumen 1)]
            }
    raysZemax <- importRays2 material spectrumFile rayFile

Available in: Base | Pro

Import a spectrum from a spectrum file, which contains intensities in an arbitrary unit for a range of wavelengths. Spectrum files can be provided by light source manufactures.

Parameters:

• File: Spectrum file specified by one of the following constructors:

  • FileDSV: Constructor for a text file with spectrum data
• IO Spectrum: Returned spectrum in an IO action

The example shows how a spectrum could be imported.

Example:

main :: IO ()
main = do
    let spectrumFile = FileDSV
            { fdsvPath = undefined
            , fdsvDelimiter = '\t'
            , fdsvQuantities =
                [ Quantity "wavelength" (Meter 1e-9)
                , Quantity "intensity" (One 1) ]
            }
   spectrum <- importSpectrum spectrumFile

Available in: Base | Pro

Import a SellmeierCatalog from a file with material data. Note that after importing a SellmeierCatalog it should be exported again as FileHS. This way it can be imported as a module by other scripts.

Parameters:

• File: File specified by one of the following constructors:

  • FileAGF: Constructor for a AGF file with material data
• IO SellmeierCatalog: Returned SellmeierCatalog in an IO action

Example:

main :: IO ()
main = do
    let materialFileIn = FileAGF {fagfPath = undefined}
    sellmeierCatalog <- importSellmeierCatalog materialFileIn
    let materialFileOut = FileHS {fhsPath = undefined}
    exportSellmeierCatalog materialFileOut sellmeierCatalog

Available in: Base | Pro

This function initializes a new view in which graphic content can be visualized.

Parameters:

• Orientation: This pair of axes define the orientation of the world coordinate system in the view. The first axis will point to the screen right and the second axis to the screen top. The direction of the third axis is perpendicular to the screen, so that the right-handedness of the coordinate system is preserved.
• Box: Bounding box of the volume to be displayed with context-dependent unit of length
• V2 Int: View position on screen in pixel
• V2 Int: View size in pixel
• IO View: Returned view in an IO action

Example:

view <- initView XY ((20,20),(20,20),(20,20)) (100,100) (800,600)

Available in: Free | Base | Pro

Sets the rulers of a view to active state. The rulers update based on the zoom, pan and rotation of the view.

Available in: Free | Base | Pro

Changes the view on the scene by setting the view matrix. The matrix is of the form 4x4 with a 3x3 rotation submatrix on the top left, a 3x1 translation vector on the top right and the 1x4 unit vector with 1 in the fourth component.

Available in: Free | Base | Pro

Adds text to a view for display.

Parameters:

• View: View on which is displayed.
• V2 Int: Position in pixels of the top left corner of the text in readable orientation
• Double: Angle in degrees by which to rotate the text
• Double: Font size in pixels
• String: Text to display

Available in: Free | Base | Pro

Add a box as a wireframe model to a view for display.

Parameters:

• View: View on which is displayed.
• Box: Box to display with context-dependent unit of length

Available in: Free | Base | Pro

Add axes to a view for display.

Parameters:

• View: View on which is displayed
• Axes: Axes to display
• IO (): Returned IO action

Available in: Free | Base | Pro

Add a point to a view for display.

Parameters:

• View: View on which is displayed
• Double: Point size in pixels
• V3 Double: Coordinates of the point to display in unit of measurement depending on the context
• IO (): Returned IO action

Available in: Free | Base | Pro

Add points to a view for display.

Parameters:

• View: View on which is displayed
• Double: Point size in pixels
• [V3 Double]: Coordinates of the points to display in unit of measurement depending on the context
• IO (): Returned IO action

Available in: Free | Base | Pro

Add a line segment to a view for display.

Parameters:

• View: View on which is displayed
• M23 Double: Point pair coordinates in unit of measurement depending on the context
• IO (): Returned IO action

Available in: Free | Base | Pro

Add line segments to a view for display.

Parameters:

• View: View on which is displayed
• [M23 Double]: Point pairs coordinates in unit of measurement depending on the context
• IO (): Returned IO action

Available in: Free | Base | Pro

Add a part to a view for display.

Parameters:

• View: View on which is displayed
• Part: Part to display
• IO (): Returned IO action

Available in: Free | Base | Pro

Add parts to a view for display.

Parameters:

• View: View on which is displayed
• [Part]: Parts to display
• IO (): Returned IO action

Available in: Free | Base | Pro

Add a single ray to a view for display.

Parameters:

• View: View on which is displayed
• Ray: Ray to display
• IO (): Returned IO action

Available in: Free | Base | Pro

Add multiple rays to a view for display.

Parameters:

• View: View on which is displayed
• [Ray]: Rays to display
• IO (): Returned IO action

Available in: Free | Base | Pro

Add a single raytrace to a view for display.

Parameters:

• View: View on which is displayed
• Raytrace: Raytrace to display
• IO (): Returned IO action

Available in: Free | Base | Pro

Add multiple raytraces to a view for display.

Parameters:

• View: View on which is displayed
• [Raytrace]: Raytraces to display
• IO (): Returned IO action

Available in: Free | Base | Pro

Creates a view with a spot diagram.

Parameters:

• V2 Int: View position on screen in pixel
• V2 Int: View size in pixel
• Double: Font size of text annotations
• Double: Point size of spot points
• String: Title
• Spot: Spot to display
• IO View: Returned view in an IO action

Available in: Base | Pro

Shows a view and runs its renderloop. During the renderloop the following user interactions could be triggerd with mouse and keyboard events:

• pan: Press the right mouse button and move the cursor
• zoom: Press the right mouse button and scroll mouse-wheel
• xy-Rotation: Press left mouse button and move the cursor
• z-Rotation: Move the mouse cursor to the center of rotation, press the left and right mouse button, move the cursor away from the center and then sideways
• redraw: The parts are rendered as a pointcloud. This pointcloud can be recalculated and redrawed for different sights after a navigation. You can trigger a redraw with the Space key
• close: Close the view window with the ESC key or ALT+F4 keys

Available in: Free | Base | Pro

Shows multiple views and runs their mainloops. The same user interactions as described in runView are accepted for each of them.

Available in: Free | Base | Pro

Calculates a list of equally distributed lines in a 2d conical area in the xy plane. All lines have the same origin (0,0,0) and the central direction of the conical area is (1,0,0).

Parameters:

• Double: Aperture angle of the lines in degrees
• Int: Number of lines
• [Line]: Resulting lines

Example:

lines = calcConicalLines2d 15 10

Available in: Free | Base | Pro

Calculates a list of equally distributed lines in a 3d conical area. All lines have the same origin (0,0,0) and the central direction of the conical area is (1,0,0).

Parameters:

• Double: Aperture angle of the lines in degrees
• Int: Number of lines
• [Line]: Resulting lines

Example:

lines = calcConicalLines3d 15 200

Available in: Free | Base | Pro

Calculates a list of equally distributed parallel lines in xy plane. The origin of the beam center is at (0,0,0) and all lines point in the direction (1,0,0).

Parameters:

• Double: Lines width
• Int: Number of lines
• [Line]: Resulting lines

Available in: Free | Base | Pro

Calculates a list of equally distributed parallel lines with circular profile. The origin of the beam center is at (0,0,0) and all lines point in the direction (1,0,0).

Parameters:

• Double: Lines width (circle diameter)
• Int: Number of lines
• [Line]: Resulting lines

Available in: Free | Base | Pro

Calculates a 3d rotation matrix from Euler-Cardan angles.

Parameters:

• AngleUnit: Unit of angles
• V3 Double: Euler-Cardan angles \( (\alpha, \beta, \gamma) \). The rotation matrix is defined as: \( R = R_z(\gamma) \cdot R_y(\beta) \cdot R_x(\alpha) \), where:

\[ R_x(\alpha) = \begin{pmatrix} 1 & 0 & 0 \\ 0 & \cos \alpha & -\sin \alpha \\ 0 & \sin \alpha & \cos \alpha \end{pmatrix} \] \[ R_y(\beta) = \begin{pmatrix} \cos \beta & 0 & \sin \beta \\ 0 & 1 & 0 \\ -\sin \beta & 0 & \cos \beta \end{pmatrix} \] \[ R_z(\gamma) = \begin{pmatrix} \cos \gamma & -\sin \gamma & 0 \\ \sin \gamma & \cos \gamma & 0 \\ 0 & 0 & 1 \end{pmatrix} \]

• M33 Double: Resulting rotation matrix

Available in: Free | Base | Pro

Calculates a 3d rotation matrix from two vectors.

Parameters:

• M23 Double: Two 3d vectors (v1,v2) to define the rotation matrix. Usually the rotated first two unit vectors in x- and y-direction are specified here, which correspond to the first two rows of the transposed rotation matrix. However, the vectors can be kept more general: The first vector points in positive direction of the rotated x-axis. The second vector is any vector in the rotated xy-plane, where its dot product with the vector along the rotated y-axis must be positive.
• M33 Double: Resulting rotation matrix

Available in: Free | Base | Pro

Calculates an transformation object with rotation from Euler-Cardan angles.

Parameters:

• V3 Double: Euler-Cardan angles, see explanation in calcRotation
• V3 Double: Location
• Transformation: Resulting transformation

Available in: Free | Base | Pro

Calculates an transformation object with rotation from two vectors.

Parameters:

• M23 Double: Two 3d vectors, see explanation in calcRotation2
• V3 Double: Location
• Transformation: Resulting transformation

Available in: Free | Base | Pro

Infinity is larger than any real number. Here it is defined as 1/0.

Available in: Free | Base | Pro

Epsilon is the approximation to machine epsilon, which is at 2.220446049250313e-16 for double precision (64-bit). This value can be used in direct or derived form (depending on the context) for algorithms that require a small positive tolerance.

Available in: Free | Base | Pro

Calculates the diameter of a box.

Available in: Free | Base | Pro

Computes the spot of rays traced through an optical system at a given analysis plane. The spot can be viewed in a spot diagram with createViewSpotDiagram.

Parameters:

• Double: Radius in millimeters of a circle around the plane local coordinate system origin in which all raypoints must lie, see also Spot.
• Transformation: Transformation defining the local coordinate system of the analysis plane, see also Spot
• System: System to be analyzed
• [Ray]: Rays traced through the system. They usually originate from a single point at a finite or infinite distance.
• Spot: Computed spot

Available in: Base | Pro

Retrieves the SellmeierCoefficients from SellmeierCatalog by the materials name.

Parameters:

• SellmeierCatalog: Catalog with SellmeierCoefficients for materials
• String: Material name
• SellmeierCoefficients: Retrieved SellmeierCoefficients

Available in: Free | Base | Pro

Tests whether a point is inside a part.

Parameters:

• Part: Part
• V3 Double: Point
• Bool: Boolean return value

Available in: Base | Pro

Calculates rays from a list of lines. The transformation parameter is used to first rotate the lines as you like and then translate them to an arbitrary location. The rays are all assigned the same wavelength and material. Be careful with this function as all ray origins should lie within a part of the same material that is assigned. Note that lines can be calculated using the functions from Math.Line.

Parameters:

• Double: Wavelength of the rays light in vacuum in micrometers.
• Double: Total radiant flux for all rays.
• Material: Assigned material where the orgins lie in.
• Transformation: Transformation that defines the rays placement.
• [Line]: List of lines.
• [Ray]: List of resulting rays.

Available in: Free | Base | Pro

This function traces a single ray through a system. The raytrace ends when the source ray or any deflected ray of the raytrace is absorbed or has no more next intersection. Note that for unbounded parts of the system (e.g. unbounded cylinders), an infinite raytrace can occur, resulting in infinite runtime. To prevent this, it is recommended to define an absorbing part that is hollow inside and encloses all other parts and the ray origin. At its simplest, this could be a part with with a reversed sphere as its only surface.

Parameters:

• System: System through which the ray is traced
• Ray: Ray to be traced
• Raytrace: Resulting raytrace

Available in: Free | Base | Pro

Raytracing of multiple rays through a system. The same rules as are described in traceRay apply to each single ray.

Parameters:

• System: System through which rays are traced
• [Ray]: Rays to be traced
• [Raytrace]: Resulting raytraces, one for each ray

Available in: Free | Base | Pro

Datatype for different file formats.

Data frame for homogenous data of the same arbitrary type.

A Quantity can be either a dimensionless or a physical quantity, depending on the unit.

Units of measurement with a multiplier, e.g. millimeter = Meter 0.001

The Axes datatype is used to visualize a right handed cartesian coordinate system relative to the global coordinate system.

Datatype for a proper rigid transformation, which is the combination of a rotation matrix that preserves handedness and a translation vector.

Sum type of all geometric surface shapes.

Arbitrary sphere: \[ F(x,y,z) = (x-P_x)^2 + (y-P_y)^2 + (z-P_z)^2 - R^2 = 0 \]

Sphere with center on x-axis: \[ F(x,y,z) = (x-P_x)^2 + y^2 + z^2 - R^2 = 0\]

Sphere with center on y-axis: \[ F(x,y,z) = x^2 + (y-P_y)^2 + z^2 - R^2 = 0\]

Sphere with center on z-axis: \[ F(x,y,z) = x^2 + y^2 + (z-P_z)^2 - R^2 = 0\]

Arbitrary plane: \[ F(x,y,z) = A x + B y + C z - D = 0 \] \( (A,B,C)^T \) is the normal vector of the plane. If the normal vector has unit length, then the absolute value of \( D \) is the distance to the coordinate origin \( (0,0,0)^T \).

Plane with normal vector in direction of x-axis: \[ F(x,y,z) = x - D = 0 \]

Plane with normal vector in direction of y-axis: \[ F(x,y,z) = y - D = 0\]

Plane with normal vector in direction of z-axis: \[ F(x,y,z) = z - D = 0 \]

Arbitrary cylinder with radius \( R \) and central line defined by a position vector \( P = (P_x,P_y,P_z)^T \) and a direction vector \( D = (D_x,D_y,D_z)^T \): \[ F(x,y,z) = ||X-P||_2^2 - \langle X-P,D_n\rangle^2 - R^2 = 0 \] where: \[X = \begin{pmatrix}x\\y\\z\end{pmatrix}\] \[ D_n = \frac{D}{||D||_2} \]

Cylinder with radius \( R \) and x-axis as central line: \[ F(x,y,z) = y^2 + z^2 - R^2 = 0\]

Cylinder with radius \( R \) and y-axis as central line: \[ F(x,y,z) = x^2 + z^2 - R^2 = 0\]

Cylinder with radius \( R \) and z-axis as central line: \[ F(x,y,z) = x^2 + y^2 - R^2 = 0\]

Cylinder with radius \( R \) parallel to x-axis and central going through \( (0,P_y,P_z)^T \): \[ F(x,y,z) = (y-P_y)^2 + (z-P_z)^2 - R^2 = 0\]

Cylinder with radius \( R \) parallel to y-axis and central going through \( (P_x,0,P_z)^T \): \[ F(x,y,z) = (x-P_x)^2 + (z-P_z)^2 - R^2 = 0\]

Cylinder with radius \( R \) parallel to z-axis and central going through \( (P_x,P_y,0)^T \): \[ F(x,y,z) = (x-P_x)^2 + (y-P_y)^2 - R^2 = 0\]

Paraboloid of revolution with x-axis as central line opened in positive direction and its vertex at \( (P_x,0,0)^T \): \[ F(x,y,z) = -(x-P_x) + \frac{y^2}{A^2} + \frac{z^2}{A^2} = 0\]

Paraboloid of revolution with y-axis as central line opened in positive direction and its vertex at \( (0,P_y,0)^T \): \[ F(x,y,z) = \frac{x^2}{A^2} - (y-P_y) + \frac{z^2}{A^2} = 0\]

Paraboloid of revolution with z-axis as central line opened in positive direction and its vertex at \( (0,0,P_z)^T \): \[ F(x,y,z) = \frac{x^2}{A^2} + \frac{y^2}{A^2} - (z-P_z) = 0\]

Paraboloid of revolution opened in positive x-direction with its vertex at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = -(x-P_x) + \frac{(y-P_y)^2}{A^2} + \frac{(z-P_z)^2}{A^2} = 0\]

Paraboloid of revolution opened in positive y-direction with its vertex at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = \frac{(x-P_x)^2}{A^2} -(y-P_y) + \frac{(z-P_z)^2}{A^2} = 0\]

Paraboloid of revolution opened in positive z-direction with its vertex at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = \frac{(x-P_x)^2}{A^2} + \frac{(y-P_y)^2}{A^2} - (z-P_z) = 0\]

Paraboloid of revolution with x-axis as central line opened in negative direction and its vertex at \( (P_x,0,0)^T \): \[ F(x,y,z) = (x-P_x) + \frac{y^2}{A^2} + \frac{z^2}{A^2} = 0\]

Paraboloid of revolution with y-axis as central line opened in negative direction and its vertex at \( (0,P_y,0)^T \): \[ F(x,y,z) = \frac{x^2}{A^2} + (y-P_y) + \frac{z^2}{A^2} = 0\]

Paraboloid of revolution with z-axis as central line opened in negative direction and its vertex at \( (0,0,P_z)^T \): \[ F(x,y,z) = \frac{x^2}{A^2} + \frac{y^2}{A^2} + (z-P_z) = 0\]

Paraboloid of revolution opened in negative x-direction with its vertex at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = (x-P_x) + \frac{(y-P_y)^2}{A^2} + \frac{(z-P_z)^2}{A^2} = 0\]

Paraboloid of revolution opened in negative y-direction with its vertex at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = \frac{(x-P_x)^2}{A^2} + (y-P_y) + \frac{(z-P_z)^2}{A^2} = 0\]

Paraboloid of revolution opened in negative z-direction with its vertex at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = \frac{(x-P_x)^2}{A^2} + \frac{(y-P_y)^2}{A^2} + (z-P_z) = 0\]

Cone of revolution with x-axis as central line opened in positive direction and its vertex at \( (P_x,0,0)^T \): \[ F(x,y,z) = - sign(x-P_x)\cdot(x-P_x)^2 + \frac{y^2}{A^2} + \frac{z^2}{A^2} = 0\]

Cone of revolution with y-axis as central line opened in positive direction and its vertex at \( (0,P_y,0)^T \): \[ F(x,y,z) = \frac{x^2}{A^2} - sign(y-P_y)\cdot(y-P_y)^2 + \frac{z^2}{A^2} = 0\]

Cone of revolution with z-axis as central line opened in positive direction and its vertex at \( (0,0,P_z)^T \): \[ F(x,y,z) = \frac{x^2}{A^2} + \frac{y^2}{A^2} - sign(z-P_z)\cdot(z-P_z)^2 = 0\]

Cone of revolution opened in positive x-direction with its vertex at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = -sign(x-P_x)\cdot(x-P_x)^2 + \frac{(y-P_y)^2}{A^2} + \frac{(z-P_z)^2}{A^2} = 0\]

Cone of revolution opened in positive y-direction with its vertex at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = \frac{(x-P_x)^2}{A^2} -sign(y-P_y)\cdot(y-P_y)^2 + \frac{(z-P_z)^2}{A^2} = 0\]

Cone of revolution opened in positive z-direction with its vertex at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = \frac{(x-P_x)^2}{A^2} + \frac{(y-P_y)^2}{A^2} - sign(z-P_z)\cdot(z-P_z)^2 = 0\]

Cone of revolution with x-axis as central line opened in negative direction and its vertex at \( (P_x,0,0)^T \): \[ F(x,y,z) = sign(x-P_x)\cdot(x-P_x)^2 + \frac{y^2}{A^2} + \frac{z^2}{A^2} = 0\]

Cone of revolution with y-axis as central line opened in negative direction and its vertex at \( (0,P_y,0)^T \): \[ F(x,y,z) = \frac{x^2}{A^2} + sign(y-P_y)\cdot(y-P_y)^2 + \frac{z^2}{A^2} = 0\]

Cone of revolution with z-axis as central line opened in negative direction and its vertex at \( (0,0,P_z)^T \): \[ F(x,y,z) = \frac{x^2}{A^2} + \frac{y^2}{A^2} + sign(z-P_z)\cdot(z-P_z)^2 = 0\]

Cone of revolution opened in negative x-direction with its vertex at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = sign(x-P_x)\cdot(x-P_x)^2 + \frac{(y-P_y)^2}{A^2} + \frac{(z-P_z)^2}{A^2} = 0\]

Cone of revolution opened in negative y-direction with its vertex at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = \frac{(x-P_x)^2}{A^2} + sign(y-P_y)\cdot(y-P_y)^2 + \frac{(z-P_z)^2}{A^2} = 0\]

Cone of revolution opened in negative z-direction with its vertex at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = \frac{(x-P_x)^2}{A^2} + \frac{(y-P_y)^2}{A^2} + sign(z-P_z)\cdot(z-P_z)^2 = 0\]

Torus of revolution in x-direction with its center at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = \left( \sqrt{(y-P_y)^2 + (z-P_z)^2} - R_2 \right)^2 + (x-P_x)^2 - R_1^2 = 0\]

Torus of revolution in z-direction with its center at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = \left( \sqrt{(x-P_x)^2 + (z-P_z)^2} - R_2 \right)^2 + (y-P_y)^2 - R_1^2 = 0\]

Torus of revolution in z-direction with its center at \( (P_x,P_y,P_z)^T \): \[ F(x,y,z) = \left( \sqrt{(x-P_x)^2 + (y-P_y)^2} - R_2 \right)^2 + (z-P_z)^2 - R_1^2 = 0\]

Datatype for a box represented as a 3x2 matrix with minimum and maximum coordinates in each dimension.

Type for a geometric ray wich has an origin and a direction. To distinguish this type from an optical ray, it is referred to as a halfline or simply a line.