TransformApi

The array tools (ArtisanArrayPolar, ArtisanArrayOnCurve panels plus a plain linear array), headless. Same conventions as the rest of the family (mm, null/empty objectIds = the current selection, LicenseGate first, redraw at the end), and like TransformApi.Basics every method ends with the parametric engine’s MeetMotherAndChildren() so the copies’ children re-adopt their nearest mother — exactly what the panels do on Accept.

from ArtisanPlugin.Scripting import TransformApi

See also the guide, Transform, and the Python package, ra.transform.

Methods

Method
ArrayLinear	Copies the objects count times in total (original included) along step: copy i sits at i * step.
ArrayOnCurve	The ArtisanArrayOnCurve panel, headless: distributes copies of the objects along curveId, each copy reoriented to the curve’s perpendicular frame (the objects are expected modeled around the world origin on the XY plane, like the panel).
ArrayPolar	The ArtisanArrayPolar panel, headless: revolves the objects around the axis of plane (“TOP” = around world Z, “FRONT” = around Y, “SIDE” = around X, “CPLANE” = the active viewport’s construction plane), copies per row over angle degrees (alignment JUSTIFY spreads over the full 360 regardless of angle; LEFT/CENTER/RIGHT start the sweep before/around/after the original).
Bend	Bends the objects around their bounding-box center (the ArtisanBend tool, headless).
Center	The ArtisanCenter command, headless: translates the objects, as one set, so the center of their common world-axis bounding box lands on the world origin (0,0,0).
Copies	The ArtisanCopies command, headless: duplicates the objects count times (1..100; 0 = 1) along -Y for a production tray, each copy one selection-height further (the union bounding box’s Y extent), so multi-object models keep their parts together and the copies touch edge to edge.
CopyOnObjects	The ArtisanCopyOnObjects command, headless: copies the objects onto the target objects, once per point in points (each point replicates one click of the command; the command loops until Enter).
Distribute	The ArtisanDistribute command, headless: lays the objects out in a row along +X for a print/casting tray — each piece resting on Z = 0 with its back edge on Y = 0, left edges chained with a 10 % gap of each piece’s width.
Duplicate	Duplicates the objects in place (a copy on top of each original) — the starting point of “duplicate and vary” Flow recipes.
FlowByCurve	The ArtisanSmartFlowbyCurve panel, headless: flows the objects from baseCurveId onto targetCurveId (Rhino’s Flow space morph).
FlowBySurface	The ArtisanSmartFlowbySurface panel, headless: flows the objects from baseSurfaceId onto targetSurfaceId (Rhino’s Sporph space morph; the first face of a polysurface/extrusion is used, like the panel).
Mirror	Mirrors the objects across a world plane through origin (null = the world origin): “XY”, “YZ” or “XZ”.
MirrorOpposite	The ArtisanMirrorOpposite command, headless: places one copy of each object on the opposite side of plane’s origin (null = the active viewport’s construction plane, like the command; world XY when there is no view).
MirrorQuad	The ArtisanMirrorQuad command, headless: mirrors the objects into the other three quadrants of plane (null = the active viewport’s construction plane, like the command; world XY when there is no view).
Move	Translates the objects by translation mm.
MoveByNormal	The ArtisanMoveByNormal command, headless: moves each object along the normal of surfaceId — evaluated at the surface point closest to the object’s bounding-box center, so each object follows its own local normal — by distance mm (the command’s initial default is 1.0; negative moves against the normal).
MoveOnObjects	The ArtisanMoveOnObjects command, headless: same placement math as CopyOnObjects (same base mesh, same per-object frame from the mesh point and normal closest to the bounding-box center) but the objects are MOVED in place onto the single point (pulled onto the base mesh first, like the command’s cursor constraint).
MoveRandom	The ArtisanMoveRandom command, headless: moves EACH object by distance mm along its own random unit direction (a different direction per object), to break the perfect regularity of pave stones or beads.
OrientOnSurface	The ArtisanOrientOnSurface command, headless: copies the objects onto surfaceId (a surface/polysurface/extrusion), once per point in points (each point = one click of the command).
Rotate	Rotates the objects angleDegrees around axis (“X”, “Y” or “Z”, world-oriented) through center (null = the center of the common bounding box, so the selection spins in place).
Scale	Scales the objects by factor about center (null = the center of the common bounding box).
ScaleByCenter	The ArtisanScaleByCenter command, headless: scales the objects uniformly by factor (> 0; 1 = no change) about the center of their common bounding box, so the set grows/shrinks in place.
ScaleByWeight	Uniformly scales the objects so they weigh exactly targetGrams when cast in metal (the ArtisanScaleByWeight tool, headless).
ScaleToDimensions	The ArtisanScaleByDimensions panel, headless: scales the objects (as one set, about the center of their common world-axis bounding box) so that box measures exactly the given sizes, in mm.
Taper	Tapers the objects along a bounding-box axis (the ArtisanTaper tool, headless): the section grows/shrinks linearly toward the “Top” end of the axis - tapered shanks, cone-ing a motif.
Twist	Twists the objects angleDegrees around a bounding-box axis (the ArtisanTwist tool, headless) - rope-like shanks, twisted wires, spiral motifs.

ArrayLinear

IReadOnlyList<Guid> TransformApi.ArrayLinear(
    IEnumerable<Guid> objectIds = null,
    int count = 2,
    Vector3d? step = null)

Copies the objects count times in total (original included) along step: copy i sits at i * step. Returns the ids of the created copies ((count - 1) x objects).

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null
count	int	2
step	Vector3d?	null

Returns IReadOnlyList<Guid>.

ArrayOnCurve

IReadOnlyList<Guid> TransformApi.ArrayOnCurve(
    IEnumerable<Guid> objectIds = null,
    Guid? curveId = null,
    int copies = 6,
    double distance = 1,
    string alignment = "JUSTIFY",
    string mode = "CENTER",
    double rotation = 0,
    double moveInZ = 0,
    IEnumerable<Guid> surfaceIds = null,
    bool keepOriginal = false)

The ArtisanArrayOnCurve panel, headless: distributes copies of the objects along curveId, each copy reoriented to the curve’s perpendicular frame (the objects are expected modeled around the world origin on the XY plane, like the panel). With surfaceIds the frames also lean on those objects’ render mesh normal — the panel’s optional base surface, for arrays that hug a shank. alignment START/CENTER/END packs the run with distance mm between copies; JUSTIFY spreads copies evenly over the whole curve and ignores distance. mode END keeps the copies’ ends inside the curve, CENTER lets the first/last centers sit on the curve ends. rotation (degrees, around the running axis) and moveInZ (mm) offset every copy. keepOriginal false deletes the source objects (the panel’s default). Returns the ids of the created copies (copies x objects).

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null
curveId	Guid?	null
copies	int	6
distance	double	1
alignment	string	"JUSTIFY"
mode	string	"CENTER"
rotation	double	0
moveInZ	double	0
surfaceIds	IEnumerable<Guid>	null
keepOriginal	bool	false

Returns IReadOnlyList<Guid>.

ArrayPolar

IReadOnlyList<Guid> TransformApi.ArrayPolar(
    IEnumerable<Guid> objectIds = null,
    int copies = 6,
    double angle = 360,
    string plane = "TOP",
    string alignment = "JUSTIFY",
    string mode = "ONE",
    int rows = 1,
    double rowsDistance = 2,
    bool bothSides = false,
    bool keepOriginal = false)

The ArtisanArrayPolar panel, headless: revolves the objects around the axis of plane (“TOP” = around world Z, “FRONT” = around Y, “SIDE” = around X, “CPLANE” = the active viewport’s construction plane), copies per row over angle degrees (alignment JUSTIFY spreads over the full 360 regardless of angle; LEFT/CENTER/RIGHT start the sweep before/around/after the original). mode adds rows (“ONE” single row; “MULTI”/“MULTI_INTER” stack rows every rowsDistance mm along the axis, INTER staggering odd rows half a step; the SPHERICAL variants wrap the rows around the axis origin instead — for domed pave). bothSides mirrors the extra rows below the first. keepOriginal false deletes the source objects (the panel’s default: the first JUSTIFY copy lands on the original). Returns the ids of the created copies.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null
copies	int	6
angle	double	360
plane	string	"TOP"
alignment	string	"JUSTIFY"
mode	string	"ONE"
rows	int	1
rowsDistance	double	2
bothSides	bool	false
keepOriginal	bool	false

Returns IReadOnlyList<Guid>.

Bend

IReadOnlyList<Guid> TransformApi.Bend(
    IEnumerable<Guid> objectIds,
    double xPos = 0,
    double xNeg = 0,
    double yPos = 0,
    double yNeg = 0,
    string plane = null,
    IEnumerable<Guid> rigidIds = null,
    bool keepOriginal = false)

Bends the objects around their bounding-box center (the ArtisanBend tool, headless). The jewelry move: curve a flat motif so it wraps the finger - e.g. bend a flat band or pattern around the ring curvature before a flow/boolean. For that, bend on the default “XY” plane with equal xPos/xNeg and the amount that matches the finger diameter (see DocumentApi.GetRingSize().Diameter). xPos, xNeg, yPos, yNeg are how far (mm) each side of the bounding box is pushed along the bend plane’s normal - exactly the four gumball handles of the panel. Positive lifts toward the plane normal, negative bends the other way, 0 leaves that side straight. At least one must be non-zero. Pass the same value to a pair for a symmetric bend (the panel’s Symmetrical / Quad modes just mirror one handle onto the others). plane is the bend plane: “XY” (default, bends up in Z), “ZX” or “YZ”. Returns the new object ids.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	required
xPos	double	0
xNeg	double	0
yPos	double	0
yNeg	double	0
plane	string	null
rigidIds	IEnumerable<Guid>	null
keepOriginal	bool	false

Returns IReadOnlyList<Guid>.

Center

IReadOnlyList<Guid> TransformApi.Center(IEnumerable<Guid> objectIds = null)

The ArtisanCenter command, headless: translates the objects, as one set, so the center of their common world-axis bounding box lands on the world origin (0,0,0). In-place move; the arrangement between the objects is kept. Returns the ids of the moved objects.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null

Returns IReadOnlyList<Guid>.

Copies

IReadOnlyList<Guid> TransformApi.Copies(IEnumerable<Guid> objectIds = null, int count = 1)

The ArtisanCopies command, headless: duplicates the objects count times (1..100; 0 = 1) along -Y for a production tray, each copy one selection-height further (the union bounding box’s Y extent), so multi-object models keep their parts together and the copies touch edge to edge. Returns the ids of the copies (count x objects), in copy-major order.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null
count	int	1

Returns IReadOnlyList<Guid>.

CopyOnObjects

IReadOnlyList<Guid> TransformApi.CopyOnObjects(
    IEnumerable<Guid> objectIds,
    IEnumerable<Guid> targetIds,
    IEnumerable<Point3d> points)

The ArtisanCopyOnObjects command, headless: copies the objects onto the target objects, once per point in points (each point replicates one click of the command; the command loops until Enter). The frame is derived exactly like the command does: the targets are meshed (render-quality) into one base mesh; for each object, the mesh point and face normal closest to the object’s bounding-box center define the origin plane, and the same offset applied at the picked point defines the destination plane — so a group of objects keeps its arrangement and each copy reorients to the surface normal. Points are pulled onto the base mesh first, like the command’s cursor constraint. Plain copies, no history/parametric link (the command records none). Returns the ids of the created copies (points x objects), in point-major order.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	required
targetIds	IEnumerable<Guid>	required
points	IEnumerable<Point3d>	required

Returns IReadOnlyList<Guid>.

Distribute

IReadOnlyList<Guid> TransformApi.Distribute(IEnumerable<Guid> objectIds = null)

The ArtisanDistribute command, headless: lays the objects out in a row along +X for a print/casting tray — each piece resting on Z = 0 with its back edge on Y = 0, left edges chained with a 10 % gap of each piece’s width. Objects sharing a Rhino group travel together as ONE piece (a ring + its gems is not dismembered); ungrouped objects are a piece each. Order = the order of the ids. In-place move; returns the ids moved.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null

Returns IReadOnlyList<Guid>.

Duplicate

IReadOnlyList<Guid> TransformApi.Duplicate(IEnumerable<Guid> objectIds = null)

Duplicates the objects in place (a copy on top of each original) — the starting point of “duplicate and vary” Flow recipes. Returns the ids of the copies.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null

Returns IReadOnlyList<Guid>.

FlowByCurve

IReadOnlyList<Guid> TransformApi.FlowByCurve(
    IEnumerable<Guid> deformableIds,
    Guid baseCurveId,
    Guid targetCurveId,
    IEnumerable<Guid> rigidIds = null,
    bool flipBase = false)

The ArtisanSmartFlowbyCurve panel, headless: flows the objects from baseCurveId onto targetCurveId (Rhino’s Flow space morph). deformableIds are morphed (a shank, a pattern…); rigidIds keep their shape and are only re-placed along the curve (gems, settings). At least one of the two lists is required. flipBase reverses the base curve direction (the panel’s flip button) when the result lands mirrored. Same bake as the panel’s Accept: the originals stay, the deformed copies keep the source layer/material and carry Rhino history (editing either curve or the source re-flows them); rigid copies are TransformWithHistory copies. Returns the ids of the created copies (deformed first, then rigid).

Parameter	Type	Default
deformableIds	IEnumerable<Guid>	required
baseCurveId	Guid	required
targetCurveId	Guid	required
rigidIds	IEnumerable<Guid>	null
flipBase	bool	false

Returns IReadOnlyList<Guid>.

FlowBySurface

IReadOnlyList<Guid> TransformApi.FlowBySurface(
    IEnumerable<Guid> deformableIds,
    Guid baseSurfaceId,
    Guid targetSurfaceId,
    IEnumerable<Guid> rigidIds = null,
    string baseOrientation = "None",
    string targetOrientation = "None")

The ArtisanSmartFlowbySurface panel, headless: flows the objects from baseSurfaceId onto targetSurfaceId (Rhino’s Sporph space morph; the first face of a polysurface/extrusion is used, like the panel). deformableIds are morphed, rigidIds keep their shape and are re-placed frame-to-frame (gems, settings); at least one of the two lists is required. baseOrientation / targetOrientation are the panel’s UV combos: “None” (default), “ReverseU”, “ReverseV” or “SwapUV” — use them when the result lands mirrored or rotated. Same bake as the Accept: originals stay, copies keep the source layer/material and carry Rhino history. Returns the ids of the created copies (deformed first, then rigid).

Parameter	Type	Default
deformableIds	IEnumerable<Guid>	required
baseSurfaceId	Guid	required
targetSurfaceId	Guid	required
rigidIds	IEnumerable<Guid>	null
baseOrientation	string	"None"
targetOrientation	string	"None"

Returns IReadOnlyList<Guid>.

Mirror

IReadOnlyList<Guid> TransformApi.Mirror(
    IEnumerable<Guid> objectIds = null,
    string plane = "YZ",
    Point3d? origin = null,
    bool copy = true)

Mirrors the objects across a world plane through origin (null = the world origin): “XY”, “YZ” or “XZ”. Unlike the two jewelry mirrors (MirrorQuad/MirrorOpposite) this is the plain mirror, plain copies without history. copy false mirrors in place.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null
plane	string	"YZ"
origin	Point3d?	null
copy	bool	true

Returns IReadOnlyList<Guid>.

MirrorOpposite

IReadOnlyList<Guid> TransformApi.MirrorOpposite(
    IEnumerable<Guid> objectIds = null,
    Plane? plane = null)

The ArtisanMirrorOpposite command, headless: places one copy of each object on the opposite side of plane’s origin (null = the active viewport’s construction plane, like the command; world XY when there is no view). The two mirrors compose into a 180-degree rotation around the plane’s vertical axis, so the copy keeps its handedness. History-linked copies, like the command. Returns the ids of the created copies (1 per object).

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null
plane	Plane?	null

Returns IReadOnlyList<Guid>.

MirrorQuad

IReadOnlyList<Guid> TransformApi.MirrorQuad(
    IEnumerable<Guid> objectIds = null,
    Plane? plane = null)

The ArtisanMirrorQuad command, headless: mirrors the objects into the other three quadrants of plane (null = the active viewport’s construction plane, like the command; world XY when there is no view). Each object gets three history-linked copies — across the plane’s ZX plane, across its YZ plane, and across both — so the four quadrants stay symmetric and the copies follow when the original is edited. Returns the ids of the created copies (3 per object).

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null
plane	Plane?	null

Returns IReadOnlyList<Guid>.

Move

IReadOnlyList<Guid> TransformApi.Move(
    IEnumerable<Guid> objectIds = null,
    Vector3d? translation = null,
    bool copy = false)

Translates the objects by translation mm. copy true leaves the originals and returns the ids of the copies; false moves in place and returns the same ids.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null
translation	Vector3d?	null
copy	bool	false

Returns IReadOnlyList<Guid>.

MoveByNormal

int TransformApi.MoveByNormal(
    IEnumerable<Guid> objectIds,
    Guid surfaceId,
    double distance = 1)

The ArtisanMoveByNormal command, headless: moves each object along the normal of surfaceId — evaluated at the surface point closest to the object’s bounding-box center, so each object follows its own local normal — by distance mm (the command’s initial default is 1.0; negative moves against the normal). surfaceId must be a surface or a single-face polysurface/extrusion, like the command’s surface pick. In-place moves: returns the number of objects moved.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	required
surfaceId	Guid	required
distance	double	1

Returns int.

MoveOnObjects

int TransformApi.MoveOnObjects(
    IEnumerable<Guid> objectIds,
    IEnumerable<Guid> targetIds,
    Point3d point)

The ArtisanMoveOnObjects command, headless: same placement math as CopyOnObjects (same base mesh, same per-object frame from the mesh point and normal closest to the bounding-box center) but the objects are MOVED in place onto the single point (pulled onto the base mesh first, like the command’s cursor constraint). Returns the number of objects moved.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	required
targetIds	IEnumerable<Guid>	required
point	Point3d	required

Returns int.

MoveRandom

IReadOnlyList<Guid> TransformApi.MoveRandom(
    IEnumerable<Guid> objectIds = null,
    double distance = 0.05)

The ArtisanMoveRandom command, headless: moves EACH object by distance mm along its own random unit direction (a different direction per object), to break the perfect regularity of pave stones or beads. 0 = the command’s default distance, 0.05 mm; the command accepts -1000..1000. In-place move; returns the ids moved.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null
distance	double	0.05

Returns IReadOnlyList<Guid>.

OrientOnSurface

IReadOnlyList<Guid> TransformApi.OrientOnSurface(
    IEnumerable<Guid> objectIds,
    Guid surfaceId,
    IEnumerable<Point3d> points,
    double scale = 1,
    double angleDegrees = 0,
    double normalOffset = 0,
    string alignment = "Center",
    bool flip = false)

The ArtisanOrientOnSurface command, headless: copies the objects onto surfaceId (a surface/polysurface/extrusion), once per point in points (each point = one click of the command). The set is anchored by the active construction plane (world XY headless) whose origin sits at the bounding-box alignment point (“Center” default, “Top” or “Bottom” = the box’s top/bottom face center) and mapped to the surface frame at the point closest to each pick. Options as the command: scale (uniform, 0 = 1), angleDegrees (spin around the surface normal), normalOffset (mm along the normal, negative = into the surface) and flip (the command’s Flip toggle: false = the command’s default orientation, true = the other side). Returns the ids of the created copies (points x objects), in point-major order.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	required
surfaceId	Guid	required
points	IEnumerable<Point3d>	required
scale	double	1
angleDegrees	double	0
normalOffset	double	0
alignment	string	"Center"
flip	bool	false

Returns IReadOnlyList<Guid>.

Rotate

IReadOnlyList<Guid> TransformApi.Rotate(
    IEnumerable<Guid> objectIds = null,
    double angleDegrees = 0,
    string axis = "Z",
    Point3d? center = null,
    bool copy = false)

Rotates the objects angleDegrees around axis (“X”, “Y” or “Z”, world-oriented) through center (null = the center of the common bounding box, so the selection spins in place). Positive angles are counter-clockwise looking down the axis. copy true rotates copies.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null
angleDegrees	double	0
axis	string	"Z"
center	Point3d?	null
copy	bool	false

Returns IReadOnlyList<Guid>.

Scale

IReadOnlyList<Guid> TransformApi.Scale(
    IEnumerable<Guid> objectIds = null,
    double factor = 1,
    double factorY = 0,
    double factorZ = 0,
    Point3d? center = null,
    bool copy = false)

Scales the objects by factor about center (null = the center of the common bounding box). factorY/factorZ 0 = same as factor (uniform); given, each axis scales by its own factor (world axes). copy true scales copies.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null
factor	double	1
factorY	double	0
factorZ	double	0
center	Point3d?	null
copy	bool	false

Returns IReadOnlyList<Guid>.

ScaleByCenter

IReadOnlyList<Guid> TransformApi.ScaleByCenter(
    IEnumerable<Guid> objectIds = null,
    double factor = 1)

The ArtisanScaleByCenter command, headless: scales the objects uniformly by factor (> 0; 1 = no change) about the center of their common bounding box, so the set grows/shrinks in place. The scale plane is the active construction plane (world XY headless) moved to that center, like the command. In place; returns the ids.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	null
factor	double	1

Returns IReadOnlyList<Guid>.

ScaleByWeight

double TransformApi.ScaleByWeight(
    IEnumerable<Guid> objectIds,
    double targetGrams,
    string metal = null,
    bool keepOriginal = false)

Uniformly scales the objects so they weigh exactly targetGrams when cast in metal (the ArtisanScaleByWeight tool, headless). metal empty/null = the document’s primary metal; keepOriginal true scales a copy and leaves the original (the tool’s DeleteOriginal toggle, inverted). Objects must be closed solids/ meshes for their volume to count. Returns the scale factor that was applied (1.0 = it already weighed the target).

Parameter	Type	Default
objectIds	IEnumerable<Guid>	required
targetGrams	double	required
metal	string	null
keepOriginal	bool	false

Returns double.

ScaleToDimensions

IReadOnlyList<Guid> TransformApi.ScaleToDimensions(
    IEnumerable<Guid> objectIds,
    double sizeX = 0,
    double sizeY = 0,
    double sizeZ = 0,
    bool keepAspect = true,
    bool keepOriginal = false)

The ArtisanScaleByDimensions panel, headless: scales the objects (as one set, about the center of their common world-axis bounding box) so that box measures exactly the given sizes, in mm. 0 on an axis = leave that axis alone (factor from the other axes, or 1). With keepAspect true (the panel’s Keep Aspect toggle, on by default) exactly ONE of sizeX/sizeY/sizeZ must be given and the scale is uniform on the three axes — “make it 20 mm wide”. With keepAspect false each given axis scales independently. An axis on which the selection is flat (zero extent) cannot be driven, same as the panel disabling that field. keepOriginal true scales a copy and leaves the original (the panel’s Delete Original toggle, inverted; the panel default is to delete). Returns the ids of the resulting objects: new copies when keepOriginal is true, the same ids (scaled in place) otherwise.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	required
sizeX	double	0
sizeY	double	0
sizeZ	double	0
keepAspect	bool	true
keepOriginal	bool	false

Returns IReadOnlyList<Guid>.

Taper

IReadOnlyList<Guid> TransformApi.Taper(
    IEnumerable<Guid> objectIds,
    double deltaMm,
    string direction = null,
    string mode = null,
    double breakOne = 0,
    double breakTwo = 0,
    bool flat = false,
    bool infinite = false,
    IEnumerable<Guid> rigidIds = null,
    bool keepOriginal = false)

Tapers the objects along a bounding-box axis (the ArtisanTaper tool, headless): the section grows/shrinks linearly toward the “Top” end of the axis - tapered shanks, cone-ing a motif. deltaMm is how much the half-width changes at the far end, in mm: positive widens, negative narrows; must be non-zero. direction and the mode/breakOne/breakTwo trio work exactly like Twist’s (defaults “ZTop”, “Uniform”, 0.5, 0.75). flat tapers only in the gumball plane’s X (one-directional squeeze); infinite extends the taper beyond the axis ends instead of clamping. Returns the new object ids.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	required
deltaMm	double	required
direction	string	null
mode	string	null
breakOne	double	0
breakTwo	double	0
flat	bool	false
infinite	bool	false
rigidIds	IEnumerable<Guid>	null
keepOriginal	bool	false

Returns IReadOnlyList<Guid>.

Twist

IReadOnlyList<Guid> TransformApi.Twist(
    IEnumerable<Guid> objectIds,
    double angleDegrees,
    string direction = null,
    string mode = null,
    double breakOne = 0,
    double breakTwo = 0,
    IEnumerable<Guid> rigidIds = null,
    bool keepOriginal = false)

Twists the objects angleDegrees around a bounding-box axis (the ArtisanTwist tool, headless) - rope-like shanks, twisted wires, spiral motifs. direction is the twist axis through the bounding box: “ZTop” (default), “ZBottom”, “YTop”, “YBottom”, “XTop”, “XBottom” - the “Top” end is the one that rotates. mode limits where the twist happens along that axis: “Uniform” (default, whole length), “OneBreak” (only past breakOne) or “TwoBreaks” (only between breakOne and breakTwo). The breaks are normalized 0-1 positions on the axis; 0 = the tool defaults (0.5 and 0.75). Circles are rebuilt to 10-point degree-3 curves before twisting (same as the command), so they can actually deform. Returns the new object ids.

Parameter	Type	Default
objectIds	IEnumerable<Guid>	required
angleDegrees	double	required
direction	string	null
mode	string	null
breakOne	double	0
breakTwo	double	0
rigidIds	IEnumerable<Guid>	null
keepOriginal	bool	false

Returns IReadOnlyList<Guid>.