Primitives API
Geometric primitives (circles, ellipses, discs, feature frames, hyperplanes, 3D conics) and their traits and operations. See the Primitives guide.
Primitives and Feature Frames
VisualGeometryToolkitCore.Primitives — Module
PrimitivesGeometric primitives submodule for VisualGeometryToolkitCore.
Provides geometric primitive types and operations:
- Rectangles: Rect constructors from intervals and ranges
- Conics: Ellipse and Circle types with conic matrix representations
- Hyperplanes: Lines in 2D, planes in 3D (generalized hyperplanes)
- Traits: Conic trait system for dispatch
- Operations: Geometric operations (dilate, intersect, containment)
Main Types
Ellipse,Circle,RectHyperplane,Line2D,Plane3DConicTrait,CircleTrait,EllipseTrait
Main Functions
dilate,intersects,gradientis_ellipse,classify_conicsigned_distance,closest_point,normal,offset
Example
using VisualGeometryToolkitCore.Primitives
ellipse = Ellipse(Point2(0.0, 0.0), 5.0, 3.0, π/4)
circle = Circle(Point2(1.0, 2.0), 2.0)
dilated = dilate(circle, 2.0)
# Hyperplanes
line = Line2D(Point2(0.0, 0.0), Point2(1.0, 1.0))
plane = Plane3D(Point3(0.0, 0.0, 0.0), Vec3(0.0, 0.0, 1.0))
d = signed_distance(line, Point2(1.0, 2.0))GeometryBasics.Circle — Type
GeometryBasics.Circle(frame::FeatureFrame, r::Real=1.0) -> CircleConstruct a Circle from a FeatureFrame at the r-σ contour.
For isotropic frames (Disc, OrientedDisc), radius = r * σ. For anisotropic frames (EllipticFrame, AffineFrame), radius = r * characteristic_scale (circumscribed circle).
Example
disc = Disc(Point2(100.0, 200.0), 5.0)
circle = Circle(disc, 3.0) # Circle with radius 15.0 (3σ)VisualGeometryToolkitCore.Primitives.AffineFrame — Type
AffineFrame{T} <: FeatureFrame{T}Full affine feature frame with 6 degrees of freedom: translation (2) + general linear (4).
Defines the transformation: x = A·u + center
where A is a general invertible 2×2 matrix. This maps the unit circle to an oriented ellipse in image space. Invariant to full affine transformations.
The extra degree of freedom compared to EllipticFrame is the in-plane rotation that a symmetric matrix cannot represent.
Fields
center::Point2{T}: Center position in image coordinatesA::SMatrix{2,2,T,4}: Shape factor (general, not necessarily symmetric; shape matrix M = A·Aᵀ)
Decomposition
Any A can be decomposed as A = R(φ)·S where:
- S is symmetric positive-definite (the "pure shape")
- R(φ) is an in-plane rotation (the extra DOF)
Example
A = @SMatrix [2.0 0.5; -0.5 1.0] # general shape factor
frame = AffineFrame(Point2(100.0, 200.0), A)
T = AffineMap(frame) # AffineMap: u → A*u + centerSee also: EllipticFrame
VisualGeometryToolkitCore.Primitives.Ellipse — Type
Ellipse(frame::FeatureFrame, r::Real=1.0) -> EllipseConstruct an Ellipse from a FeatureFrame at the r-σ contour.
For isotropic frames, returns a circle-equivalent ellipse (a == b). For anisotropic frames, computes semi-axes via SVD of the scaled shape factor.
Example
frame = EllipticFrame(Point2(100.0, 200.0), S)
ell = Ellipse(frame, 2.0) # Ellipse at 2σ contourVisualGeometryToolkitCore.Primitives.Ellipse — Method
Ellipse(u::Uncertain{<:FeatureFrame}; sigma = 3) -> EllipseThe sigma-σ error ellipse of an uncertain frame's centre, for every frame: Ellipse(center(u); sigma), the error ellipse of its point observation (center). (A scaled frame's REGION is region(f, k), a different verb.)
VisualGeometryToolkitCore.Primitives.EllipticFrame — Type
EllipticFrame{T} <: FeatureFrame{T}Anisotropic feature frame with 5 degrees of freedom: translation (2) + symmetric shape (3).
Defines the transformation: x = S·u + center
where S is a symmetric positive-definite 2×2 matrix (the shape factor, shape_factor). The shape matrix is M = S·S' = S² (since S is symmetric, shape_matrix): the region is (x-c)ᵀ M⁻¹ (x-c) ≤ 1.
This maps the unit circle to an ellipse in image space. Invariant to affine transformations (up to in-plane rotation).
Fields
center::Point2{T}: Center position in image coordinatesS::SMatrix{2,2,T,4}: Shape factor (symmetric positive-definite)
Relationship to the shape matrix
- Shape factor: S (what we store)
- Shape matrix: M = S² = S·S'
- To get S from M: S = √M (matrix square root)
Example
S = @SMatrix [2.0 0.5; 0.5 1.0] # symmetric shape factor
frame = EllipticFrame(Point2(100.0, 200.0), S)
T = AffineMap(frame) # AffineMap: u → S*u + center
ellipse = region(frame, 2.0) # Ellipse at 2σ contourSee also: AffineFrame, Distributions.MvNormal
VisualGeometryToolkitCore.Primitives.OrientedDisc — Type
OrientedDisc{T} <: FeatureFrame{T}Isotropic feature frame with orientation: 4 degrees of freedom.
Defines the transformation: x = σ·R(θ)·u + center
where R(θ) is a 2D rotation matrix. This maps the unit circle with a marked orientation to an oriented circle in image space. Invariant to full similarity transformations.
Fields
center::Point2{T}: Center position in image coordinatesσ::T: Characteristic scaleθ::T: Dominant orientation in radians (measured from +x axis)
Example
disc = OrientedDisc(Point2(100.0, 200.0), 5.0, π/4)
T = AffineMap(disc) # AffineMap with rotationSee also: Disc, EllipticFrame
VisualGeometryToolkitCore.Primitives.Paraboloid3D — Type
Paraboloid3D{T,P}Quadratic surface z = a₀ + b'x + x'Cx over a 2D domain.
The type parameter P encodes the number of free parameters:
P=6: Full anisotropic —bandCare freeP=4: Isotropic with center —C = cI,bis freeP=2: Fixed-center isotropic —C = cI,b = 0
Storage is always the full (a₀, b, C) so the geometric interface (shape_matrix, is_peak, EllipticFrame) works uniformly.
Fields
a₀::T: Intercept (peak value)b::SVector{2,T}: Linear gradientC::SMatrix{2,2,T,4}: Quadratic Hessian (neg-def for valid peaks)
Constructors
Paraboloid3D(θ::SVector{6}): Full anisotropic{T,6}Paraboloid3D(θ::SVector{4}): Isotropic with center{T,4}Paraboloid3D(θ::SVector{2}): Fixed-center isotropic{T,2}Paraboloid3D(d::Disc, a₀): From detection{T,2}
See also: shape_matrix, is_peak, coeffs, EllipticFrame
VisualGeometryToolkitCore.Primitives.Paraboloid3D — Method
Paraboloid3D(d::Disc, a₀::Real) -> Paraboloid3D{T,2}Construct a fixed-center isotropic paraboloid from a Disc detection.
The disc's scale σ maps to the quadratic coefficient c = -1/(2σ²), with zero center offset (b = 0). The intercept a₀ is typically the peak log-intensity z_max = log(max inverted intensity).
VisualGeometryToolkitCore.Primitives.Paraboloid3D — Method
Paraboloid3D{T,Q}(p::Paraboloid3D{T,P}) -> Paraboloid3D{T,Q}Promote (or demote) a paraboloid to a different parameter count Q. The underlying storage (a₀, b, C) is unchanged — only the type tag changes.
VisualGeometryToolkitCore.Primitives.coeffs — Method
coeffs(p::Paraboloid3D{T,P}) -> SVector{P,T}Return the free paraboloid coefficients. The size is determined by P:
P=6:[a₀, bx, by, Cxx, Cxy, Cyy](full anisotropic)P=4:[a₀, bx, by, c](isotropic with center)P=2:[a₀, c](fixed-center isotropic)
VisualGeometryToolkitCore.Primitives.frame_dof — Method
frame_dof(::Type{<:FeatureFrame}) -> Int
frame_dof(f::FeatureFrame) -> IntThe frame's degrees of freedom, the size of its parameter vector and of an uncertain frame's covariance: PointFrame 2, Disc 3, OrientedDisc 4, EllipticFrame 5, AffineFrame 6. The covariance's coordinates are the centre (x, y) first, then the shape's in the producer's documented chart (a Disc's log σ), so its first 2×2 block is always the centre's (center).
VisualGeometryToolkitCore.Primitives.is_peak — Method
is_peak(p::Paraboloid3D) -> BoolWhether the paraboloid opens downward (its quadratic form is negative definite) — i.e. the fitted surface has a maximum, as expected for a bright-blob response peak. See Paraboloid3D.
VisualGeometryToolkitCore.Primitives.is_peak — Method
is_peak(C::StaticMatrix{2, 2}) -> BoolWhether the quadratic form C of a paraboloid z = a₀ + bᵀx + xᵀCx opens downward (negative definite: C₁₁ < 0, det C > 0): the paraboloid's peak test on its 2×2 coefficients, closed form and kernel-callable — a device fit that holds (C₁₁, C₁₂, C₂₂) tests is_peak(C) and then is_valid_shape(-C; max_aspect_ratio) without building a Paraboloid3D.
VisualGeometryToolkitCore.Primitives.is_positive_definite — Method
is_positive_definite(M::StaticMatrix{N, N}) -> Bool
is_positive_definite(M::AbstractMatrix) -> BoolPositive-definiteness by Sylvester's criterion: every leading principal minor of the symmetric M is positive. A static N × N matrix tests all N minors, unrolled in plain arithmetic (N ≤ 3: the cofactor expansions; larger N: StaticArrays' det of each leading block); any other matrix tests its leading 2×2 block. At N = 2 the expression is M[1,1] > 0 && M[1,1]·M[2,2] − M[1,2]·M[2,1] > 0, as before. Allocation-free and kernel-callable (no factorization). The test behind is_valid_shape (and, negated, behind is_peak); λ_min(M) > c is is_positive_definite(M − c·I). Public, not exported.
VisualGeometryToolkitCore.Primitives.is_valid_shape — Method
is_valid_shape(S; max_aspect_ratio=DEFAULT_MAX_ASPECT_RATIO) -> BoolCheck that a 2×2 shape factor is positive-definite and has aspect_ratio√(σ_max/σ_min) ≤ max_aspect_ratio (the frame's, of EllipticFrame(c, S)). Closed form, without building the frame or a decomposition: σ_max·σ_min = |det S| and σ_max² + σ_min² = ‖S‖²_F, so with r = σ_max/σ_min ≥ 1 and k = max_aspect_ratio the test √r ≤ k is r + 1/r ≤ k² + 1/k², i.e. ‖S‖²_F ≤ (k² + k⁻²)·|det S|. Allocation-free and branch-light in the element type: callable inside a kernel on a static 2×2 (a fitted peak's negated quadratic form -C after is_peak).
VisualGeometryToolkitCore.Primitives.Disc — Type
Disc{T} <: FeatureFrame{T}Isotropic feature frame with 3 degrees of freedom: translation (2) + scale (1).
Defines the transformation: x = σ·u + center
This maps the unit circle in canonical space to a circle of radius σ in image space. Invariant to similarity transformations (up to rotation).
Fields
center::Point2{T}: Center position in image coordinatesσ::T: Characteristic scale (not a boundary radius!)
Example
disc = Disc(Point2(100.0, 200.0), 5.0)
T = AffineMap(disc) # AffineMap: u → 5*u + [100, 200]
circ = region(disc, 3.0) # Circle at 3σSee also: OrientedDisc, EllipticFrame
VisualGeometryToolkitCore.Primitives.PointFrame — Type
PointFrame{T} <: FeatureFrame{T}A point feature, the 2-DOF member of the FeatureFrame family: a position and nothing else — no scale, no orientation, no shape. What a detector that locates points without a size estimate returns (a corner, the centre of a rotationally symmetric pattern). Its uncertainty is a 2×2 position covariance, Uncertain(PointFrame(c), CovMat{2}(…)), whose Ellipse is the error ellipse, and whose point observation is center(u).
It is first-class: every verb every frame has (the FeatureFrame interface table, conventions/feature-frames.md) reaches it through the hoisted code, with no copy of its own, and it costs what a Point2 costs (isbits, the layout of Point2{T}). With no scale, the scaled frames' verbs — scale, shape_factor, shape_matrix, AffineMap, region, Circle, Ellipse(frame, r), characteristic_scale, aspect_ratio, boundary_point, MvNormal, intersects — are absent by design: each is a MethodError whose hint says so.
Fields
center::Point2{T}: the position in image coordinates
Example
julia> using VisualGeometryToolkitCore
julia> p = Uncertain(PointFrame(10.0, 20.0), CovMat{2, Float64}(4.0, 0.0, 0.0, 1.0));
julia> e = Ellipse(p; sigma = 1); # the 1σ error ellipse
julia> (e.center, e.a, e.b)
([10.0, 20.0], 2.0, 1.0)
julia> VisualGeometryToolkitCore.center(p) == Uncertain(Point2(10.0, 20.0), CovMat{2, Float64}(4.0, 0.0, 0.0, 1.0)) # its point observation
trueSee also: Disc
Hyperplanes
VisualGeometryToolkitCore.Primitives.Hyperplane — Type
Hyperplane{M,N,T}An M-dimensional hyperplane represented by normalized homogeneous coefficients.
The equation a₁x₁ + a₂x₂ + ... + aₘxₘ + d = 0 is stored as [a₁, ..., aₘ, d] where the normal [a₁, ..., aₘ] is automatically normalized to unit length.
Type Parameters
M: Ambient space dimension (2 for lines, 3 for planes)N: Number of coefficients (always M+1)T: Coefficient type
Properties
normal(h): Unit normal vector [a₁, ..., aₘ]offset(h): Signed distance from origin (-d when normal is unit)
Examples
# 2D line: x - y = 0 (diagonal through origin)
line = Hyperplane(SVector(1.0, -1.0, 0.0))
line = Line2D(1.0, -1.0, 0.0)
# 3D plane: z = 5 (horizontal plane at height 5)
plane = Hyperplane(SVector(0.0, 0.0, 1.0, -5.0))
plane = Plane3D(Point3(0,0,5), Vec3(0,0,1))
# Point-to-hyperplane signed distance
d = signed_distance(line, Point2(1.0, 2.0))
# Closest point on hyperplane (orthogonal projection)
p_closest = closest_point(line, Point2(1.0, 2.0))VisualGeometryToolkitCore.Primitives.Line2D — Type
2D line (hyperplane in 2D): ax + by + c = 0
VisualGeometryToolkitCore.Primitives.Line2D — Method
Line2D(p::Point2, q::Point2) -> Line2DConstruct a 2D line through two points.
VisualGeometryToolkitCore.Primitives.Line2D — Method
Line2D(ρ, θ) -> Line2DConstruct a 2D line in Hesse normal form (distance ρ from origin, angle θ). The line equation is: x·cos(θ) + y·sin(θ) - ρ = 0
VisualGeometryToolkitCore.Primitives.Line2D — Method
Line2D(p::Point2, n::Vec2) -> Line2DConstruct a 2D line from a point on the line and a normal vector.
VisualGeometryToolkitCore.Primitives.Plane3D — Type
3D plane (hyperplane in 3D): ax + by + cz + d = 0
VisualGeometryToolkitCore.Primitives.Plane3D — Method
Plane3D(p1::Point3, p2::Point3, p3::Point3) -> Plane3DConstruct a 3D plane from three non-collinear points. The normal direction follows the right-hand rule for p1→p2→p3.
VisualGeometryToolkitCore.Primitives.Plane3D — Method
Plane3D(point::Point3, normal::Vec3) -> Plane3DConstruct a 3D plane from a point on the plane and a normal vector.
VisualGeometryToolkitCore.Primitives.Plane3D — Method
Plane3D{T}() -> Plane3D{T}Construct the canonical z=0 plane.
VisualGeometryToolkitCore.Primitives.clip_to_rect — Method
clip_to_rect(l::Line2D, rect::Rect2) -> GeometryBasics.Line{2,T} or nothingClip the infinite 2D line l to the axis-aligned rectangle rect, returning the line segment (as GeometryBasics.Line) of the portion inside. Returns nothing if the line misses the rectangle.
Liang-Barsky clipping on the parametric line p(t) = p₀ + t·(−b, a), where p₀ = (−ac, −bc) is the closest point to the origin (uses ‖(a,b)‖=1).
VisualGeometryToolkitCore.Primitives.coeffs — Method
The normalized coefficients (n..., d) of a Hyperplane: n·x + d = 0, |n| = 1.
VisualGeometryToolkitCore.Primitives.intercept — Method
Y-intercept of line. Returns Inf for vertical lines.
VisualGeometryToolkitCore.Primitives.ray_plane_intersection — Method
ray_plane_intersection(plane, origin, dir_x, dir_y, dir_z)
-> (x, y, z, t)
ray_plane_intersection(plane, o_x, o_y, o_z, dir_x, dir_y, dir_z)
-> (x, y, z, t)Broadcasted ray–plane intersection over structure-of-arrays ray bundles: the world-space hit points and ray parameters of the rays origin + t·dir against plane (convention n·x + d = 0). The first form shares one origin::StaticVector{3} across the bundle; the second takes per-ray origin component arrays (finite-aperture cameras, multi-bounce tracers). Rays parallel to the plane divide by zero and produce ±Inf/NaN components — callers mask by validity, the kernel never throws.
The plane is a CONSTANT of the computation: its scalars are extracted once before the broadcast and the extraction is @non_differentiable under the ChainRulesCore extension; gradients flow through origins and directions only.
VisualGeometryToolkitCore.Primitives.side — Method
side(h::Hyperplane, p) -> IntReturn which side of the hyperplane p is on:
+1if on positive side (same direction as normal)-1if on negative side0if on the hyperplane (within tolerance)
VisualGeometryToolkitCore.Primitives.slope — Method
Slope of line (dy/dx). Returns Inf for vertical lines.
The Surface a Ray Meets
Two isbits primitives behind one protocol — intersection(s, o, d), normal(s, x), chart(s, x), its inverse surface_point(s, uv) and bounds(s) — generic in the element type (Float32, Float64, ForwardDiff.Dual), allocation-free and usable in a KernelAbstractions kernel. A ray is an origin and a direction in the surface's frame and units, as ray_plane_intersection takes it, and a half-line (t ≥ 0). A Quad is a bounded plane, its intersection ray_plane_intersection's arithmetic bit for bit; a MappedSurface is the surface of a chart map — a deformed posed target's pose ∘ S₃ ∘ lift ∘ C ∘ S₂⁻¹ — its intersection a 2 × 2 root in the chart (the spline models' static LM behind one internal function, the implicit function theorem for Duals, nested ones included). The chart is the DESIGN chart, so a pattern lookup uses nominal coordinates. A ray that misses (parallel, behind the origin, outside the rectangle, or not converging) gives NaN. The normal is geometric, the frame's e_u × e_v; flip it against the ray for a camera-facing one. A posed target's primitive is surface(pt) (Imaging Chain and Stereo API).
s = surface(PosedTarget(target, pose)) # a Quad, or a MappedSurface for a deformed target
t, x = VisualGeometryToolkitCore.intersection(s, o, d)
uv = VisualGeometryToolkitCore.chart(s, x) # the design coordinates of the hitA caller that keeps a ray's hit and later needs its derivatives (a renderer's record, then a Jacobian in the surface's parameters) calls intersection_at(s, o, d, x₀) with the plain hit x₀: a height field's surface takes the implicit-function step there and solves no root again.
VisualGeometryToolkitCore.Quad — Type
Quad(origin, frame, rect::Rect2, A = I, b = 0)
Quad{T}(q::Quad)A bounded plane. frame is a right-handed orthonormal 3 × 3 matrix (a rotation) whose columns are the in-plane basis e_u, e_v and the normal n = e_u × e_v; a point with metric plane coordinates m is origin + m₁ e_u + m₂ e_v. The CHART is c with m = A c + b (A an invertible 2 × 2 matrix, inverted once here), and rect is a rectangle in the chart. A left-handed or non-orthonormal frame (to 64 eps of the frame's element type: 1.4e-14 in Float64, 7.6e-6 in Float32), a singular A or a negative width is an ArgumentError. Quad{T}(q) converts the element type (Float32 for a device).
isbits. intersection is ray_plane_intersection's arithmetic, bit for bit, NaN when t < 0 or the hit's chart is outside rect; chart(q, x) = A⁻¹ (m − b); surface_point its inverse; bounds is rect. normal is the GEOMETRIC normal n on either side: a consumer that wants the normal facing the camera flips it against the ray (shading, not geometry). A rigid or affine-calibrated target's surface is a Quad.
Under ChainRules (reverse mode) the plane is a constant of ray_plane_intersection, so a Quad's intersection carries no gradient to its pose; ForwardDiff does.
VisualGeometryToolkitCore.bounds — Function
bounds(s) -> Rect2The rectangle of chart coordinates the surface s covers (chart).
VisualGeometryToolkitCore.chart — Function
chart(s, x) -> SVector{2}The chart coordinates (u, v) of the point x of the surface s — the DESIGN chart (for surface(pt), the coordinates of the target's nominal points). For a Quad the projection of x − o on its in-plane basis, then the inverse of its in-plane affine (the print's calibration; the component along the normal is ignored); for a MappedSurface the chart point whose image is x. x is in the surface's frame and units, as for intersection; surface_point is the inverse.
VisualGeometryToolkitCore.intersection — Function
intersection(s, o, d) -> (t, x)Where the ray o + t d, t ≥ 0 (origin o, direction d, both 3-vectors; d need not be unit) meets the surface s: the ray parameter t and the point x. The ray and x are in the surface's frame — for surface(pt) the pose's destination frame F — and its units (metres when the target is physical). A ray that misses — parallel to a plane, hitting behind its origin (t < 0), hitting outside bounds(s), or (a MappedSurface) not converging — returns t and every coordinate of x as NaN, never an error. Methods: Quad (closed form, the arithmetic of ray_plane_intersection) and MappedSurface (a 2 × 2 root in its chart). Allocation-free and generic in the element type, so it runs on the GPU path and under ForwardDiff (a MappedSurface's root by the implicit function theorem).
VisualGeometryToolkitCore.intersection_at — Function
intersection_at(s, o, d, x₀) -> (t, x)intersection(s, o, d) for a caller that already holds the hit point x₀ in plain numbers — the point intersection returns for the same surface and ray with every ForwardDiff.Dual layer stripped (a hit kept from an earlier evaluation: a renderer's record, a residual's). Where the surface has a method for it, no root is solved:
- a
MappedSurfaceof aHeightFieldalone or over the planar affine factors, with ONE layer of Duals anywhere (the field's heights, the placement, the pose, the ray): the implicit-function step atx₀, one evaluation of the chart map on the Dual parts, whereintersectionfirst runs its Newton on the values and then takes the same step. The hit's value is the surface's point atx₀'s design point; its partials areintersection's to rounding; - the same surface with plain parts:
(t, x₀),tthe ray parameter ofx₀; - every other surface and nested Duals:
intersection(s, o, d),x₀unused.
x₀ is trusted: a point that is not the ray's hit gives the partials of nothing. A miss is a non-finite x₀ (as intersection returns it) or, in the Dual step, a design point off the rectangle: t and every coordinate of x are NaN.
VisualGeometryToolkitCore.surface — Function
surface(pt::PosedTarget{<:PlanarTarget}) -> Quad | MappedSurfaceThe surface a ray meets on the posed planar target pt, in the pose's destination frame, its CHART the design chart (so chart of a hit is the nominal coordinates it shows). Its rectangle, in that chart, is Rect(board(t)) when the target has a Board, else the design bounding box — either grown by 16 eps of its coordinates, the margin within which PlanarTarget accepts a point on its board, so a ray at a point on the edge is a hit (up to the chart's own rounding).
- A planar affine calibration (
Rigid, the factorsEuclideanMap ∘ Scale ∘ Aspect ∘ Skewor any of them) gives aQuad: the target's TargetFrame placed bypose(pt)(origin its translation,e_u,e_vand the normal the rotation's columns), the calibration its affine (placed:A p + b,b = s β − (A − I) o). - Any other — a
HeightField, an in-planeThinPlateSpline, either after the affine factors (HeightField ∘ ThinPlateSpline ∘ Aspect ∘ Skew) — gives theMappedSurfaceof the composed chart mappose ∘ S₃ ∘ lift ∘ C ∘ S₂⁻¹(the pose, theplacementS₃and its in-plane partS₂, the calibrationC, the lift(c, 0)of a planar one), built byMappedSurface(pose, calibration, placement, rect). Heights are along TargetFrame +z.
A physical target (metres) gives a primitive in metres, plain numbers. An uncertain pose or calibration gives its value. A PointTarget has no surface (a MethodError). The kind is chosen by the calibration's type, so a rigid target's ray caster never compiles the root.
VisualGeometryToolkitCore.surface_point — Function
surface_point(s, uv) -> SVector{3}The point of the surface s at chart coordinates uv (the inverse of chart): a Quad's in-plane affine applied and placed in its frame, a MappedSurface's chart map. In the surface's frame and units.
VisualGeometryToolkitCore.Cameras.MappedSurface — Type
MappedSurface(map, frame::Quad)A surface given by its CHART MAP: the points map(p) (3-vectors in the surface's frame) of the chart points p in the rectangle bounds(s) = bounds(frame). map is any isbits CoordinateTransformations Transformation of a 2-vector to a 3-vector with a transform_deriv (its point Jacobian, 3 × 2) — for a posed target's surface, the composition pose ∘ S₃ ∘ lift ∘ C ∘ S₂⁻¹ of its pose, its placement, its calibration and the placement's inverse on the design chart, so the chart is the DESIGN chart. frame is the plane the map deforms (the posed target's z = 0 plane, its rectangle the chart's bounds): it seeds the solves and orients the normal.
intersection solves for the chart point of the hit, p, such that map(p) lies on the ray: the two components of map(p) − o across the ray (u₁, u₂, an orthonormal pair perpendicular to d) vanish — a 2 × 2 least-squares root through transform_deriv, seeded at the chart coordinates of the frame's plane hit and bounded to the chart's rectangle — and the hit is x = map(p), t = (x − o)·d / (d·d). A ray misses (NaN) when the plane hit does not exist, the solve does not converge within the rectangle, or t < 0. chart(s, x) is the same root for the residual map(p) − x, surface_point(s, p) = map(p), and normal the unit ∂map/∂p₁ × ∂map/∂p₂ at the point's chart point (geometric: on the side of the frame's normal for a chart map of positive orientation).
Generic in the element type (Float32, Float64, ForwardDiff Duals, nested ones included) and allocation-free: under ForwardDiff the root is solved on the values and differentiated by the implicit function theorem, one layer at a time — never by differentiating the iteration.
VisualGeometryToolkitCore.Cameras.MappedSurface — Method
MappedSurface(pose, calibration, placement, rect::Rect2) -> MappedSurfaceThe deformed surface of a posed planar target from its parts — THE builder: surface(pt) builds it from the target's stored parts. The chart map is the composition
pose ∘ S₃ ∘ lift ∘ C ∘ S₂⁻¹ (design chart → the pose's frame)of the pose (an EuclideanMap{3}, plain numbers), the placement S₃ (a SimilarityMap{3} or nothing, see placement) and its in-plane part's inverse S₂⁻¹, the calibration C (any kind or composition, plain numbers) and, for a planar calibration, the lift (c, 0). rect is the design chart's rectangle. Each member is a CoordinateTransformations map with its transform_deriv; the composition's derivative is CT's chain rule.
This form checks its parts (the calibration's composition, the placement, the pose's frame), on the host. A device caller — a kernel that rebuilds a HeightField or ThinPlateSpline from new nodal values by with_parameters on its adapted solver — calls the unchecked inner builder VisualGeometryToolkitCore.Cameras._mapped_surface(pose, calibration, placement, rect) with parts it has checked once on the host; it keeps the parts' element type (an unplaced target gets the identity placement in that type).
VisualGeometryToolkitCore.Cameras.with_parameters — Method
with_parameters(s::MappedSurface, θ::AbstractVector) -> MappedSurfaceThe surface s with its calibration rebuilt from the parameters θ: the chart map's calibration member C (a HeightField, a ThinPlateSpline, or a composition with the affine factors) replaced by with_parameters(C, θ) — θ in C's parameter_names order, in the numbers the surface was built in (plain metres for a physical target; a thin-plate kind projects them onto its pure-bending subspace) — and every other member (the pose, the placement, the lift) and the frame kept as they are. A surface on the device stays on the device (the kind's with_parameters on its adapted solver), and θ may be of any element type (Float32, ForwardDiff Duals): a warped board's surface at new nodal heights inside a kernel, with no rebuild from the target's parts (the checked MappedSurface(pose, calibration, placement, rect)).
Conics and 3D Primitives
GeometryBasics.Circle — Type
GeometryBasics.Circle(det::AbstractDetection, cutoff::Real=1.0) -> CircleConstruct a unitless GeometryBasics.Circle from a detection with radius cutoff * σ (σ the frame's characteristic_scale), through the checked unit strip. The geometry is the detection's feature_frame, so a detection of an Uncertain frame gives the circle of its frame.
GeometryBasics.Circle — Method
Circle(Q::Union{HomCircleMat, HomEllipseMat, Conic}) -> CircleThe circle of a conic matrix. A HomCircleMat is one by its class; an ellipse's or a general conic's matrix is checked by THE circle predicate, the HomCircleMat class check (isotropy within √eps · ‖A‖, relative, so a large circle is read as a small one is), with its ArgumentError.
VisualGeometryToolkitCore.Primitives.Ellipse — Type
Ellipse{T}Semantic ellipse representation with center, semi-major axis a, semi-minor axis b, and orientation angle θ in radians.
The constructor automatically ensures a ≥ b by swapping axes and adjusting the angle if needed.
Fields
center::Point2{T}: Center coordinates (cx, cy)a::T: Semi-major axis length (always ≥ b)b::T: Semi-minor axis length (always ≤ a)θ::T: Orientation angle in radians [0, π)
Constructors
# Basic constructor with Point2 center
ellipse = Ellipse(Point2(1.0, 2.0), 3.0, 2.0, π/4)
# Constructor with vector center (automatically converted to Point2)
ellipse = Ellipse([1.0, 2.0], 3.0, 2.0, π/4)
# Mixed numeric types are automatically promoted
ellipse = Ellipse([1, 2], 3.0f0, 2, π/4)Integration with GeometryBasics
# Generate boundary points using GeometryBasics.coordinates
points = GeometryBasics.coordinates(ellipse, 64)
# Access geometric properties
center = GeometryBasics.coordinates(ellipse) # Returns ellipse.center
major_radius = GeometryBasics.radius(ellipse) # Returns max(a, b)VisualGeometryToolkitCore.Primitives.Ellipse — Method
Ellipse(center, A::AbstractMatrix)Refused: a plain 2×2 matrix is ambiguous — it could be a shape matrix M ((x-c)ᵀ M⁻¹ (x-c) = 1, the 1σ contour of a covariance M) or a shape factor A with M = A·A', and for symmetric input the two interpretations silently differ by a squaring. Say which one you mean:
- shape matrix:
Ellipse(center, Symmetric(M)) - shape factor (e.g. Baumberg adaptation):
Ellipse(center, Symmetric(A * A'))
VisualGeometryToolkitCore.Primitives.Ellipse — Method
Ellipse(center, Σ::Symmetric) -> EllipseConstruct an ellipse from its 2×2 shape matrix (symmetric PD; a covariance's 1σ contour). The boundary is {x : (x-c)ᵀ Σ⁻¹ (x-c) = 1}.
Semi-axes are √λᵢ where λᵢ are eigenvalues of Σ.
Σ = Symmetric([4.0 1.0; 1.0 9.0])
e = Ellipse(Point2(100.0, 200.0), Σ)VisualGeometryToolkitCore.Primitives.Ellipse — Method
Ellipse(d::Uncertain{<:AbstractVector, <:Union{CovMat{2}, PrecMat{2}}}; sigma=3) -> EllipseThe sigma-σ confidence ellipse of an uncertain 2D point: Ellipse(center, Σ::Symmetric) at its covariance cov(d) (a stored precision is inverted once), semi-axes scaled by sigma.
Σ = CovMat{2,Float64}(4.0, 1.0, 1.0, 9.0)
e = Ellipse(Uncertain(Point2(123.4, 56.7), Σ); sigma=3)
Λ = PrecMat{2,Float32}(2.0f0, 0.1f0, 0.1f0, 3.0f0)
e = Ellipse(Uncertain(Point2(123.4, 56.7), Λ); sigma=3)VisualGeometryToolkitCore.Primitives.Ellipse — Method
Ellipse(c::Circle) -> EllipseConvert a Circle to an Ellipse with equal semi-axes.
Example
circle = Circle(Point2(100.0, 200.0), 5.0)
ellipse = Ellipse(circle) # Ellipse with a=b=5.0, θ=0VisualGeometryToolkitCore.Primitives.Ellipse — Method
Ellipse(Q::Union{HomEllipseMat{T}, HomCircleMat{T}}) -> Ellipse{T}Extract Ellipse from conic matrix Q using robust eigenvalue decomposition.
VisualGeometryToolkitCore.Primitives.gradient — Method
gradient(Q::HomEllipseMat{T}, p::Point2{T}) -> Vec2{T}Compute the gradient of the conic implicit function at point p.
For conic equation x^T Q x = 0, the gradient is ∇f(x) = 2Qx (homogeneous form). Returns the 2D Euclidean gradient [∂f/∂x, ∂f/∂y] as a Vec2 — it's a direction (steepest-ascent), not a position: the point-on-conic constraint's observation gradient (constraint_with_jacobians(::Conic, p)'s G_x).
VisualGeometryToolkitCore.Primitives.is_ellipse — Method
is_ellipse(Q) -> BoolWhether Q — a conic matrix, an Ellipse or a Circle — is a real, non-degenerate ellipse: classify_conic answering EllipseTrait or CircleTrait, so the two can never disagree.
VisualGeometryToolkitCore.Primitives.Circle3D — Type
Circle3D{T}A planar circle embedded in 3D space.
Fields
center::Point3{T}: Center point of the circleradius::T: Radius of the circleu::Vec3{T}: First basis vector in circle's plane (unit length)v::Vec3{T}: Second basis vector in circle's plane (unit length, perpendicular to u)
Properties
The circle boundary is parameterized as:
p(θ) = center + radius * (cos(θ) * u + sin(θ) * v)The normal is cross(u, v).
Example
# Circle centered at origin, in xy-plane, radius 3
c3d = Circle3D(Point3(0.0, 0.0, 0.0), 3.0)
# Transform with rigid motion
E = EuclideanMap(R, t)
c3d_transformed = E(c3d)
# Sample boundary point
θ = π/4
p = centroid(c3d) + c3d.radius * (cos(θ) * c3d.u + sin(θ) * c3d.v)VisualGeometryToolkitCore.Primitives.Circle3D — Method
Circle3D(c::Circle) -> Circle3DEmbed 2D circle into 3D in the xy-plane at z=0.
VisualGeometryToolkitCore.Primitives.Circle3D — Method
Circle3D(center::Point3, radius) -> Circle3DConstruct a circle in the xy-plane (normal = +z).
VisualGeometryToolkitCore.Primitives.Circle3D — Method
Circle3D(center::Point3, radius, normal::Vec3) -> Circle3DConstruct a circle from center, radius, and normal vector.
Automatically generates orthonormal basis vectors u, v in the circle's plane.
VisualGeometryToolkitCore.Primitives.Circle3D — Method
Circle3D(c::Circle, E::EuclideanMap{3}) -> Circle3DEmbed a 2D circle into 3D using a Euclidean frame.
The EuclideanMap E defines how the local xy-plane maps to world coordinates.
VisualGeometryToolkitCore.Primitives.Ellipse3D — Method
Ellipse3D(c::Circle3D) -> Ellipse3DConvert a Circle3D to an Ellipse3D (axisa = radius*u, axisb = radius*v).
VisualGeometryToolkitCore.Primitives.AbstractConic3D — Type
AbstractConic3D{T}Abstract supertype for planar conic sections embedded in 3D space.
Subtypes must have a center::Point3{T} field and implement:
_axis_a(c)::SVector{3,T}— first axis vector (direction × length)_axis_b(c)::SVector{3,T}— second axis vector (perpendicular to first)
The boundary is parameterized as: p(θ) = center + cos(θ)*axis_a + sin(θ)*axis_b
VisualGeometryToolkitCore.Primitives.Ellipse3D — Type
Ellipse3D{T}A planar ellipse embedded in 3D space, represented by center and axis vectors.
Fields
center::Point3{T}: Center point of the ellipse (3 DOF)axis_a::Vec3{T}: Semi-major axis vector (3 DOF)axis_b::Vec3{T}: Semi-minor axis vector, perpendicular to axis_a (2 DOF)
Properties
The ellipse boundary is parameterized as:
p(θ) = center + cos(θ) * axis_a + sin(θ) * axis_bExample
# Ellipse centered at origin, in xy-plane, semi-axes 3 and 2
e3d = Ellipse3D(
Point3(0.0, 0.0, 0.0),
Vec3(3.0, 0.0, 0.0), # semi-major along x
Vec3(0.0, 2.0, 0.0) # semi-minor along y
)
# Transform with rigid motion
E = EuclideanMap(R, t)
e3d_transformed = E(e3d)
# Sample boundary point
θ = π/4
p = centroid(e3d) + cos(θ) * e3d.axis_a + sin(θ) * e3d.axis_bVisualGeometryToolkitCore.Primitives.Ellipse3D — Method
Ellipse3D(e::Ellipse) -> Ellipse3D
Ellipse3D(c::Circle) -> Ellipse3DEmbed 2D shape into 3D in the xy-plane at z=0.
VisualGeometryToolkitCore.Primitives.Ellipse3D — Method
Ellipse3D(c::Circle, E::EuclideanMap{3}) -> Ellipse3DEmbed a 2D circle into 3D using a Euclidean frame.
VisualGeometryToolkitCore.Primitives.Ellipse3D — Method
Ellipse3D(e::Ellipse, E::EuclideanMap{3}) -> Ellipse3DEmbed a 2D ellipse into 3D using a Euclidean frame.
The EuclideanMap E defines how the local xy-plane (containing the 2D ellipse) maps to world coordinates:
E.Rrotates the xy-plane to its 3D orientationE.ttranslates the local origin to its 3D position
Example
# Place ellipse in xy-plane at z=5
E = EuclideanMap(I, SVector(0, 0, 5))
e3d = Ellipse3D(ellipse_2d, E)
# Place ellipse in a tilted plane
R = RotX(π/4) # tilt 45° around x-axis
E = EuclideanMap(R, SVector(0, 0, 0))
e3d = Ellipse3D(ellipse_2d, E)VisualGeometryToolkitCore.Primitives.Disc — Method
Disc(d::AbstractMvNormal) -> DiscConvert an MvNormal to a Disc using the equivalent isotropic scale.
VisualGeometryToolkitCore.Primitives.EllipticFrame — Method
EllipticFrame(d::AbstractMvNormal) -> EllipticFrameConvert an MvNormal to an EllipticFrame for geometric operations.
The frame is the Gaussian's 1σ contour: its shape matrix is the covariance, shape_matrix(frame) = Σ, and its shape factor S = √Σ (symmetric, by eigendecomposition).
Example
d = MvNormal(SVector(100.0, 200.0), SMatrix{2,2}(25.0, 5.0, 5.0, 16.0))
frame = EllipticFrame(d)
ellipse = region(frame, 3.0) # 3σ contourOperations, Containment, and Traits
VisualGeometryToolkitCore.bbox — Method
bbox(shape; scale=1.0, snap_to_grid=false) -> SpatialIndexing.RectGeneric shape bounding box (Circle, Ellipse, …) via the shape's Rect2 extent.
VisualGeometryToolkitCore.bbox — Method
bbox(f::FeatureFrame; scale=1.0, snap_to_grid=false) -> SpatialIndexing.RectBounding box of a feature frame at its scale-σ contour, optionally snapped outward to the pixel grid, through the coordinate compute boundary (a frame in quantities is stripped: pixels in px, lengths in mm). Every frame, on its DOF trait: a PointFrame's is the point (no extent at any scale), an isotropic frame's center ∓ scale·σ (allocation-free), a shape-factor frame's its region(f, scale) ellipse's exact box.
Example
d = Disc(100.5, 200.5, 5.0)
rect = bbox(d; scale=3.0, snap_to_grid=true)VisualGeometryToolkitCore.Primitives.best_iou_match — Method
best_iou_match(query, candidates) -> (idx, iou_value)The candidate with the highest iou against query, as (index, iou); (0, 0.0) when candidates is empty or no pair overlaps. Works for any pair iou accepts (ellipses, circles, mixed).
VisualGeometryToolkitCore.Primitives.iou_below — Method
iou_below(e1::Ellipse, e2::Ellipse, t) -> Booltrue only when iou(e1, e2) < t is PROVEN by a bound that needs no exact intersection, so a pair whose IoU could reach t is never declared below it (false means "not proven", not "at least t"). Three upper bounds on IoU = |A∩B| / |A∪B|, each from |A∪B| ≥ max(|A|, |B|): the area ratio (|A∩B| ≤ min(|A|, |B|)); disjoint circumscribed discs (each ellipse lies in the disc of its semi-major axis about its centre); and those discs' lens (|A∩B| ≤ lens, the two Circles' overlap_area). Each is compared with a relative slack of 1e-6, above the exact IoU's rounding. A pre-filter before iou over many pairs (BlobBoards' guided search).
VisualGeometryToolkitCore.Primitives.homogeneous_w — Method
homogeneous_w(H::StaticMatrix{3, 3}, p::StaticVector{2}) -> RealThe homogeneous coordinate H * [p; 1] produces — the chirality reference for to_euclidean's guarded form and maps_within. Evaluate it once at a point known to be on the visible side (e.g. the plane's own center) and supply it as w_ref.
VisualGeometryToolkitCore.Primitives.maps_within — Method
maps_within(H::StaticMatrix{3, 3}, rect::Rect, p::StaticVector{2}, w_ref::Real) -> BoolDoes p map through the homography H inside rect (closed bounds), on the same side of the plane's horizon as w_ref? The one predicate behind "does this image point back-project onto this board/plane region": points beyond the horizon flip the homogeneous sign and would wrap into the rectangle from behind the camera — w_ref (see homogeneous_w) keeps them out.
VisualGeometryToolkitCore.Primitives.PolygonRegion — Type
PolygonRegion(polygon::Polygon, centre)
PolygonRegion(vertices::AbstractVector{<:StaticVector{2}}, centre)A 2-D region bounded by a simple polygon that is STAR-SHAPED about centre: its vertex ring s.vertices (Point2{Float64}, counter-clockwise; a clockwise ring is reversed; GeometryBasics.Polygon(s) is it as a GeometryBasics Polygon) in the region interface — p ∈ s, the bounding box Rect2(s), ∩ (a RegionIntersection), ⊆ and ∈ of a Rect, intersects(s, rect), pixel_mask, dilate about centre. What valid_domain answers for a lens that is not radially symmetric: its boundary runs through each azimuth's own fold.
Membership is Core's one crossing-number test of a point in a polygon's ring (a Polygon's p ∈ polygon), skipped where it cannot change the answer: a point nearer centre than every edge (s.inner) is in, one farther than every vertex (s.outer) is out — so a pixel mask over a sensor tests the polygon only in the annulus between the two.
On a device: Adapt.adapt(backend, s) moves the vertex ring (the region is parametrized on its container, one implementation for host and device), and p ∈ s evaluates inside a KernelAbstractions kernel as on the host; so does an intersection holding it (an imaged_region). The other operations (containment, intersects, dilate, pixel_mask) are host-side.
The constructor refuses (ArgumentError) a ring of fewer than 3 vertices, or one that is not star-shaped about centre (every edge must turn the same way about it, once round).
VisualGeometryToolkitCore.Primitives.RegionIntersection — Type
RegionIntersection{A, B}The intersection a ∩ b of two 2-D regions, held lazily: a point is in it when it is in both (p ∈ s ⟺ p ∈ s.a && p ∈ s.b), and its bounding box is the intersection of the two bounding boxes, Rect2(s) == Rect2(s.a) ∩ Rect2(s.b) (so bbox works on it). Built by Base.intersect (∩) of a Rect, an Ellipse or another intersection, in any order and nesting (a Circle enters as its Ellipse):
domain = Rect(0, 0, 1920, 1200) ∩ Ellipse(Point2(960.0, 600.0), 700.0, 700.0, 0.0)
Point2(960.0, 100.0) ∈ domain # true: inside both
Point2(10.0, 10.0) ∈ domain # false: in the rect, outside the ellipse
Rect2(domain) # the rect clipped to the ellipse's boxThe identity of ∩ is WholePlane: r ∩ WholePlane() === r (what valid_domain answers for a lens with no limit of its own).
Containment s ⊆ region (a Rect, an Ellipse, an intersection or the WholePlane; a Circle as its Ellipse) never answers true for an s that is not contained, to the rounding of its membership tests (and Ellipse ⊆ Ellipse's relative slack of 8 eps). Into an intersection it is s ⊆ a && s ⊆ b, as exact as those two. Into a Rect or an Ellipse it is sufficient, not exact: true when the bounding box of s lies in the region (or, for an Ellipse, when either part does), so neither part alone need fit. That box is the meet of the parts' boxes, which can reach out of the region where s does not; a true containment then answers false, and so does an empty intersection (disjoint boxes).
VisualGeometryToolkitCore.Primitives.WholePlane — Type
WholePlane()The whole plane as a 2-D region: the identity of ∩. Every point is in it (p ∈ WholePlane()), every rectangle lies inside it (r ∈ WholePlane()), and a ∩ WholePlane() === a for any region a (in either order). It has no bounding box: Rect2(WholePlane()) is an ArgumentError. It is what valid_domain answers for a lens with no limit of its own, so Rect(extent) ∩ valid_domain(camera) and Rect(extent) ∈ valid_domain(camera) read the same for every lens, and what imaged_region is given when no image circle is known.
Index
VisualGeometryToolkitCore.PrimitivesGeometryBasics.CircleGeometryBasics.CircleGeometryBasics.CircleVisualGeometryToolkitCore.Cameras.MappedSurfaceVisualGeometryToolkitCore.Cameras.MappedSurfaceVisualGeometryToolkitCore.Primitives.AbstractConic3DVisualGeometryToolkitCore.Primitives.AffineFrameVisualGeometryToolkitCore.Primitives.Circle3DVisualGeometryToolkitCore.Primitives.Circle3DVisualGeometryToolkitCore.Primitives.Circle3DVisualGeometryToolkitCore.Primitives.Circle3DVisualGeometryToolkitCore.Primitives.Circle3DVisualGeometryToolkitCore.Primitives.DiscVisualGeometryToolkitCore.Primitives.DiscVisualGeometryToolkitCore.Primitives.EllipseVisualGeometryToolkitCore.Primitives.EllipseVisualGeometryToolkitCore.Primitives.EllipseVisualGeometryToolkitCore.Primitives.EllipseVisualGeometryToolkitCore.Primitives.EllipseVisualGeometryToolkitCore.Primitives.EllipseVisualGeometryToolkitCore.Primitives.EllipseVisualGeometryToolkitCore.Primitives.EllipseVisualGeometryToolkitCore.Primitives.Ellipse3DVisualGeometryToolkitCore.Primitives.Ellipse3DVisualGeometryToolkitCore.Primitives.Ellipse3DVisualGeometryToolkitCore.Primitives.Ellipse3DVisualGeometryToolkitCore.Primitives.Ellipse3DVisualGeometryToolkitCore.Primitives.EllipticFrameVisualGeometryToolkitCore.Primitives.EllipticFrameVisualGeometryToolkitCore.Primitives.HyperplaneVisualGeometryToolkitCore.Primitives.Line2DVisualGeometryToolkitCore.Primitives.Line2DVisualGeometryToolkitCore.Primitives.Line2DVisualGeometryToolkitCore.Primitives.Line2DVisualGeometryToolkitCore.Primitives.OrientedDiscVisualGeometryToolkitCore.Primitives.Paraboloid3DVisualGeometryToolkitCore.Primitives.Paraboloid3DVisualGeometryToolkitCore.Primitives.Paraboloid3DVisualGeometryToolkitCore.Primitives.Plane3DVisualGeometryToolkitCore.Primitives.Plane3DVisualGeometryToolkitCore.Primitives.Plane3DVisualGeometryToolkitCore.Primitives.Plane3DVisualGeometryToolkitCore.Primitives.PointFrameVisualGeometryToolkitCore.Primitives.PolygonRegionVisualGeometryToolkitCore.Primitives.RegionIntersectionVisualGeometryToolkitCore.Primitives.WholePlaneVisualGeometryToolkitCore.QuadVisualGeometryToolkitCore.Cameras.with_parametersVisualGeometryToolkitCore.Primitives.best_iou_matchVisualGeometryToolkitCore.Primitives.clip_to_rectVisualGeometryToolkitCore.Primitives.coeffsVisualGeometryToolkitCore.Primitives.coeffsVisualGeometryToolkitCore.Primitives.frame_dofVisualGeometryToolkitCore.Primitives.gradientVisualGeometryToolkitCore.Primitives.homogeneous_wVisualGeometryToolkitCore.Primitives.interceptVisualGeometryToolkitCore.Primitives.iou_belowVisualGeometryToolkitCore.Primitives.is_ellipseVisualGeometryToolkitCore.Primitives.is_peakVisualGeometryToolkitCore.Primitives.is_peakVisualGeometryToolkitCore.Primitives.is_positive_definiteVisualGeometryToolkitCore.Primitives.is_valid_shapeVisualGeometryToolkitCore.Primitives.maps_withinVisualGeometryToolkitCore.Primitives.ray_plane_intersectionVisualGeometryToolkitCore.Primitives.sideVisualGeometryToolkitCore.Primitives.slopeVisualGeometryToolkitCore.bboxVisualGeometryToolkitCore.bboxVisualGeometryToolkitCore.boundsVisualGeometryToolkitCore.chartVisualGeometryToolkitCore.intersectionVisualGeometryToolkitCore.intersection_atVisualGeometryToolkitCore.surfaceVisualGeometryToolkitCore.surface_point