foocad-core/uk.co.nickthecoder.foocad.core.compounds

Package-level declarations

Types

Arranges any number of Shape3d in a roughly square pattern (X and Y), with no shapes touching each other. Primarily designed to arrange multiple independent pieces on a single build-plate.

AutoArrangeGrid

object AutoArrangeGrid : AutoArrangeHeuristic

Currently the one and only heuristic used by AutoArrange.

AutoArrangeHeuristic

interface AutoArrangeHeuristic

Cavity

class Cavity

Sometimes it is useful for the holes to be 1st class objects, instead of only modelling the solid parts. For example, we could define a pipe by modelling just the solid part (an extruded ring), or we could define it as a solid cylinder with a cylindrical cavity through it.

ClosestPathPairing

class ClosestPathPairing : ScoredPathPairing

CompoundShape2d

abstract class CompoundShape2d(dependencies2d: List<Shape2d?>) : Multi2dDependent

The base class for Union2d, Intersection2d and Difference2d.

CompoundShape3d

abstract class CompoundShape3d(dependencies3d: List<Shape3d?>) : Multi3dDependent

The base class for Union3d, Intersection3d and Difference3d.

DefaultJoinStrategy

class DefaultJoinStrategy : JoinStrategy

DefaultTubeBuilder

class DefaultTubeBuilder : TubeBuilder

Difference2d

class Difference2d(children: List<Shape2d?>) : CompoundShape2d

Difference3d

class Difference3d(children: List<Shape3d?>) : CompoundShape3d

Extrusion

open class Extrusion(val shape2d: Shape2d, val height: Double, val scale: Vector2, val convexity: Int?) : Shape3d, Shape2dDependent

An extrusion takes a Shape2d, and stretches (extrudes) it upwards (the Z direction). Created via Shape2d.extrude. OpenSCAD calls this linear_extrude.

ExtrusionBuilder

class ExtrusionBuilder

Creates a 3D shape from a 2D shape (or many 2D shapes).

HeuristicPairing

class HeuristicPairing : VertexPairing

A heuristic, which makes a "best effort" to join the two shapes in a "pleasing" manner, avoiding twists, and broken extrusions where possible.

Hull2d

class Hull2d(dependencies2d: List<Shape2d>) : Multi2dDependent

See https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Transformations#hull

Hull3d

class Hull3d(dependencies3d: List<Shape3d>) : Multi3dDependent

Intersection2d

class Intersection2d(children: List<Shape2d?>) : CompoundShape2d

Intersection3d

class Intersection3d(children: List<Shape3d?>) : CompoundShape3d

JoinStrategy

interface JoinStrategy

ManualPairing

class ManualPairing(val pairs: List<Pair<Int, Int>>) : VertexPairing

Pair up the points manually.

Minkowski2d

class Minkowski2d(val a: Shape2d, val b: Shape2d) : Multi2dDependent

See https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Transformations#minkowski

Minkowski3d

class Minkowski3d(val a: Shape3d, val b: Shape3d) : Multi3dDependent

See https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Transformations#minkowski

OneToOneJoinStrategy

class OneToOneJoinStrategy : JoinStrategy

OneToOneOffsetPairing

class OneToOneOffsetPairing(val offset: Int) : VertexPairing

Similar to OneToOnePairing, except the pairs are offset. So point 0 of shapeA is paired to point offset of shapeB, and point 1 of shapeA is paired to offset + 1 of shapeB etc.

OneToOnePairing

class OneToOnePairing : VertexPairing

Assuming shapeA and shapeB are have the same number of points, this pairs the first point of A with the first point of B and so on, in a 1 to 1 fashion.

Path3dBuilder

class Path3dBuilder

PathPairing

interface PathPairing

Determines how the paths from one Shape2d are mapped to the paths in another Shape2d. Used by Worm to guess how to join to complex shapes (i.e. shapes with holes, or with more than one simple shape)

PolygonBuilder

class PolygonBuilder

Projection

class Projection(val shape3d: Shape3d, val cut: Boolean) : Shape2d, Shape3dDependent

Creates a 2d projection of a 3d shape. If cut is false, then we end up with a "shadow", as if the light source were directly above (to infinity). If cut is true (the default), then the result is the slice through the z=0 plane.

Revolution

class Revolution : Shape2dDependent, Shape3d

A solid of revolution built from a 2D shape shape2d. Created via Shape2d.revolve.

ScoredPathPairing

abstract class ScoredPathPairing : PathPairing

STLParser

class STLParser

Parses STL files, and returns a Polyhedron. Note, STL comes in two flavours, binary and text. To distinguish between the two, we check the first 5 bytes, and if it reads solid, then it is assumed to be an ascii file. However, I have seen binary STL files with an (erroneous?) header. In this case, use parseBinaryFile, instead of the more usual parseFile (which attempts to guess the flavour).

SVGDocument

class SVGDocument : Union2d

Parses an SVG file (Use the program Inkscape to edit SVG files) This is a Union2d of all shapes within the SVG file.

SVGHandler

class SVGHandler(val scale: Vector2) : DefaultHandler

SVGParser

class ~~SVGParser~~

TubeBuilder

interface TubeBuilder

Helps Worm determine how points in pairs of paths are joined to form a tube between the two shapes.

Union2d

open class Union2d(children: List<Shape2d?>) : CompoundShape2d

Union3d

open class Union3d(children: List<Shape3d?>) : CompoundShape3d

VertexPairing

interface VertexPairing

Determines how the vertices of two 2D shapes are to be paired up when making 3d shapes from 2d shapes.

Worm

interface Worm : Shape3d

A Worm is a 3d shape made up of sections, where each section has a 2d shape at each end joined by a tube. The simplest worm is an extrusion, were both ends are the same shape, parallel to the Z=0 plane (the floor), separated by the length of the extrusion.

WormFactory

class WormFactory

Static methods which are automatically imported within FooCAD scripts, which start making Worms from Shape2d.