Meshes and 3D geometry

A mesh gives you a surface to work with as well as a shape to draw. Ask whether it is closed, subdivide it, smooth it without deflating it, reduce its triangle count, measure its volume, or shoot a ray at it. You can also write it out for another program to read.

Field's CPU mesh tools are built around TriMesh. They make primitives and surfaces from signed distance fields, then let you inspect, reshape, simplify and export them. The operations run in a box without a GPU; the graphics reference lists the API.

End a box on a TriMesh and Field draws it, with measurements beside the picture:

Use toFLines(...) to turn a mesh into a wireframe, crease set or normal field. You can then draw, animate and export those lines alongside the rest of your work.

The value type

TriMesh(positions, indices, normals = null, uvs = null, colors = null)

Flat FloatArrays (positions is 3 * vertexCount floats, indices is 3 * triangleCount ints), with optional per-vertex normals, uvs and colors. Three choices in that shape change how the type behaves:

• Flat arrays, not a list of vertex objects. Vec3 in afield.math.linalg is mutable, and a mesh built out of mutable vectors is an aliasing bug waiting to happen: transform one vertex twice because two triangles share it and the surface tears. So TriMesh stores floats and every accessor (position(i), faceNormal(t), triangle(t)) hands back a fresh Vec3 that cannot write back into the mesh. positionInto(i, dest) is there for the inner loop that cares.
• Immutable in practice. Everything returns a new mesh: translated, scaled, rotated, transformed { }, flipped, weld, loopSubdivide, decimate. So a pipeline stays readable as one expression, and re-running a box gives you the same answer every time.
• Topology is computed, not stored. topology() builds the edge map, the vertex stars and the boundary loops on demand and caches the expensive parts lazily. The mesh itself stays a plain buffer that a GPU upload or a file writer can take verbatim.

The generators return the minimal closed mesh for their shape, which is a much stronger guarantee than "it renders": a cube is 8 vertices and 12 triangles, not 24 and 12.

Four more generators build a mesh out of something you already have rather than out of parameters: extrudeMesh (real ear clipping, so a concave polygon works and does not fan), revolveMesh (a lathe), tubeMesh (a rotation-minimising sweep along a 3D path) and heightfieldMesh, which has a lambda form and an Img.toHeightfieldMesh() form, and that second one is the bridge from the imaging family into this one. The two heightfields are the only panels here that are open surfaces rather than closed solids, so they report χ=1 instead of 2. A heightfield has a rim.

Modelling with a field

With a signed distance field (SDF) a shape is an expression you edit rather than a thing you assemble. A ScalarField3D is a type alias for (Vec3) -> Float (negative inside, positive outside), and every combinator is one line.

:::static
// A shape as an expression. Every one of these is a (Vec3) -> Float; nothing is a mesh yet.
val ball = sdfSphere(0.8)
val bar = sdfBox(vec(2.2, 0.34, 0.34))
val sharp = sdfUnion(ball, bar)
val soft = sdfSmoothUnion(ball, bar, k = 0.3) // the k is the fillet radius
val drilled = sdfSmoothSubtract(soft, sdfCylinder(0.28, 4.0), k = 0.1)
val twisted = sdfBox(vec(1.2, 1.8, 0.4)).twisted(0.35)

// marchingCubes samples each grid corner and shares one vertex per crossed grid edge.
// The result is indexed; closure also requires the surface to stay inside the sampling bounds.
val window = boundsAround(radius = 1.35)
val sharpMesh = marchingCubes(sharp, window, 72)
val softMesh = marchingCubes(soft, window, 72)
val drilledMesh = marchingCubes(drilled, window, 72)
val twistedMesh = marchingCubes(twisted, boundsAround(radius = 1.2), 72)

// A shell looked at from outside is indistinguishable from the solid, so cut it open with a
// half-space: intersecting with sdfPlane keeps only the half you want and the wall becomes visible.
val shell = soft.shell(0.07)
val closedShell = marchingCubes(shell, window, 88)
val cutaway = marchingCubes(sdfIntersect(shell, sdfPlane(vec(0, 0, -1), 0.0)), window, 88)
:::fold print what each one came out as, then draw the six
// A fillet only ever ADDS material, so the smooth union must enclose more than the sharp one.
// That is a property you can assert rather than eyeball.
println("sharp union  volume %.5f".format(sharpMesh.signedVolume()))
println(
    "smooth union volume %.5f  (the fillet adds %.5f)"
        .format(
            softMesh.signedVolume(),
            softMesh.signedVolume() - sharpMesh.signedVolume(),
        ),
)
println("drilled      ${drilledMesh.summary()}")
println("twisted      ${twistedMesh.summary()}")
println("closed shell ${closedShell.summary()}")
println("cut open     ${cutaway.summary()}")

showMeshGrid(
    "sdfUnion(sphere, box)" to sharpMesh,
    "sdfSmoothUnion(…, k = 0.3)" to softMesh,
    "…then sdfSmoothSubtract(cylinder)" to drilledMesh,
    "sdfBox(…).twisted(0.35)" to twistedMesh,
    "shell(0.07) — closed, chi = 4" to closedShell,
    "…cut open by sdfPlane" to cutaway,
    columns = 2,
    cellWidth = 320,
)
:::endfold

The box also prints each solid's volume and topology, and those numbers say more than the pictures. The sharp union encloses 2.2135 and the filleted one 2.2690, because a fillet only ever adds material. A test can assert that ordering; your eye cannot. Drilling through drops it to 1.8805 and takes χ from 2 to 0, genus 0 to 1: the drill added a handle. The closed shell reports χ = 4, which is exactly right, if odd at first: a shell is two nested closed surfaces, an outer and an inner, and 2 + 2 = 4. Cutting it with a half-space glues them into one surface again (χ = 2) and halves the z extent, from 1.739 to 0.870, which is how you know the cut actually happened.

showMeshGrid(...) is the fastest way to see a whole pipeline: labelled panels side by side, in the Three.js viewer, so in a live box you can orbit the whole sheet at once. It is one WebGL context tiled into viewports rather than one iframe per panel. See Field's 3D output. Pass renderer = MeshRenderer.CPU for a static rasterized sheet instead.

Each panel carries its label and the same fact line showMesh prints: counts, extent, χ, genus and volume (facts = false leaves it off). For a sentence of your own under each cell, hand threeGrid ThreeMeshPanel(label, mesh, facts = "…") cells; polytope_examples.md does that throughout.

The primitives are sdfSphere, sdfBox, sdfRoundBox, sdfTorus, sdfPlane, sdfCylinder, sdfCapsule, sdfGyroid and sdfMetaballs. The combinators are sdfUnion, sdfIntersect, sdfSubtract, sdfInvert, their three sdfSmooth… variants, sdfExpUnion, and the modifiers shell, rounded, translated, scaled, rotated, repeated, twisted and displaced. gradient(p) and normalAt(p) finite-difference the field where you need a direction.

Looking at what you got

A broken mesh can still look fine. A missing cap, unwelded vertices or a tear in a marched surface may be hard to see in a render. Start by measuring the mesh: the Euler characteristic V - E + F is 2 for a closed genus-0 surface and 2 - 2g for genus g. Check watertightness and manifoldness as well; the Euler characteristic alone cannot establish that a mesh is sound.

summary() prints the whole verdict in one line. The rest of the pieces are separately available: isWatertight(), isManifold(), eulerCharacteristic(), genus(), boundaryLoops(), surfaceArea(), signedVolume(), and topology() gives you the object they all delegate to.

The other half of "looking at what you got" is checking the geometry against an answer you already know. This box marches a sphere, whose volume should converge to 4/3 π, at two resolutions, beside a drilled solid and a gyroid:

:::static
// Marching cubes is O(h^2) accurate, so the error should fall by ~4x each time the resolution
// doubles. Watch it: this is the check that tells you the marcher is right, not just plausible.
val exact = 4.0 / 3.0 * PI
println("resolution   tris    volume     relative error")
for (resolution in [12, 24, 48, 64]) {
    val m = marchingCubes(sdfSphere(1.0), boundsAround(radius = 1.4), resolution)
    val error = abs(m.signedVolume() - exact) / exact
    println(
        "%10d %7d %10.6f %14.5f   watertight=%s chi=%d"
            .format(
                resolution,
                m.triangleCount,
                m.signedVolume(),
                error,
                m.isWatertight(),
                m.eulerCharacteristic(),
            ),
    )
}
println("the analytic answer is 4/3 pi = $exact")

// Drilling straight through a solid adds a handle, so the genus goes from 0 to 1. That is the
// topology layer telling you something a picture cannot: the two look identical from outside.
val drilled = marchingCubes(
    sdfSubtract(sdfSphere(1.0), sdfCylinder(0.3, 4.0)),
    boundsAround(radius = 1.3),
    64,
)
println()
println("drilled sphere: ${drilled.summary()}")

/*
A gyroid is a triply-periodic minimal surface: one sheet with many handles, so chi goes strongly
negative. A scalar field need not be a distance function: signs classify corners,
while the sampled values locate interpolated edge crossings.
*/
val gyroid = marchingCubes(sdfGyroid(4.0, 0.3), boundsAround(radius = 1.0), 56)
println("gyroid: ${gyroid.summary()}")
:::fold draw the coarse and fine spheres beside the two harder shapes
val coarse = marchingCubes(sdfSphere(1.0), boundsAround(radius = 1.4), 16)
val fine = marchingCubes(sdfSphere(1.0), boundsAround(radius = 1.4), 64)
fun err(m: TriMesh) = "%.2f%%".format(100.0 * abs(m.signedVolume() - exact) / exact)
showMeshGrid(
    "marched at 16 — volume off by ${err(coarse)}" to coarse,
    "…at 64 — off by ${err(fine)}" to fine,
    "sdfSubtract(sphere, cylinder) — genus 1" to drilled,
    "sdfGyroid(4.0, 0.3) — one sheet, many handles" to gyroid,
    columns = 2,
    cellWidth = 340,
)
:::endfold

The two spheres are the same field at two grid resolutions: 1544 triangles and a volume of 4.1124 at 16, 24920 and 4.1840 at 64, against an analytic 4/3 π = 4.18879. Both are watertight with χ = 2, and the error falls from 1.82% to 0.11%, roughly the O(h²) you should demand of a marcher, and the printed table in the box carries all four resolutions. The drilled solid carries the topology: it looks like a sphere from most angles and reports χ = 0, genus 1. The gyroid is the awkward edge case (χ = −20, genus 4, and open, with 20 boundary loops) because the surface runs out of the sampling box rather than closing inside it. summary() reports it as open, and Field's 3D output draws those twenty loops over the surface so you can see where they are.

Subdivide, and smooth without shrinking

loopSubdivide(times) quadruples the triangles and preserves χ exactly, so a watertight input stays watertight at the same genus. Smoothing needs more care: the naive answer is subtly wrong and the mesh will not tell you unless you measure it.

A Laplacian pass moves every vertex toward the average of its neighbours. That is diffusion, and diffusion of a closed surface deflates it: run it long enough and the shape collapses to a point. Taubin's fix is to alternate a positive shrinking step lambda with a slightly larger negative inflating step mu, chosen so the pair is a low-pass filter with unity gain in the passband. The noise still goes; the volume stays.

:::static
// Loop subdivision converges on the Loop LIMIT surface, not on the sphere its control vertices sit
// on, so the volume falls monotonically in geometrically shrinking steps. chi never moves.
var control = icosahedronMesh(0.8)
val rounds = ArrayList<TriMesh>()
:::fold subdivide three times, printing the volume step each round
println("round  tris    volume     step")
var previous = control.signedVolume()
println("%5d %6d %10.5f".format(0, control.triangleCount, previous))
for (round in 1..3) {
    control = control.loopSubdivide(1)
    rounds.add(control)
    val v = control.signedVolume()
    println(
        "%5d %6d %10.5f %9.5f   chi=%d"
            .format(
                round,
                control.triangleCount,
                v,
                v - previous,
                control.eulerCharacteristic(),
            ),
    )
    previous = v
}

:::endfold

// Now the smoothing comparison. Same input, same iteration count, same lambda — the only
// difference is Taubin's second, inflating pass.
val rng = java.util.Random(7)
val clean = icosphereMesh(3, 0.8)
val noisy =
    clean
        .transformed { p ->
            val s = 1f + (rng.nextFloat() - 0.5f) * 0.18f // 18% radial noise
            vec(p.x * s, p.y * s, p.z * s)
        }
        .withVertexNormals()
val laplacian = noisy.laplacianSmooth(iterations = 30, lambda = 0.6)
val taubin = noisy.taubinSmooth(iterations = 30, lambda = 0.6, mu = -0.63)
:::fold print the four volumes — this is the whole point — and draw the six meshes
println()
println("clean     volume %.5f".format(clean.signedVolume()))
println("noisy     volume %.5f".format(noisy.signedVolume()))
println("laplacian volume %.5f  <- a diffusion deflates the ball".format(laplacian.signedVolume()))
println("taubin    volume %.5f  <- the lambda/mu pair holds it".format(taubin.signedVolume()))

showMeshGrid(
    "icosahedronMesh() control" to icosahedronMesh(0.8),
    "loopSubdivide(1)" to rounds[0],
    "loopSubdivide(3)" to rounds[2],
    "+18% radial noise" to noisy,
    "laplacianSmooth(30) — deflated" to laplacian,
    "taubinSmooth(30) — volume held" to taubin,
    columns = 3,
    cellWidth = 290,
    // One scale for every panel, so the deflated ball looks deflated.
    sharedScale = true,
)
:::endfold

The noisy input encloses 2.1293 across an extent of 1.701. Thirty Laplacian iterations at λ = 0.6 leave 1.1509 across 1.301: it has thrown away 46% of the volume. Thirty Taubin iterations of the same λ, with μ = −0.63, leave 2.1840 across 1.631, within about 3% of the clean ball this noise was added to, and, at 1280 triangles and χ = 2 throughout, just as smooth. Reach for Taubin whenever the volume has to survive the smoothing.

In the top row, the volume falls 1.2985 → 0.8518 → … → 0.7490 and does not stop at the sphere the icosahedron's vertices sit on, because Loop subdivision converges on the Loop limit surface, not on whatever you imagined the control mesh approximated. The steps shrink geometrically and χ never moves off 2.

Both smoothers take cotangent = true for the cotangent-weighted Laplacian, which is the right choice on an irregular triangulation because it weights by the geometry rather than by valence, and withVertexNormals() recomputes the shading normals afterwards.

Decimate to a budget, and know the price

decimate(targetTriangles) is quadric-error-metric edge collapse: each vertex accumulates the quadric of its incident face planes, every candidate collapse is scored by the error at its optimal position, and the cheapest is taken until the budget is met. Collapses are vetoed by the link condition (so the mesh cannot go non-manifold), by a normal-flip test, and by a shape test that defers a collapse which would produce a sliver.

After reducing the triangle count, check the deviation: how far either mesh's vertices sit from the other's surface. maxDeviation(a, b) measures both directions, so you can see how much shape the simplification has lost.

:::static
val detailed = icosphereMesh(4, 0.8) // 5120 triangles
println("start: ${detailed.summary()}")
println()
println("target    got   deviation   min angle   watertight")

val budgets = ArrayList<Pair<String, TriMesh>>()
for (target in [2000, 600, 150]) {
    val small = detailed.decimate(target)
    // Symmetric: the largest distance either mesh's vertices sit from the other's surface.
    val deviation = maxDeviation(detailed, small)
    println(
        "%6d %6d %11.5f %11.1f   %s"
            .format(
                target,
                small.triangleCount,
                deviation,
                small.quality().minAngleDegrees,
                small.isWatertight(),
            ),
    )
    budgets.add("decimate($target) — deviation ${deviation.f4}" to small)
}
:::fold draw the original beside the three budgets
showMeshGrid(
    "icosphereMesh(4) — ${detailed.triangleCount} tris" to detailed,
    budgets[0].first to budgets[0].second,
    budgets[1].first to budgets[1].second,
    budgets[2].first to budgets[2].second,
    columns = 2,
    cellWidth = 340,
)
:::endfold

Every budget is hit exactly (2000, 600 and 150 triangles) and all three stay watertight at χ = 2, which is the link condition doing its job. The volume drifts from 2.1400 down to 2.1252, 2.0860 and 2.0724 (the collapses cut corners off a convex solid, so it can only lose). The number to budget against is the deviation in each panel heading: 0.0047 at 2000 triangles, 0.0166 at 600 and 0.0326 at 150, on a ball of radius 0.8, so a 34× reduction costs you about 4% of the radius. The deviation grows slower than the triangle count falls. Decimation trades on that asymmetry.

quality() is the other half of that judgement: minimum and mean triangle angle, aspect ratio, degenerate count. A decimator that hits its budget by producing slivers has not helped you, and the minimum angle is where that shows up first.

Drawing it, and writing it out

toFLines(mode) is the bridge back into Field. Five modes:

CREASES is the one that makes a drawing readable: on a smooth mesh the full wireframe is a grey mat and the crease set is correctly empty, while on a faceted or CSG solid the creases are exactly the silhouette you would have drawn by hand. Once you have FLines, everything else in Field applies:

lines(mesh.toFLines(MeshLines.CREASES, creaseAngleDegrees = 30.0))

Going the other way, tubeMesh(fline, radius, sides, samples, caps) sweeps a tube along an FLine using rotation-minimising frames rather than Frenet frames, so it does not twist where the path's curvature swings through vertical.

For files: toObj(name) / objToTriMesh(text) and toStlAscii / toStlBinary / stlToTriMesh(bytes), plus saveObj(file), saveStl(file) and triMeshFromObj(file). The two formats differ in what you get back. OBJ keeps the index structure, so a watertight mesh round-trips watertight. STL is triangle soup (three unshared vertices per triangle, no indices at all), so it comes back with 3× the vertices and isWatertight() false until you weld(1e-5) it. Both recover the volume exactly.

Shading normals are a choice rather than a property, and the choice changes the vertex count. A generator ships without normals when its vertices sit on a crease, and then flatShaded() splits every one, shadedNormals(creaseAngleDegrees = 35.0) splits only across creases, and withVertexNormals() shares them all: 144, 50 and 26 vertices for the same 12-sided cylinder, from a hard-faceted tube to one with a rounded-off rim:

OBJ and STL are the two formats this family reads and writes without a dependency; PLY, glTF and GLB read as well. Geometry from disk is the route from any format to pixels: one call per format, a measured table of what each one loses in each direction, and a list of what cannot be read at all (STEP and every other CAD boundary representation).

:::static
// A tube swept along an FLine: rotation-minimising frames, so it does not twist where the path's
// curvature swings through vertical.
val path = FLine()
for (i in 0..120) {
    val t = i / 120.0
    val a = 2.0 * PI * 2.0 * t
    val p = vec(cos(a) * 0.6, (t - 0.5) * 1.3, sin(a) * 0.6)
    if (i == 0) path.moveTo(p) else path.lineTo(p)
}
val coil = tubeMesh(path, radius = 0.1, sides = 18, samples = 120, caps = true)
println("tube along an FLine: ${coil.summary()}")

// A coarse torus, so there really are creases to keep. On a fine one the crease set is empty,
// which is the correct answer and a dull demonstration.
val ring = torusMesh(14, 8, 0.6, 0.22)
println(
    "torus: ${ring.toFLines(MeshLines.EDGES).size} edges, " +
        "${ring.toFLines(MeshLines.CREASES, creaseAngleDegrees = 30.0).size} creases at 30 degrees, " +
        "${ring.toFLines(MeshLines.NORMALS).size} normals",
)
val patch = planeMesh(6, 6, 1.2, 1.2)
println(
    "plane patch: ${patch.toFLines(MeshLines.BOUNDARY).size} boundary loop(s), " +
        "${patch.toFLines(MeshLines.BOUNDARY).firstOrNull()?.nodes?.size} nodes around it",
)

// OBJ keeps the indices; STL is soup and needs a weld. Both must recover the volume exactly.
val source = icosphereMesh(3, 0.7)
val viaObj = objToTriMesh(source.toObj("ball"))
val viaStl = stlToTriMesh(source.toStlBinary())
println()
println("source     ${source.vertexCount} verts  volume %.6f".format(source.signedVolume()))
println(
    "via OBJ    ${viaObj.vertexCount} verts  volume %.6f  watertight ${viaObj.isWatertight()}"
        .format(
            viaObj.signedVolume(),
        ),
)
println(
    "via STL    ${viaStl.vertexCount} verts  volume %.6f  watertight ${viaStl.isWatertight()}"
        .format(
            viaStl.signedVolume(),
        ),
)
println("STL welded ${viaStl.weld(1e-5).vertexCount} verts  watertight ${viaStl.weld(1e-5).isWatertight()}")
:::fold draw the coil beside the coarse torus and the STL round trip
showMeshGrid(
    "tubeMesh(FLine, sides = 18)" to coil,
    "torusMesh(14, 8) — creases to keep" to ring,
    "icosphereMesh(3) via STL, welded" to viaStl.weld(1e-5),
    columns = 3,
    cellWidth = 250,
)
:::endfold

The coil is the frame test: 4320 triangles, watertight, χ = 2, and no twist anywhere along the helix even though the path's curvature swings through vertical twice. The round-tripped sphere comes back at 642 vertices, watertight, χ = 2, volume 1.4244, the same 642 vertices it started with, after having been flattened to 3840 unshared ones by the STL writer and welded back.

Measuring and querying

surfaceArea(), signedVolume() (the divergence-theorem sum, so it is signed: an inside-out closed mesh reports a negative volume, which is the only thing that will tell you), centroid() for the area-weighted surface centroid and solidCentroid() for the enclosed solid's.

Discrete curvature: gaussianCurvature() is the angle deficit and meanCurvature() the cotangent Laplacian's magnitude, both divided by the mixed Voronoi area from mixedVertexAreas(). On a sphere of radius r they are 1/r² and 1/r. A torus is the shape to look at, because its Gaussian curvature has both signs, positive on the outside and negative in the hole:

A useful global check is Gauss–Bonnet: the integral of Gaussian curvature over a closed surface is 2πχ. Compare the computed integral with that value, while keeping in mind that a global sum can hide local errors that cancel each other.

val k = mesh.gaussianCurvature()
val areas = mesh.mixedVertexAreas()
val total = (0 until mesh.vertexCount).sumOf { k[it] * areas[it] } // == 2 * PI * chi

bvh() builds a bounding-volume hierarchy to accelerate spatial queries: raycast(origin, direction), raycastAll(...), closestPoint(query), contains(query) (a parity test, so it needs a watertight mesh) and signedDistance(query). asSdf() hands the whole thing back as a ScalarField3D, which closes the loop: you can march a mesh's own signed distance field and get a remeshed version of it. There are TriMesh.raycast / closestPoint / contains shorthands that build a throwaway BVH, fine for one query and wrong for a loop.

convexHullMesh(points) is an incremental hull with no dependencies, and deviationFrom / maxDeviation / isContainedIn / samplePoints are the comparison tools.

A Voronoi diagram as solids

voronoi3d(...) clips half-spaces and hands back VoronoiCell3s with polygonal faces. VoronoiCell3.toTriMesh(shrink) and VoronoiLattice.toTriMesh(shrink, boundedOnly) turn those into geometry you can measure, cut, export or print. Because a Voronoi tessellation partitions its clip box exactly, there is a one-line total check on the result: the cell volumes must sum to the box's own volume.

val lattice = Voronoi3d.build(sites, clipPadding = 0.15f)
val total = lattice.cells.sumOf { abs(it.toTriMesh(shrink = 1.0).signedVolume()) }
// total agrees with the clip box's volume to ~1e-8 relative
showMeshGrid(
    "all the cells" to lattice.toTriMesh(shrink = 1.0),
    "the interior cells, exploded" to lattice.toTriMesh(shrink = 0.6, boundedOnly = true),
    columns = 2,
)

Recipes

Trying it yourself

Every runnable example above is a box: paste it into Field, change a resolution, a smoothing parameter or an SDF expression, and run it again. To start from boxes that already run, open mesh_geometry_examples from Starting points on the welcome screen, or open it here.

Reference

Source: src/jvmMain/kotlin/afield/geometry/mesh/mesh.kt, src/jvmMain/kotlin/afield/geometry/mesh/mesh_topology.kt, src/jvmMain/kotlin/afield/geometry/mesh/mesh_generate.kt, src/jvmMain/kotlin/afield/geometry/mesh/mesh_sdf.kt, src/jvmMain/kotlin/afield/geometry/mesh/mesh_process.kt, src/jvmMain/kotlin/afield/geometry/mesh/mesh_measure.kt, src/jvmMain/kotlin/afield/geometry/mesh/mesh_io.kt, src/jvmMain/kotlin/afield/geometry/mesh/mesh_field.kt. Developer notes, including the measurements behind the Voronoi fix: dev_docs/MESH_GEOMETRY.md.

Reading a mesh in from PLY, glTF or GLB: Geometry from disk, over afield/graphics/scene/MeshFromDisk.kt.

Build a scene with meshes, lines and points using three { … }. Use geometry review to select a visible feature and return its coordinates, note and images to Field.