Look at the garment: capture CLO's 3D window from one or more camera views.

Use after simulating or editing to check the result (e.g. twisted seams, pieces in the wrong place, fabric through the avatar). Moves CLO's 3D camera.

Args: views: Any of front, back, left, right, three_quarter_left, three_quarter_right, top, bottom, zoom_all, current (default: ["front"]). fit_map: "strain" or "stress" to show CLO's fit map in the capture (red = tight or overstretched), "off" to hide it, or omit to leave the display as it is.

Show CLO's fit map in the 3D window: "strain" (stretch %), "stress" (pressure) or "off".

Picture of the 2D pattern pieces with every outline line numbered and seams coloured.

Blue numbers are line_index values for sewing, elastic, topstitch and seam taping; "sN" marks lines sewn by seam N; grey lines are internal lines. Pieces on another layer (appliqué, hem strips) lie on their base piece and are labelled with their layer, +z or -z. Pair it with get_pattern_geometry for exact lengths and coordinates.

Args: pattern_index: Draw only this piece (default: all pieces).

Make a rod pocket along a panel's top edge and hang the panel on a rod (curtains, banners, flags). The panel needs a straight, horizontal top edge. Verified with one panel; with several panels a pocket often fails to wrap, so prefer hang_on_rod there.

Adds a pocket strip above the panel, sews it to the top edge and to a fold line, holds the panel still, places a rod just in front of the strip above the top edge (the folding strip wraps it; verified in CLO 2025.2) and lets the panel hang. Returns whether the cloth stays up at the ends and in the middle; the pocket can be fuller in places, so look at the result with capture_3d. Save a checkpoint first.

Args: pattern_index: The panel, or a list of panels sharing one rod (e.g. the two halves of a noren); their top edges must be at the same height. pocket_depth: Height of the pocket strip in mm (the tube is roughly 1.4x this around). rod_diameter: Rod diameter in mm. rod_overhang: How far the rod extends past each side of the panel, in mm. settle_steps: Simulation steps after releasing the panel. pocket_side: Only "front" (+z, towards the front camera) forms reliably in CLO 2025.2. For a curtain whose pocket belongs on the back, build it facing the "back" camera (decorative patches on layer -1). Keep patches on the pocket side below fold_y.

Hang panels on a rod from a frozen header band: the reliable way to hang curtains, noren and banners (make_rod_pocket's folded pocket is not reliable with several panels).

Adds a band above each panel's straight top edge, sews it on, freezes it flat (it acts like a pin line) and lays a rod along it; the panels drape from the bands. The pocket does not wrap the rod in 3D: the rod lies against the band's rod_side face, so from the other side it looks like a rod pocket with the rod ends showing. Save a checkpoint first.

Args: pattern_index: The panel, or a list of panels sharing one rod; their top edges must be at the same height. band_height: Height of the band in mm, added above the top edge (so make the panels that much shorter for a given finished height). At least rod_diameter + 10. rod_diameter: Rod diameter in mm. rod_overhang: How far the rod extends past each side, in mm. settle_steps: Simulation steps to let the panels hang. rod_side: "front" (+z, towards the front camera) or "back" (-z). fabric_index: Fabric for the bands (default: each panel's own fabric).

3D bounding box (mm) of the cloth: min/max [x, y, z]. CLO's 3D axes: Y is up, Z points towards the front view camera, X to the avatar's left. Use it to place rods and props and to check where a piece ended up (e.g. is this panel still on the rod?).

CLO only reports cloth once it has been simulated, and reports nothing while every piece is frozen: run simulate(1) with at least one piece unfrozen first. A flat new piece lies at its 2D (x, y) coordinates in the plane z = 200.

Args: region_min: Only count vertices inside this box: [x, y, z] lower corner. region_max: Upper corner [x, y, z] of that box. pattern_index: Only this pattern's vertices.

Work out which cloth vertices belong to which pattern, for get_cloth_bounds(pattern_index). Run while the pieces are still flat (after a few simulation steps, before draping).

CLO lists cloth vertices pattern by pattern, but its per-pattern counts are slightly off, so the boundaries are found from the flat layout. Freezing or unfreezing pieces reorders CLO's list (unfrozen pieces first) and changes the mesh; the map is then refused, so map again in the new state.

Add a cylinder (curtain rod, rail, hanger bar...) that cloth collides with.

All rods and boxes form one collision object (CLO keeps a single avatar), placed exactly at the given coordinates. For curtains, make_rod_pocket does the whole job. Tested in CLO 2025.2: cloth passes through a thin rod unless its mesh is finer than the rod, so set the pieces' particle_distance to about a third of the diameter and use >= 30 mm.

Args: center: [x, y, z] centre in mm (see get_cloth_bounds for where the cloth is). length: Length in mm. diameter: Diameter in mm. axis: Direction of the rod: "x" (left-right), "y" (up-down) or "z" (front-back). replace_avatar: Allow replacing a human avatar in the scene.

Add a box that cloth collides with (a table, shelf, bed or window sill...).

Args: center: [x, y, z] centre in mm. size: [width_x, height_y, depth_z] in mm. replace_avatar: Allow replacing a human avatar in the scene.

The rods and boxes currently in the scene, with the index remove_collision_object takes.

Remove one rod or box (index from list_collision_objects); the others stay.

Import your own OBJ (e.g. a modelled curtain rail or furniture) as an object cloth collides with. Units are mm unless scale is set (e.g. 10 for a model in cm). It replaces the current avatar and any rods or boxes (CLO keeps a single avatar).

Args: file_path: Absolute path to the .obj file. keep_position: Keep the file's coordinates (False: CLO drops it onto the ground). scale: Scale factor applied on import.

Save the whole scene so it can be restored later. CLO's API has no undo, so save one before risky edits (sewing, deleting lines, simulating). Reusing a name overwrites it.

CLO saves the checkpoint like "Save As", so its open file becomes the checkpoint copy. The result's original_path is the real file: save there with save_project when done.

List saved checkpoints, newest first.

Reopen a checkpoint, replacing the current scene (unsaved changes are lost).

Afterwards CLO's open file is the checkpoint copy; save with save_project to the original_path returned here to keep working on the real file.

Get information about the current CLO3D project including name, path, version, and counts for patterns, fabrics, and colorways.

Create a new empty CLO3D project, clearing the current scene.

Args: discard_unsaved: Drop unsaved changes when CLO asks; otherwise it stops with an error.

Open a file in CLO3D. Supports .zprj, .zpac, .avt, .obj, .fbx formats.

Args: file_path: Absolute path to the file to open. discard_unsaved: Drop unsaved changes when CLO asks; otherwise it stops with an error.

Save the current CLO3D project as a .zprj file.

Args: file_path: Absolute path for the saved .zprj file.

Export and retrieve garment metadata as JSON, including pattern details, fabric assignments, and measurements.

Get the total number of pattern pieces in the current project.

Get a list of all pattern pieces with their indices and names.

Get detailed information about a specific pattern piece.

Args: pattern_index: Zero-based index of the pattern piece.

Get the bounding box (width/height) of a pattern piece.

Args: pattern_index: Zero-based index of the pattern piece.

Rename a pattern piece.

Args: pattern_index: Zero-based index of the pattern piece. name: New name for the pattern piece.

Duplicate a pattern piece at a given position.

Args: pattern_index: Zero-based index of the pattern piece to copy. x: X position offset for the copy (mm). y: Y position offset for the copy (mm).

Delete a pattern piece from the project.

Args: pattern_index: Zero-based index of the pattern piece to delete.

Flip a pattern piece horizontally or vertically.

Args: pattern_index: Zero-based index of the pattern piece to flip. horizontal: True for horizontal flip, False for vertical flip.

Create a new pattern piece from vertex points.

Args: points: List of [x, y] or [x, y, type] coordinates in mm. Type: 0=straight (default), 2=spline, 3=bezier. Example: [[0,0], [100,0], [100,200], [0,200]]

Returns the new pattern_index and its outline lines (line_index, start, end, length), so you can sew, hem or topstitch without looking the piece up.

Get the list of arrangement points on the avatar.

Get a list of all fabrics in the current project with their indices and names.

A fabric's name, its information fields (content, classification, supplier...) and CLO's fabric info JSON.

Set a fabric's name and information fields, e.g. {"Content": "60% Cotton, 40% Linen"}. Field names are CLO's (see get_fabric_info). This is metadata only; the drape comes from the fabric's physical properties.

Save a fabric as a .zfab file (CLO 2025.2 refuses .jfab here; the .fab inside is binary).

Args: fabric_index: Fabric to export. file_path: Absolute output path ending in .zfab.

Apply a .jfab file (CLO's JSON fabric format, see JFABSpec.json in the CLO SDK) to a fabric. Keys the file leaves out at the top level keep their values (colour, texture, content), but a "mapPhysical" block replaces the whole physical set: its missing keys reset to CLO's defaults, and a missing "qsFabricName" clears the name. set_fabric_physics handles this for you.

Set all of a fabric's physical properties (how it stretches, bends and hangs), keeping its colour, texture and name. CLO cannot report a fabric's current values (only weight and thickness, via get_fabric_info), so every value is written: the defaults are CLO's documented defaults, not the fabric's own. Pass real values for a specific cloth, or keep a library fabric (add_fabric) whose physics were measured.

Args: fabric_index: Fabric to change. weight_gsm: Weight in g/m2. thickness_mm: Thickness in mm. stretch_weft: Stretch stiffness across the grain (weft); higher = less stretch. stretch_warp: Stretch stiffness along the grain (warp). shear: Shear stiffness (bias stretch). bending_weft: Bending stiffness across the grain; higher = stiffer, fewer folds. bending_warp: Bending stiffness along the grain. bending_bias: Bending stiffness on the bias. buckling_ratio: Buckling ratio (all directions). buckling_stiffness: Buckling stiffness (all directions). friction: Friction. internal_damping: Internal damping. content: Optionally also set the content label, e.g. "60% Cotton, 40% Linen". property_name: Name for this set of physical properties.

Add a new fabric to the project from a .zfab or .jfab file.

Args: file_path: Absolute path to the fabric file (.zfab or .jfab).

Replace an existing fabric with a new one from file.

Args: fabric_index: Zero-based index of the fabric to replace. file_path: Absolute path to the replacement fabric file (.zfab).

Assign a fabric to a pattern piece.

Args: fabric_index: Zero-based index of the fabric. pattern_index: Zero-based index of the pattern piece. assign_option: 1=current colorway only, 2=all colorways (unlinked), 3=all colorways (linked).

Set the PBR base color of a fabric.

Args: fabric_index: Zero-based index of the fabric. r: Red channel (0-255). g: Green channel (0-255). b: Blue channel (0-255). face: "front", "back" or "side". The back and side only show their own colour once set_fabric_faces has separated them from the front.

Give a fabric a back face of its own, for double-faced and reversible cloth (e.g. plaid on the front, solid charcoal on the back), or join it to the front again. Do this before texturing the front: a back separated afterwards copies the front's texture.

Args: fabric_index: Fabric to change. separate_back: True for its own back material and colour, False to use the front's. back_color: Optionally set the back's colour at the same time, [r, g, b] 0-255.

Use an image (PNG, JPG) as a fabric's base texture.

Make a plaid (tartan) texture from its stripe sequence and put it on a fabric. The same stripes run both ways; where two colours cross they mix in a twill, as in woven checks.

Args: fabric_index: Fabric to texture. sett: One repeat as [[colour, width_mm], ...], e.g. a grey/black workwear check: [["#1b1b1d", 45], ["#5d5d60", 6], ["#1b1b1d", 6], ["#5d5d60", 35], ["#8e8e90", 3], ["#5d5d60", 35]]. The repeat is the sum of the widths. px_per_mm: Image resolution. twill: Mix crossing colours along diagonals (woven look) instead of averaging them. back_color: For double-faced cloth, a plain back in this colour [r, g, b]. The back is separated before the plaid goes on: separated afterwards, it copies the plaid (tested in CLO 2025.2.236).

Get which fabric is assigned to a pattern piece.

Args: pattern_index: Zero-based index of the pattern piece.

Export the garment as an OBJ file.

Args: file_path: Absolute path for the exported .obj file. options: Optional export options (bExportGarment, bExportAvatar, bThin, scale, etc.).

Export the garment as an FBX file.

Args: file_path: Absolute path for the exported .fbx file.

Export the garment as a GLB (binary glTF) file.

Args: file_path: Absolute path for the exported .glb file. options: Optional export options.

Export the garment as a glTF file.

Args: file_path: Absolute path for the exported .gltf file. options: Optional export options.

Export a 3D viewport screenshot/thumbnail.

Args: file_path: Absolute path for the exported image file. width: Image width in pixels (default 512). height: Image height in pixels (default 512).

Save front, back, left and right images of the 3D window as PNG files.

To look at the garment yourself, use capture_3d instead (returns the images).

Args: file_path: Base path; files are saved as _front.png, _back.png, ...

Export a 360-degree turntable image sequence.

Args: file_path: Absolute path (directory or base name) for turntable images.

Export a tech pack with JSON metadata and images.

Args: file_path: Absolute path for the tech pack output.

Current 2D export settings (paper, orientation, resolution and what is shown) for the pattern window ("pattern") or the print layout ("print_layout").

Export the 2D pattern as a PDF (vector, exactly 1:1: verified in CLO 2025.2) or PNG, by the file's extension, for plotting or printing.

"print_layout" exports the marker of the fabric shown in CLO's Print Layout Editor (see marker_report): the page is the fabric width by the marker length. It needs the layout set up once in CLO (Printing Layout mode, Auto Nesting). "pattern" exports the pattern window.

Args: file_path: Absolute path ending in .pdf or .png. source: "print_layout" or "pattern". paper: a4, a3, b5, b4, letter, legal, tabloid, wide_24in, wide_36in, wide_44in, one_to_one or custom (then give width_mm and height_mm). Default: CLO's setting. The PDF stays one 1:1 page whatever the paper (tested with a4: no tiling), so tile it with your plotter or PDF software for small paper. landscape: Paper orientation. width_mm: Paper width for custom paper. height_mm: Paper height for custom paper. resolution_dpi: Resolution for PNG output. show: What to draw, e.g. {"seam_allowance": true, "notches": true, "grain_line": true, "pattern_name": true, "annotations": true}. Keys: outline, internal_lines, graphic_outline, baseline, notches, seam_allowance, symmetry_line, reference_line, pattern_name, annotations, line_length, grain_line, button_holes, seam_taping, measurements_2d, grading_size_name, nest_information, fabric_texture, pattern_texture, graphic_texture.

Export the pattern as a DXF for CAD, plotters and cutters (no dialog). Returns the pieces read back from the file (name, size, quantity, outline box in mm) as a check.

Args: file_path: Absolute path ending in .dxf. format: "aama", "astm" or "gerber" (Gerber-flavoured AAMA). metric: Millimetres (True) or inches. box_per_piece: One bounding box per piece instead of one around all pieces. curves_to_straight: Convert curve points to straight points. optimize_curve_points: Drop curve points very close to others. without_grading: Leave grading out. without_baselines: Only the outlines, without base lines. remove_duplicate_notches: Remove duplicate notches. scale: Scale factor. rotate_degrees: Rotate the pieces.

Set a fabric's usable width (the marker width in the print layout), in mm.

Nesting settings for the print layout: spacing between pieces, which colourways get the result, and per piece how it may turn ("1-way": as cut, "2-way": also turned 180 degrees, "4-way": also 90 degrees) or a fixed [x, y] position.

Auto-nest the pieces in CLO's print layout and report the marker shown there: length along the fabric, width, pieces and utilisation (measured from the exported 1:1 layout; CLO's own fabric length value did not match the layout in testing).

In a fresh CLO session the API's nesting leaves the layout empty until CLO's Printing Layout mode has been opened once (tested: empty before the switch, working right after it and for the rest of the session, also back in Simulation mode). If it is still empty, allow_ui_click clicks "Nest All Fabrics" in CLO (needs Printing Layout mode); otherwise the error says what to do.

Args: buffer_spacing_mm: Space between pieces. fabric_index: With fabric_width_mm, set this fabric's width first. fabric_width_mm: Usable fabric width in mm. timeout_s: How long to wait for CLO's nesting to finish. allow_ui_click: Click CLO's "Nest All Fabrics" button when the layout is empty.

Click "Nest All Fabrics" in CLO's Print Layout Editor (through Windows UI Automation), for when the print layout is empty: the API's nesting only works once CLO's own nesting has run. CLO must be in Printing Layout mode (the user switches it; CLO's mode menu cannot be driven this way). Returns the marker it produced.

The dialog open in CLO right now, if any: title, message and buttons. Commands answer CLO's acknowledge-only dialogs (OK / Close) themselves and list them in clo_dialogs; a dialog that needs a decision stops the command with its text and buttons instead of hanging.

Click a button on the dialog open in CLO (see get_clo_dialog). If a command was stopped by the dialog, it carries on inside CLO and its result is returned here. Decisions that lose work (e.g. "No" to saving changes) are the user's to make.

Close CLO and start it again, e.g. to load a rebuilt plug-in or recover from a hang.

The scene is saved first as the checkpoint "before_restart" and reopened afterwards. CLO is then ended without its own save prompt. If the scene cannot be saved (CLO not answering), nothing is closed unless discard_unsaved=True.

Args: save_first: Save the scene as checkpoint "before_restart" first. reopen: Reopen that checkpoint once CLO is back. install_plugin: Path of a plug-in DLL to install while CLO is closed (e.g. cpp_plugin/dist/CloMcpPlugin.dll); CLO only loads plug-ins at startup. discard_unsaved: Close even when the scene could not be saved. timeout_s: How long to wait for CLO and the plug-in to come back.

Measure the marker shown in CLO's Print Layout Editor: which fabric it is, its length along the fabric, width, pieces, area and utilisation, from a 1:1 PDF export (path included for plotting). CLO exports one fabric at a time and the API cannot switch it; the result lists the other fabrics to switch to in CLO.

Write a note on a piece (cut quantity, fabric, size, "place on fold"...) at 2D (x, y) in the piece's coordinates; it prints on pattern sheets with show={"annotations": true}. With annotation_index, replace that note instead.

The notes written on a piece, with their positions.

Import a file into CLO3D. Auto-detects type from extension (.zprj, .zpac, .obj, .fbx, .avt, etc.).

Args: file_path: Absolute path to the file to import.

Run cloth simulation for a number of steps.

Args: steps: Number of simulation steps to run (default 100).

Get a list of all colorways in the current project with names and which is active.

Switch to a different colorway.

Args: colorway_index: Zero-based index of the colorway to activate.

Get pattern pieces with numbered outline lines, internal shapes and all seams.

Use this before sewing or editing lines: every line-based tool takes the line_index values listed here. Each line has its length (mm) and start/end points in 2D pattern coordinates. Each seam lists, for both sides, the pattern, optional internal shape, the lines it covers (coverage 1.0 = whole line) and where stitching starts and ends. "sewn_together" pairs those ends (side a's start is sewn to side b's start, end to end): if a left end is paired with a right end the seam is twisted; sew it again with one direction flipped. A pocket's fold-over seam deliberately pairs the strip's top edge with a lower line.

Args: pattern_index: Only return this piece and the seams touching it (default: all). include_points: Also return every point of every line (larger output).

Sew one line to another (segment sewing). Get line indices from get_pattern_geometry.

If the seam comes out twisted, sew it again with one direction flipped.

Args: pattern_a: Pattern index of side A. line_a: Line index on side A (outline line, or line of internal_shape_a). pattern_b: Pattern index of side B. line_b: Line index on side B (outline line, or line of internal_shape_b). direction_a: Stitch direction along line A (True = forward). direction_b: Stitch direction along line B (True = forward). internal_shape_a: Sew a line of this internal shape on A instead of the outline. internal_shape_b: Sew a line of this internal shape on B instead of the outline.

Sew two outline edges by saying which points meet: from_a meets from_b and to_a meets to_b. The lines are found by their endpoints (2D pattern coordinates, mm, within 2 mm) and the stitch directions follow, so the seam cannot come out twisted (with sew_lines the direction flags are easy to get backwards).

Args: pattern_a: Piece of side A. from_a: One end of the edge on A, e.g. the neck point [x, y]. to_a: The other end on A, e.g. the shoulder point. pattern_b: Piece of side B. from_b: The point on B that meets from_a. to_b: The point on B that meets to_a.

List the topstitch styles in the project, for add_topstitch's style_index.

Create a topstitch style with a given stitch length, thread thickness and offset from the stitched line (CLO's API cannot set these on a style, so a saved style file is copied with the values changed and imported). Returns its style_index for add_topstitch.

The stitch's shape and colour come from a template: a style saved from CLO once (select a topstitch in the Object Browser, set its Shape, e.g. Overlock, and colour in the Property Editor, click the save icon in its Topstitch row) and passed as template_path with a template name; later calls just name the template.

Args: name: Name for the new style. stitch_length_mm: Length of each stitch in mm (default: the template's). thread_thickness_mm: Thread thickness in mm (CLO shows it as Tex: 0.2 mm = 40 Tex). offset_mm: Distance of the stitching from the line or seam it follows, in mm. template: Which saved template to use, e.g. "default" or "overlock". template_path: A .sst saved from CLO, stored as this template (first time only).

A topstitch style's name, offset and per-line values as CLO's API reports them (stitch length and thread thickness are not readable through the API).

Rename a topstitch style, set its thread colour ([r, g, b] 0-255) or its number of parallel lines. For stitch length, thread thickness and offset use create_topstitch_style.

Add topstitching either along a seam or along one pattern line.

Args: style_index: Topstitch style from list_topstitch_styles. seam_index: Topstitch this seam (from get_pattern_geometry). start_ratio: Where along the seam to start (0-1), with seam_index. end_ratio: Where along the seam to end (0-1), with seam_index. pattern_index: Topstitch a line of this pattern instead of a seam. line_index: The line to topstitch, with pattern_index.

Topstitch a whole garment in one go: every seam and/or every free outline edge (edges no seam uses: hems, front edges, cuffs, collar tops), e.g. the contrast edge stitching of a reversible or unlined jacket.

Args: style_index: Topstitch style (list_topstitch_styles, create_topstitch_style). seams: Stitch along every seam. free_edges: Stitch every free outline edge. pattern_indices: Only these pieces (default: all).

Turn seam taping on or off for one outline line of a pattern.

Set simulation state of a pattern piece. Only the values you pass are changed.

CLO's API cannot place pins; freeze or strengthen a piece to hold it in place instead.

Args: pattern_index: Pattern to change. frozen: Freeze (excluded from simulation, stays where it is). strengthened: Strengthen (stiffer, holds shape). solidified: Solidify. solidify_strength: Solidify strength. hidden_3d: Hide the piece in the 3D window. layer: Layer number (higher layers sit on top in collisions). particle_distance: Mesh particle distance in mm (smaller = finer mesh, slower). grain_degrees: Grainline direction in degrees.

Get a piece's layer, solidify state, grain direction, shrinkage and 3D arrangement.

Remove every pin in the scene. (CLO's API can remove pins but not create them.)

List the avatar's arrangement points (needs an avatar in the scene) for place_pattern.

Place a pattern piece in 3D on an avatar arrangement point.

CLO's API has no free XYZ move/rotate; placement goes through arrangement points. Run simulate afterwards to drape.

Args: pattern_index: Pattern to place. arrangement_index: Arrangement point from get_arrangement_points. orientation: Orientation value for the piece on the point. position_x: Position on the arrangement surface (set together with position_y/offset). position_y: Position on the arrangement surface. offset: Distance from the arrangement surface. shape_style: "Flat" or "Curved" (wrap around the body).

Reset all pieces to their arrangement positions (undo draping).

Move a piece in the 2D pattern window: to (x, y), or by (dx, dy).

Draw an internal line or shape on a pattern (fold lines, darts, pocket placement...).

Args: pattern_index: Pattern to draw on. points: [[x, y], ...] or [[x, y, type], ...] in pattern coordinates (mm), inside the piece (CLO also accepts points outside it); type 0 = straight, 2 = spline curve, 3 = bezier curve. Use get_pattern_geometry for the piece's coordinates. closed: Connect the last point back to the first.

Create internal lines parallel to an outline line (e.g. hem fold or pleat lines).

The offset must fit inside the piece; if CLO creates nothing, the tool returns an error (try reverse=True, a smaller distance, or a longer line).

Args: pattern_index: Pattern to draw on. line_index: Outline line to offset from. distance: Distance between lines in mm. count: Number of lines to create. reverse: Offset to the other side. extend: Extend the new lines to the piece outline.

Convert an internal shape to a base line ("base") or back ("internal").

Delete an outline point (point n is the start point of line n; see get_pattern_geometry).

Delete an outline line of a pattern.

Create a symmetric (mirrored, linked) copy of a piece, optionally copying its sewing.

Unfold a half pattern across one of its lines (e.g. the centre-front fold line).

Hem a straight edge: adds the turned-back layer as a strip covering the hem area on the reverse side, sewn along the edge and along a new hem line (cloth cannot be folded this way: a fold angle only bends it about 20 degrees, even at full strength). Gives the doubled fabric at the edge. The pattern's edge is the finished edge, so draw pieces at their finished size.

Args: pattern_index: Piece to hem. line_index: The straight outline line to hem (from get_pattern_geometry / view_patterns). width: Finished hem width in mm. layer: Layer for the hem strip: -1 = the -z side (towards the back camera), 1 = the +z side. Use the side opposite the garment's face. Where hems cross (a bottom hem and the side hems), put the later ones one layer further out (e.g. -2), like the real corner; on the same layer the overlapping strips crumple. fabric_index: Fabric for the strip (default: the piece's fabric). place_flat: Place the strip Flat, like a piece laid out without an avatar; set False and place it yourself for pieces on an avatar.

Add an appliqué patch on a piece, sewn to it where it sits (a new internal line on the base marks each sewn edge). Optionally the matching patch on the other side ("front and reverse patches"), sharing the same stitch line.

Args: pattern_index: Base piece. points: The patch outline in the base's 2D coordinates (mm), inside the piece. sewn_lines: Sew only the first N edges (points[0]->points[1] is edge 0); edges on the base's outline or a seam can stay free. Default: all edges. layer: Layer for the patch: 1 = the +z side, -1 = the -z side. reverse: Also add the same patch on the opposite layer. fabric_index: Fabric for the patch (default: the base's fabric). name: Name for the patch piece(s); " front"/" reverse" is added with reverse=True. place_flat: Place the patch Flat; set False and place it yourself on an avatar. reverse_layer: Layer for the reverse patch (default: -layer). Put it outside any hem strips it crosses (e.g. 3 over hems on 1 and 2).

Set elastic on a pattern line (or all lines with line_index=-1). Only passed values change.

Args: pattern_index: Pattern to change. line_index: Outline line, or -1 for every line. enabled: Elastic on/off. strength: Elastic strength. ratio: Elastic strength ratio in percent. segment_length: Elastic segment length in mm. total_length: Elastic total length in mm.

Set a piece's fabric shrinkage as its size in percent: 100 = no shrinkage, 97 = shrinks 3 %.

Args: pattern_index: Pattern to change. width_percent: Width (weft) size in percent, 50-150. height_percent: Height (warp) size in percent, 50-150.

Set the simulation preset: 0 Normal, 1 Animation (stable), 2 Fitting (accurate), 3 FAST (GPU).

Args: quality: Preset index. simulation_mode: 0 CPU, 1 GPU (defaults to GPU for preset 3, CPU otherwise).

List avatars in the scene with names and genders.

Load an avatar (.avt, .avac) into the scene, optionally with an arrangement file (.apf).

Pose the avatar from a .pos file (made and saved in CLO, or with save_pose). CLO's API cannot bend joints itself, so poses are built in CLO's pose tools and reused from files. Load the pose before placing garment pieces: arrangement points follow the avatar.

Args: file_path: The .pos file. pose_and_translation: Also apply the pose's position in the scene (default: pose only). bottom_to_ground: Stand the avatar's feet on the ground afterwards.

Save the avatar's current pose as a .pos file, for load_pose later (e.g. after posing it in CLO). Without a path CLO writes it to its temporary folder; the path is returned.

Show or hide the avatar.

Delete a fabric from the project.