# Scan and Mesh Workshop

## Links

- Product page URL: https://www.agentpmt.com/marketplace/scan-and-mesh-workshop
- Product markdown URL: https://www.agentpmt.com/marketplace/scan-and-mesh-workshop?format=agent-md
- Product JSON URL: https://www.agentpmt.com/marketplace/scan-and-mesh-workshop?format=agent-json

## Overview

- Product ID: 6ae3e6dc6b8e2f458be7d95c
- Type: function
- Unit type: request
- Price: 300 credits
- Categories: Quality Assurance, AI & Machine Learning, Data Processing, 3D Design & Modeling, 3D Printing / 3DMF, 3D Asset Creation, Spatial Analysis
- Generated at: 2026-11-03T10:30:27.085Z

### Page Description

Turn raw 3D scans, point clouds and meshes into clean, measured, ready-to-use geometry in one place. Load common mesh, point cloud and STEP files and get an immediate quality report. Clean noisy scans, downsample, rebuild surfaces, or fuse depth camera frames into a mesh. Repair meshes by welding, removing defects and filling holes so they follow the surrounding curvature, then simplify, smooth or combine them with watertight booleans. Align scans automatically, compare a scan with its design to see deviation maps and the share within tolerance, and measure sizes, cross sections, flat faces and wall thickness. Split scenes into planes, clusters or AI-labeled parts such as walls, floors, furniture, roads and vehicles. Render preview images and export to standard formats in the units you need.

### Agent Description

Load scans, point clouds and meshes, then clean, repair, fill holes, reconstruct surfaces, align, compare against a reference, measure, segment (including AI scene labels and 3D object boxes), render and export, with quality reports and previews on every step.

## Details

### Details

Turn raw 3D scans, point clouds and meshes into clean, measured, ready-to-use geometry in one place. Load common mesh, point cloud and STEP files and get an immediate quality report. Clean noisy scans, downsample, rebuild surfaces, or fuse depth camera frames into a mesh. Repair meshes by welding, removing defects and filling holes so they follow the surrounding curvature, then simplify, smooth or combine them with watertight booleans. Align scans automatically, compare a scan with its design to see deviation maps and the share within tolerance, and measure sizes, cross sections, flat faces and wall thickness. Split scenes into planes, clusters or AI-labeled parts such as walls, floors, furniture, roads and vehicles. Render preview images and export to standard formats in the units you need.

### Actions

- `inspect_geometry` (2 credits): Load a mesh, point cloud or STEP file, or re-check an existing geometry. Returns a geometry_id and a quality report: counts, size, watertightness, self-intersections, holes, pieces, normals, colors, point spacing, suggested next steps and a preview image.
- `create_geometry` (2 credits): Create a mesh primitive, 3D text or an extruded outline, ready to process, combine with booleans, measure or export.
- `process_point_cloud` (3 credits): Clean and prepare a point cloud with ordered steps: downsampling, outlier removal, normals, cropping, transforms, merging and keeping segment labels. Returns a new geometry and a per-step report.
- `process_mesh` (3 credits): Repair and modify a mesh with ordered steps: welding, cleanup, hole filling that follows the surrounding curvature, self-intersection repair, simplification, smoothing, subdivision, watertight booleans, piece filtering, transforms, ambient occlusion and point sampling. Every result is checked for watertightness.
- `reconstruct_surface` (8 credits): Build a mesh from a point cloud, or fuse RGB-D camera frames into a mesh. auto picks the method and settings from the data.
- `register_geometry` (5 credits): Align scans to a target automatically (feature matching, then ICP). Returns the transform, fit quality, aligned geometries, an overlay image, and a warning when a symmetric part also fits flipped.
- `compare_geometry` (5 credits): Compare a scan or mesh with a reference: deviation statistics, percent within tolerance, signed inside or outside deviation for closed references, Chamfer, Hausdorff and F-score, plus a colored deviation map.
- `measure_geometry` (2 credits): Measure a geometry: size and oriented box, area and volume, cross sections, flat faces, wall thickness between parallel faces, distance to another geometry, and convex hull.
- `segment_geometry` (5 credits): Split a point cloud or mesh into labeled parts: planes, flat patches, clusters, connected pieces, AI scene labels (wall, floor, table, road, building, car and more) or AI 3D object boxes. Returns a labeled geometry for keep_labels, a per-segment summary and a colored preview.
- `render_geometry` (2 credits): Render PNG images of one or more geometries together, colored by their own colors (deviation maps, labels), height, normals or a uniform color.
- `export_geometry` (2 credits): Export a geometry to a mesh or point cloud file in the units you choose. glb and gltf are always meters, y-up, as the standard requires.
- `run_script` (5 credits): Run custom Open3D Python on your geometries for anything the other actions do not cover. Inputs are variables; publish(name, geometry) returns new geometries and report({...}) returns values.
- `get_task`: Check work that returned status processing. Completed tasks return the original action result in outputs[0]. Free.
- `list_tasks`: List your recent tasks with their status and the geometries they produced, newest first. Free.
- `cancel_task`: Cancel work that is still processing. Free.

### Use Cases

Clean a noisy 3D scan and turn it into a watertight mesh, Compare a scanned part against its CAD design, Repair a broken STL before 3D printing, Align several scans of the same object, Measure wall thickness and sections from a scan, Label walls, floors and furniture in a room scan, Convert meshes between formats and units

### Workflows Using This Tool

No public workflows currently reference this product.

### Related Content

No related content is currently linked to this product.

## Documentation

No platform documentation is currently linked to this product.

## Integration Details

### DynamicMCP

- Setup page URL: https://www.agentpmt.com/dynamic-mcp
- Claude setup guide: https://www.agentpmt.com/dynamic-mcp#platform=claude
- ChatGPT setup guide: https://www.agentpmt.com/dynamic-mcp#platform=chatgpt
- Cursor setup guide: https://www.agentpmt.com/dynamic-mcp#platform=cursor
- Windsurf setup guide: https://www.agentpmt.com/dynamic-mcp#platform=windsurf

Use the local router for command-based MCP clients. It forwards requests to `https://api.agentpmt.com/mcp` and does not execute tools locally.

```bash
npm install -g @agentpmt/mcp-router
agentpmt-setup
```

### REST API

The live page renders cURL, Python, JavaScript, and Node.js examples. Logged-in users see those examples prefilled with their own API and budget credentials.

- Purchase endpoint: https://api.agentpmt.com/products/purchase
- Authorization format: `Bearer <base64(apiKey:budgetKey)>`

```bash
curl -X POST "https://api.agentpmt.com/products/purchase" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer eW91ci1hcGkta2V5LWhlcmU6eW91ci1idWRnZXQta2V5LWhlcmU=" \
  -d '{
    "product_id": "6ae3e6dc6b8e2f458be7d95c",
    "parameters": {
      "action": "inspect_geometry"
    }
  }'
```

### Autonomous Agents

Autonomous agents can access this tool through AgentAddress credit balances or direct x402 payments. Use the Autonomous Agent API reference for endpoint shapes after choosing the access pattern below.

- Autonomous Agent API reference URL: https://www.agentpmt.com/docs/api-reference/autonomous-agents
- Autonomous Agent API reference markdown URL: https://www.agentpmt.com/docs/api-reference/autonomous-agents?format=agent-md
- Credit-Based Access Using AgentAddress: https://www.agentpmt.com/docs/autonomous-agents/credit-based-tool-usage-with-agentaddress
- AgentAddress is preferred for persistent file access, stored platform state, and maximum tool use ability across repeated calls.
- Direct x402 is for independent one-off tool calls that do not require shared files or stored platform state.
- Direct x402 public payments: USDC on Base, Arbitrum, Optimism, Polygon, and Avalanche.

### Schema

#### Parameters

- Schema type: actions

```json
{
  "actions": {
    "inspect_geometry": {
      "description": "Load a mesh, point cloud or STEP file, or re-check an existing geometry. Returns a geometry_id and a quality report: counts, size, watertightness, self-intersections, holes, pieces, normals, colors, point spacing, suggested next steps and a preview image.",
      "properties": {
        "file_id": {
          "type": "string",
          "description": "File Manager ID of a ply, obj, stl, off, glb, gltf, pcd, xyz, xyzn, xyzrgb, pts, step or stp file. Give file_id or geometry_id.",
          "required": false
        },
        "geometry_id": {
          "type": "string",
          "description": "Existing geometry to re-check instead of loading a file.",
          "required": false
        },
        "units": {
          "type": "string",
          "description": "Units of the file. Required for stl, obj, ply, off, pcd, xyz, xyzn, xyzrgb and pts, which record none. glb and gltf are meters and STEP declares its own; giving units converts to them.",
          "required": false,
          "enum": [
            "mm",
            "cm",
            "m",
            "in"
          ]
        },
        "up_axis": {
          "type": "string",
          "description": "Axis that points up in the file. Default y for glb and gltf, z otherwise. Stored z-up.",
          "required": false,
          "enum": [
            "x",
            "y",
            "z"
          ]
        },
        "load_as": {
          "type": "string",
          "description": "auto loads files with faces as meshes. Default auto.",
          "required": false,
          "enum": [
            "auto",
            "mesh",
            "point_cloud"
          ]
        },
        "step_tolerance": {
          "type": "number",
          "description": "STEP only: maximum mesh deviation from the exact surface in file units. Default 0.1 percent of the part size.",
          "required": false,
          "minimum": 0.0001
        },
        "preview": {
          "type": "boolean",
          "description": "Return a preview image of the result. Default true.",
          "required": false
        },
        "name": {
          "type": "string",
          "description": "Readable name used in file names.",
          "required": false
        }
      },
      "price_per_unit": 2
    },
    "create_geometry": {
      "description": "Create a mesh primitive, 3D text or an extruded outline, ready to process, combine with booleans, measure or export.",
      "properties": {
        "shape": {
          "type": "string",
          "description": "Shape to create.",
          "required": true,
          "enum": [
            "box",
            "sphere",
            "cylinder",
            "cone",
            "torus",
            "arrow",
            "tetrahedron",
            "octahedron",
            "icosahedron",
            "text",
            "extruded_outline"
          ]
        },
        "width": {
          "type": "number",
          "description": "Box size along x.",
          "required": false,
          "minimum": 0
        },
        "depth": {
          "type": "number",
          "description": "Box size along y, or text thickness.",
          "required": false,
          "minimum": 0
        },
        "height": {
          "type": "number",
          "description": "Box, cylinder, cone or extrusion height, arrow length, or text height.",
          "required": false,
          "minimum": 0
        },
        "radius": {
          "type": "number",
          "description": "Sphere, cylinder, cone, torus or polyhedron radius.",
          "required": false,
          "minimum": 0
        },
        "tube_radius": {
          "type": "number",
          "description": "Torus tube radius.",
          "required": false,
          "minimum": 0
        },
        "resolution": {
          "type": "integer",
          "description": "Segments around round shapes. Default 64.",
          "required": false,
          "minimum": 3,
          "maximum": 1024
        },
        "text": {
          "type": "string",
          "description": "Text for the text shape.",
          "required": false
        },
        "outline": {
          "type": "array",
          "description": "Closed outline for extruded_outline as [x, y] points in order.",
          "required": false,
          "items": {
            "type": "array",
            "description": "Point",
            "items": {
              "type": "number",
              "description": "Coordinate",
              "required": false
            },
            "required": false,
            "minItems": 2,
            "maxItems": 2
          },
          "maxItems": 10000
        },
        "center": {
          "type": "array",
          "description": "Center position. Default the origin.",
          "required": false,
          "items": {
            "type": "number",
            "description": "Component",
            "required": false
          },
          "minItems": 3,
          "maxItems": 3
        },
        "units": {
          "type": "string",
          "description": "Units for all sizes. Default mm.",
          "required": false,
          "enum": [
            "mm",
            "cm",
            "m",
            "in"
          ]
        },
        "name": {
          "type": "string",
          "description": "Readable name used in file names.",
          "required": false
        }
      },
      "price_per_unit": 2
    },
    "process_point_cloud": {
      "description": "Clean and prepare a point cloud with ordered steps: downsampling, outlier removal, normals, cropping, transforms, merging and keeping segment labels. Returns a new geometry and a per-step report.",
      "properties": {
        "geometry_id": {
          "type": "string",
          "description": "geometry_id returned by inspect_geometry or an earlier action.",
          "required": true
        },
        "steps": {
          "type": "array",
          "description": "Steps to run in order.",
          "required": true,
          "items": {
            "type": "object",
            "description": "One processing step",
            "properties": {
              "operation": {
                "type": "string",
                "description": "Operation. Steps run in order; omitted settings are chosen from the data and reported back.",
                "required": true,
                "enum": [
                  "voxel_downsample",
                  "uniform_downsample",
                  "random_downsample",
                  "farthest_point_downsample",
                  "remove_statistical_outliers",
                  "remove_radius_outliers",
                  "remove_non_finite",
                  "estimate_normals",
                  "orient_normals",
                  "crop_box",
                  "keep_labels",
                  "hidden_point_removal",
                  "transform",
                  "translate",
                  "rotate",
                  "scale",
                  "paint",
                  "merge"
                ]
              },
              "size": {
                "type": "number",
                "description": "Voxel size, radius or tolerance in geometry units, depending on the operation.",
                "required": false,
                "minimum": 0
              },
              "count": {
                "type": "integer",
                "description": "Points for farthest_point_downsample and sample_points, triangles for simplify, neighbors for outlier and normal steps, iterations for smooth and subdivide, rays for bake_ambient_occlusion.",
                "required": false,
                "minimum": 1
              },
              "ratio": {
                "type": "number",
                "description": "Fraction kept by random_downsample, or the standard deviation ratio for remove_statistical_outliers.",
                "required": false,
                "minimum": 0
              },
              "min": {
                "type": "array",
                "description": "Lower corner for crop_box.",
                "items": {
                  "type": "number",
                  "description": "Component",
                  "required": false
                },
                "required": false,
                "minItems": 3,
                "maxItems": 3
              },
              "max": {
                "type": "array",
                "description": "Upper corner for crop_box.",
                "items": {
                  "type": "number",
                  "description": "Component",
                  "required": false
                },
                "required": false,
                "minItems": 3,
                "maxItems": 3
              },
              "vector": {
                "type": "array",
                "description": "Offset for translate, axis for rotate, direction for orient_normals and hidden_point_removal.",
                "items": {
                  "type": "number",
                  "description": "Component",
                  "required": false
                },
                "required": false,
                "minItems": 3,
                "maxItems": 3
              },
              "angle_deg": {
                "type": "number",
                "description": "Rotation angle in degrees.",
                "required": false
              },
              "factor": {
                "type": "number",
                "description": "Scale factor about the center.",
                "required": false,
                "minimum": 0
              },
              "matrix": {
                "type": "array",
                "description": "Transform as 16 numbers, row by row, in the geometry units.",
                "items": {
                  "type": "number",
                  "description": "Matrix entry",
                  "required": false
                },
                "required": false,
                "minItems": 16,
                "maxItems": 16
              },
              "color": {
                "type": "array",
                "description": "RGB from 0 to 1 for paint.",
                "items": {
                  "type": "number",
                  "description": "Component",
                  "required": false
                },
                "required": false,
                "minItems": 3,
                "maxItems": 3
              },
              "geometry_ids": {
                "type": "array",
                "description": "Other geometries for merge or boolean.",
                "items": {
                  "type": "string",
                  "description": "geometry_id",
                  "required": false
                },
                "required": false,
                "maxItems": 20
              },
              "labels": {
                "type": "array",
                "description": "Labels to keep for keep_labels, from segment_geometry.",
                "items": {
                  "type": "string",
                  "description": "Label",
                  "required": false,
                  "maxLength": 100
                },
                "required": false,
                "maxItems": 100
              },
              "every_k": {
                "type": "integer",
                "description": "Keep every k-th point for uniform_downsample.",
                "required": false,
                "minimum": 2
              }
            },
            "required": false
          },
          "minItems": 1,
          "maxItems": 30
        },
        "preview": {
          "type": "boolean",
          "description": "Return a preview image of the result. Default true.",
          "required": false
        },
        "name": {
          "type": "string",
          "description": "Readable name used in file names.",
          "required": false
        }
      },
      "price_per_unit": 3
    },
    "process_mesh": {
      "description": "Repair and modify a mesh with ordered steps: welding, cleanup, hole filling that follows the surrounding curvature, self-intersection repair, simplification, smoothing, subdivision, watertight booleans, piece filtering, transforms, ambient occlusion and point sampling. Every result is checked for watertightness.",
      "properties": {
        "geometry_id": {
          "type": "string",
          "description": "geometry_id returned by inspect_geometry or an earlier action.",
          "required": true
        },
        "steps": {
          "type": "array",
          "description": "Steps to run in order.",
          "required": true,
          "items": {
            "type": "object",
            "description": "One processing step",
            "properties": {
              "operation": {
                "type": "string",
                "description": "Operation. Steps run in order; omitted settings are chosen from the data and reported back.",
                "required": true,
                "enum": [
                  "weld_vertices",
                  "remove_duplicates",
                  "remove_degenerate",
                  "remove_non_manifold_edges",
                  "orient_triangles",
                  "fill_holes",
                  "repair_self_intersections",
                  "simplify",
                  "cluster_simplify",
                  "smooth",
                  "subdivide",
                  "boolean",
                  "keep_largest_component",
                  "remove_small_components",
                  "crop_box",
                  "transform",
                  "translate",
                  "rotate",
                  "scale",
                  "compute_normals",
                  "bake_ambient_occlusion",
                  "sample_points",
                  "convex_hull",
                  "paint"
                ]
              },
              "size": {
                "type": "number",
                "description": "Voxel size, radius or tolerance in geometry units, depending on the operation.",
                "required": false,
                "minimum": 0
              },
              "count": {
                "type": "integer",
                "description": "Points for farthest_point_downsample and sample_points, triangles for simplify, neighbors for outlier and normal steps, iterations for smooth and subdivide, rays for bake_ambient_occlusion.",
                "required": false,
                "minimum": 1
              },
              "ratio": {
                "type": "number",
                "description": "Fraction kept by random_downsample, or the standard deviation ratio for remove_statistical_outliers.",
                "required": false,
                "minimum": 0
              },
              "min": {
                "type": "array",
                "description": "Lower corner for crop_box.",
                "items": {
                  "type": "number",
                  "description": "Component",
                  "required": false
                },
                "required": false,
                "minItems": 3,
                "maxItems": 3
              },
              "max": {
                "type": "array",
                "description": "Upper corner for crop_box.",
                "items": {
                  "type": "number",
                  "description": "Component",
                  "required": false
                },
                "required": false,
                "minItems": 3,
                "maxItems": 3
              },
              "vector": {
                "type": "array",
                "description": "Offset for translate, axis for rotate, direction for orient_normals and hidden_point_removal.",
                "items": {
                  "type": "number",
                  "description": "Component",
                  "required": false
                },
                "required": false,
                "minItems": 3,
                "maxItems": 3
              },
              "angle_deg": {
                "type": "number",
                "description": "Rotation angle in degrees.",
                "required": false
              },
              "factor": {
                "type": "number",
                "description": "Scale factor about the center.",
                "required": false,
                "minimum": 0
              },
              "matrix": {
                "type": "array",
                "description": "Transform as 16 numbers, row by row, in the geometry units.",
                "items": {
                  "type": "number",
                  "description": "Matrix entry",
                  "required": false
                },
                "required": false,
                "minItems": 16,
                "maxItems": 16
              },
              "color": {
                "type": "array",
                "description": "RGB from 0 to 1 for paint.",
                "items": {
                  "type": "number",
                  "description": "Component",
                  "required": false
                },
                "required": false,
                "minItems": 3,
                "maxItems": 3
              },
              "geometry_ids": {
                "type": "array",
                "description": "Other geometries for merge or boolean.",
                "items": {
                  "type": "string",
                  "description": "geometry_id",
                  "required": false
                },
                "required": false,
                "maxItems": 20
              },
              "mode": {
                "type": "string",
                "description": "fill_holes: smooth or flat. smooth: laplacian or taubin. subdivide: loop or midpoint. boolean: union, difference or intersection. sample_points: uniform or poisson.",
                "required": false,
                "enum": [
                  "smooth",
                  "flat",
                  "laplacian",
                  "taubin",
                  "loop",
                  "midpoint",
                  "union",
                  "difference",
                  "intersection",
                  "uniform",
                  "poisson"
                ]
              },
              "max_hole_edges": {
                "type": "integer",
                "description": "fill_holes: only fill holes with at most this many border edges. Default all.",
                "required": false,
                "minimum": 3
              }
            },
            "required": false
          },
          "minItems": 1,
          "maxItems": 30
        },
        "preview": {
          "type": "boolean",
          "description": "Return a preview image of the result. Default true.",
          "required": false
        },
        "name": {
          "type": "string",
          "description": "Readable name used in file names.",
          "required": false
        }
      },
      "price_per_unit": 3
    },
    "reconstruct_surface": {
      "description": "Build a mesh from a point cloud, or fuse RGB-D camera frames into a mesh. auto picks the method and settings from the data.",
      "properties": {
        "geometry_id": {
          "type": "string",
          "description": "Point cloud to reconstruct. Not used with rgbd_fusion.",
          "required": false
        },
        "method": {
          "type": "string",
          "description": "Default auto. poisson gives a closed watertight surface, ball_pivoting keeps the original points, alpha_shape suits sparse data, rgbd_fusion integrates camera frames.",
          "required": false,
          "enum": [
            "auto",
            "poisson",
            "ball_pivoting",
            "alpha_shape",
            "rgbd_fusion"
          ]
        },
        "detail": {
          "type": "string",
          "description": "Surface detail for poisson and rgbd_fusion. Default medium.",
          "required": false,
          "enum": [
            "low",
            "medium",
            "high"
          ]
        },
        "trim_low_density": {
          "type": "number",
          "description": "poisson: remove this fraction of the least supported surface, which opens holes. Default 0.",
          "required": false,
          "minimum": 0,
          "maximum": 0.5
        },
        "radius": {
          "type": "number",
          "description": "ball_pivoting radius or alpha_shape alpha in geometry units. Default from point spacing.",
          "required": false,
          "minimum": 0
        },
        "frames": {
          "type": "array",
          "description": "rgbd_fusion: color and depth image pairs in capture order.",
          "required": false,
          "items": {
            "type": "object",
            "description": "One RGB-D frame",
            "properties": {
              "color_file_id": {
                "type": "string",
                "description": "Color image File Manager ID.",
                "required": true
              },
              "depth_file_id": {
                "type": "string",
                "description": "16-bit depth image File Manager ID.",
                "required": true
              },
              "pose": {
                "type": "array",
                "description": "Camera-to-world transform as 16 numbers, row by row. Omit to estimate from the images.",
                "items": {
                  "type": "number",
                  "description": "Matrix entry",
                  "required": false
                },
                "required": false,
                "minItems": 16,
                "maxItems": 16
              }
            },
            "required": false
          },
          "maxItems": 500
        },
        "camera": {
          "type": "object",
          "description": "rgbd_fusion: pinhole intrinsics in pixels.",
          "required": false,
          "properties": {
            "width": {
              "type": "integer",
              "description": "Image width.",
              "required": true,
              "minimum": 1
            },
            "height": {
              "type": "integer",
              "description": "Image height.",
              "required": true,
              "minimum": 1
            },
            "fx": {
              "type": "number",
              "description": "Focal length x.",
              "required": true
            },
            "fy": {
              "type": "number",
              "description": "Focal length y.",
              "required": true
            },
            "cx": {
              "type": "number",
              "description": "Principal point x.",
              "required": true
            },
            "cy": {
              "type": "number",
              "description": "Principal point y.",
              "required": true
            }
          }
        },
        "depth_scale": {
          "type": "number",
          "description": "rgbd_fusion: depth units per meter. Default 1000.",
          "required": false,
          "minimum": 0
        },
        "depth_max": {
          "type": "number",
          "description": "rgbd_fusion: ignore depth beyond this many meters. Default 3.",
          "required": false,
          "minimum": 0
        },
        "units": {
          "type": "string",
          "description": "rgbd_fusion: units for the fused mesh. Default m.",
          "required": false,
          "enum": [
            "mm",
            "cm",
            "m",
            "in"
          ]
        },
        "preview": {
          "type": "boolean",
          "description": "Return a preview image of the result. Default true.",
          "required": false
        },
        "name": {
          "type": "string",
          "description": "Readable name used in file names.",
          "required": false
        }
      },
      "price_per_unit": 8
    },
    "register_geometry": {
      "description": "Align scans to a target automatically (feature matching, then ICP). Returns the transform, fit quality, aligned geometries, an overlay image, and a warning when a symmetric part also fits flipped.",
      "properties": {
        "source_geometry_id": {
          "type": "string",
          "description": "Geometry to move.",
          "required": true
        },
        "target_geometry_id": {
          "type": "string",
          "description": "Geometry to align to.",
          "required": true
        },
        "extra_source_geometry_ids": {
          "type": "array",
          "description": "More scans, each aligned to the target the same way.",
          "required": false,
          "items": {
            "type": "string",
            "description": "geometry_id",
            "required": false
          },
          "maxItems": 50
        },
        "method": {
          "type": "string",
          "description": "Default auto: global feature matching, then point-to-plane ICP. ICP options refine from initial_transform.",
          "required": false,
          "enum": [
            "auto",
            "icp_point_to_point",
            "icp_point_to_plane",
            "icp_colored",
            "icp_generalized"
          ]
        },
        "initial_transform": {
          "type": "array",
          "description": "Transform as 16 numbers, row by row, in the geometry units.",
          "required": false,
          "items": {
            "type": "number",
            "description": "Matrix entry",
            "required": false
          },
          "minItems": 16,
          "maxItems": 16
        },
        "max_distance": {
          "type": "number",
          "description": "Largest point pair distance to trust, in target units. Default from point spacing.",
          "required": false,
          "minimum": 0
        },
        "apply": {
          "type": "boolean",
          "description": "Also return the aligned sources as new geometries. Default true.",
          "required": false
        }
      },
      "price_per_unit": 5
    },
    "compare_geometry": {
      "description": "Compare a scan or mesh with a reference: deviation statistics, percent within tolerance, signed inside or outside deviation for closed references, Chamfer, Hausdorff and F-score, plus a colored deviation map.",
      "properties": {
        "geometry_id": {
          "type": "string",
          "description": "Measured geometry, such as a scan.",
          "required": true
        },
        "reference_geometry_id": {
          "type": "string",
          "description": "Reference geometry, such as the design mesh.",
          "required": true
        },
        "tolerance": {
          "type": "number",
          "description": "Deviation counted as in tolerance, in reference units. Default 0.1 mm.",
          "required": false,
          "minimum": 0
        },
        "align_first": {
          "type": "boolean",
          "description": "Align automatically before comparing. Default false.",
          "required": false
        },
        "f_score_radius": {
          "type": "number",
          "description": "Distance for the F-score. Default tolerance.",
          "required": false,
          "minimum": 0
        },
        "name": {
          "type": "string",
          "description": "Readable name used in file names.",
          "required": false
        }
      },
      "price_per_unit": 5
    },
    "measure_geometry": {
      "description": "Measure a geometry: size and oriented box, area and volume, cross sections, flat faces, wall thickness between parallel faces, distance to another geometry, and convex hull.",
      "properties": {
        "geometry_id": {
          "type": "string",
          "description": "geometry_id returned by inspect_geometry or an earlier action.",
          "required": true
        },
        "measurements": {
          "type": "array",
          "description": "Measurements to take. Default overview.",
          "required": false,
          "items": {
            "type": "object",
            "description": "One measurement",
            "properties": {
              "kind": {
                "type": "string",
                "description": "overview: size, oriented box, area, volume, watertightness. section: outline length and enclosed areas where a plane cuts a mesh. planes: the largest flat regions. thickness: distance between the two best-supported parallel faces. distance: minimum, mean and maximum distance to other_geometry_id. convex_hull: hull volume and area.",
                "required": true,
                "enum": [
                  "overview",
                  "section",
                  "planes",
                  "thickness",
                  "distance",
                  "convex_hull"
                ]
              },
              "plane": {
                "type": "string",
                "description": "Section plane normal axis. Default Z.",
                "required": false,
                "enum": [
                  "X",
                  "Y",
                  "Z"
                ]
              },
              "offset": {
                "type": "number",
                "description": "Section position along the axis. Default the middle.",
                "required": false
              },
              "count": {
                "type": "integer",
                "description": "Number of planes for planes. Default 3.",
                "required": false,
                "minimum": 1,
                "maximum": 20
              },
              "distance_threshold": {
                "type": "number",
                "description": "Distance from a plane to count as on it. Default from point spacing.",
                "required": false,
                "minimum": 0
              },
              "other_geometry_id": {
                "type": "string",
                "description": "Second geometry for distance.",
                "required": false
              }
            },
            "required": false
          },
          "maxItems": 20
        }
      },
      "price_per_unit": 2
    },
    "segment_geometry": {
      "description": "Split a point cloud or mesh into labeled parts: planes, flat patches, clusters, connected pieces, AI scene labels (wall, floor, table, road, building, car and more) or AI 3D object boxes. Returns a labeled geometry for keep_labels, a per-segment summary and a colored preview.",
      "properties": {
        "geometry_id": {
          "type": "string",
          "description": "geometry_id returned by inspect_geometry or an earlier action.",
          "required": true
        },
        "method": {
          "type": "string",
          "description": "planes, planar_patches, clusters, connected_components, semantic (AI labels per point) or objects (AI 3D boxes).",
          "required": true,
          "enum": [
            "planes",
            "planar_patches",
            "clusters",
            "connected_components",
            "semantic",
            "objects"
          ]
        },
        "scene": {
          "type": "string",
          "description": "How the scan was captured; picks the AI model. indoor_room: rooms and buildings. outdoor_street: street-level mobile or terrestrial scans. vehicle_lidar: one sweep from a car-mounted spinning LiDAR with the sensor at the origin (needed for objects).",
          "required": false,
          "enum": [
            "indoor_room",
            "outdoor_street",
            "vehicle_lidar"
          ]
        },
        "model": {
          "type": "string",
          "description": "Override the model chosen from scene.",
          "required": false,
          "enum": [
            "randlanet_s3dis",
            "kpconv_s3dis",
            "pointtransformer_s3dis",
            "sparseconvunet_scannet",
            "randlanet_semantickitti",
            "kpconv_semantickitti",
            "randlanet_toronto3d",
            "kpconv_toronto3d",
            "randlanet_semantic3d",
            "randlanet_parislille3d",
            "kpconv_parislille3d",
            "pointpillars_kitti",
            "pointpillars_waymo",
            "pointrcnn_kitti"
          ]
        },
        "max_segments": {
          "type": "integer",
          "description": "Maximum planes, patches, clusters or pieces. Default 10.",
          "required": false,
          "minimum": 1,
          "maximum": 200
        },
        "distance_threshold": {
          "type": "number",
          "description": "planes: distance to count as on a plane. clusters: neighbor distance. Default from point spacing.",
          "required": false,
          "minimum": 0
        },
        "min_points": {
          "type": "integer",
          "description": "Smallest segment to keep. Default 50.",
          "required": false,
          "minimum": 1
        },
        "min_confidence": {
          "type": "number",
          "description": "objects: lowest box confidence to return. Default 0.5.",
          "required": false,
          "minimum": 0,
          "maximum": 1
        },
        "preview": {
          "type": "boolean",
          "description": "Return a preview image of the result. Default true.",
          "required": false
        },
        "name": {
          "type": "string",
          "description": "Readable name used in file names.",
          "required": false
        }
      },
      "price_per_unit": 5
    },
    "render_geometry": {
      "description": "Render PNG images of one or more geometries together, colored by their own colors (deviation maps, labels), height, normals or a uniform color.",
      "properties": {
        "geometry_ids": {
          "type": "array",
          "description": "Geometries to draw in one scene.",
          "required": true,
          "items": {
            "type": "string",
            "description": "geometry_id",
            "required": false
          },
          "minItems": 1,
          "maxItems": 10
        },
        "views": {
          "type": "array",
          "description": "Views to render. Default iso.",
          "required": false,
          "items": {
            "type": "string",
            "description": "View",
            "required": false,
            "enum": [
              "iso",
              "top",
              "bottom",
              "front",
              "back",
              "left",
              "right"
            ]
          },
          "maxItems": 7
        },
        "direction": {
          "type": "array",
          "description": "Custom view direction from the geometry toward the camera.",
          "required": false,
          "items": {
            "type": "number",
            "description": "Component",
            "required": false
          },
          "minItems": 3,
          "maxItems": 3
        },
        "color_by": {
          "type": "string",
          "description": "Default natural: stored colors such as deviation maps and labels.",
          "required": false,
          "enum": [
            "natural",
            "height",
            "normals",
            "uniform"
          ]
        },
        "point_size": {
          "type": "number",
          "description": "Point size in pixels for point clouds. Default 2.",
          "required": false,
          "minimum": 1,
          "maximum": 10
        },
        "width_px": {
          "type": "integer",
          "description": "Image width. Default 1024.",
          "required": false,
          "minimum": 256,
          "maximum": 2048
        },
        "height_px": {
          "type": "integer",
          "description": "Image height. Default 768.",
          "required": false,
          "minimum": 256,
          "maximum": 2048
        }
      },
      "price_per_unit": 2
    },
    "export_geometry": {
      "description": "Export a geometry to a mesh or point cloud file in the units you choose. glb and gltf are always meters, y-up, as the standard requires.",
      "properties": {
        "geometry_id": {
          "type": "string",
          "description": "geometry_id returned by inspect_geometry or an earlier action.",
          "required": true
        },
        "format": {
          "type": "string",
          "description": "Output format. stl, obj, off, glb and gltf need a mesh.",
          "required": true,
          "enum": [
            "ply",
            "obj",
            "stl",
            "off",
            "glb",
            "gltf",
            "pcd",
            "xyz",
            "xyzn",
            "xyzrgb",
            "pts"
          ]
        },
        "units": {
          "type": "string",
          "description": "Units for the exported coordinates. Default the geometry units.",
          "required": false,
          "enum": [
            "mm",
            "cm",
            "m",
            "in"
          ]
        },
        "binary": {
          "type": "boolean",
          "description": "Write binary where the format allows. Default true.",
          "required": false
        },
        "filename": {
          "type": "string",
          "description": "Base file name without folder or extension.",
          "required": false
        }
      },
      "price_per_unit": 2
    },
    "run_script": {
      "description": "Run custom Open3D Python on your geometries for anything the other actions do not cover. Inputs are variables; publish(name, geometry) returns new geometries and report({...}) returns values.",
      "properties": {
        "script": {
          "type": "string",
          "description": "Python with o3d (open3d) and np (numpy) preloaded; scipy and manifold3d importable. No network access.",
          "required": true
        },
        "inputs": {
          "type": "array",
          "description": "Geometries loaded as Open3D objects under these variable names.",
          "required": false,
          "items": {
            "type": "object",
            "description": "One input",
            "properties": {
              "name": {
                "type": "string",
                "description": "Python variable name.",
                "required": true,
                "maxLength": 64
              },
              "geometry_id": {
                "type": "string",
                "description": "geometry_id to load.",
                "required": true
              }
            },
            "required": false
          },
          "maxItems": 20
        }
      },
      "price_per_unit": 5
    },
    "get_task": {
      "description": "Check work that returned status processing. Completed tasks return the original action result in outputs[0]. Free.",
      "properties": {
        "task_id": {
          "type": "string",
          "description": "task_id from a processing response.",
          "required": true
        },
        "wait_seconds": {
          "type": "integer",
          "description": "Seconds to wait for completion (0-55); use 55 when polling. Default 0.",
          "required": false,
          "minimum": 0,
          "maximum": 55
        }
      },
      "price_per_unit": 0
    },
    "list_tasks": {
      "description": "List your recent tasks with their status and the geometries they produced, newest first. Free.",
      "properties": {
        "limit": {
          "type": "integer",
          "description": "Maximum results. Default 20.",
          "required": false,
          "minimum": 1,
          "maximum": 100
        }
      },
      "price_per_unit": 0
    },
    "cancel_task": {
      "description": "Cancel work that is still processing. Free.",
      "properties": {
        "task_id": {
          "type": "string",
          "description": "task_id from a processing response.",
          "required": true
        }
      },
      "price_per_unit": 0
    }
  }
}
```

### Usage Instructions

# Scan and Mesh Workshop

Load scans, point clouds and meshes, then clean, repair, reconstruct, align, compare, measure, segment, render and export them; every result comes with a quality report and a preview image.

## Workflow

1. `inspect_geometry` with a `file_id` (and `units` for formats without units) returns a `geometry_id`, a report and `next_steps`.
2. Pass that `geometry_id` to other actions. Each action that produces geometry returns new `geometry_id`s; the inputs are never changed.
3. `export_geometry` writes a standard file when you are done.

Units are set once when loading; all later sizes and settings are in the geometry's units. Any action that runs the geometry engine returns its result directly when it finishes within about 20 seconds. Longer work returns `status: "processing"` with a `task_id`; call `get_task` with `wait_seconds: 55` until `completed` (the result is in `outputs[0]`) or `failed`. Tasks are saved before work starts, so they survive server restarts (an interrupted job restarts automatically from the beginning) and wait in a queue when every engine is busy; you never need to resubmit a processing task.

## Actions

### `get_instructions`
Returns this documentation.

### `inspect_geometry`
Required: `file_id` or `geometry_id`. Optional: `units` (mm, cm, m, in; required for stl, obj, ply, off, pcd, xyz, xyzn, xyzrgb, pts), `up_axis` (x, y, z; default y for glb/gltf, z otherwise), `load_as` (auto, mesh, point_cloud), `step_tolerance`, `preview`, `name`. Formats: ply, obj, stl, off, glb, gltf, pcd, xyz, xyzn, xyzrgb, pts, step, stp. Points with missing (NaN or infinite) coordinates are dropped on load and counted in `load_notes.removed_non_finite_points`.

`{"action":"inspect_geometry","file_id":"FILE_ID","units":"mm"}`

### `create_geometry`
Required: `shape` (box, sphere, cylinder, cone, torus, arrow, tetrahedron, octahedron, icosahedron, text, extruded_outline). Sizes: `width`, `depth`, `height`, `radius`, `tube_radius`, `resolution`, `text`, `outline` ([[x, y], ...]), `center`, `units`, `name`.

`{"action":"create_geometry","shape":"extruded_outline","outline":[[0,0],[30,0],[30,10],[10,10],[10,30],[0,30]],"height":5}`

### `process_point_cloud`
Required: `geometry_id`, `steps` (run in order). Operations: voxel_downsample (`size`), uniform_downsample (`every_k`), random_downsample (`ratio`), farthest_point_downsample (`count`), remove_statistical_outliers (`count` neighbors, `ratio`), remove_radius_outliers (`size`, `count`), remove_non_finite, estimate_normals (`size`, `count`; orients them too), orient_normals (`vector`, or automatic when omitted: consistent across the surface, along the plane normal for flat clouds; the method is in `settings`), crop_box (`min`, `max`), keep_labels (`labels` from segment_geometry), hidden_point_removal (`vector`), transform (`matrix`), translate (`vector`), rotate (`vector` axis, `angle_deg`), scale (`factor`), paint (`color`), merge (`geometry_ids`). Omitted settings are derived from the data and reported in `steps[].settings`.

`{"action":"process_point_cloud","geometry_id":"GEOMETRY_ID","steps":[{"operation":"remove_statistical_outliers"},{"operation":"voxel_downsample"},{"operation":"estimate_normals"}]}`

### `process_mesh`
Required: `geometry_id`, `steps`. Operations: weld_vertices (`size`), remove_duplicates, remove_degenerate, remove_non_manifold_edges, orient_triangles (consistent winding; turns an inside-out closed mesh right side out), fill_holes (`mode` smooth or flat, `max_hole_edges`), repair_self_intersections, simplify (`count` target triangles), cluster_simplify (`size`), smooth (`mode` laplacian or taubin, `count`), subdivide (`mode` loop or midpoint, `count`), boolean (`mode` union, difference or intersection, `geometry_ids`), keep_largest_component, remove_small_components (`count`), crop_box, transform, translate, rotate, scale, compute_normals, bake_ambient_occlusion (`count` rays; stored as vertex colors), sample_points (`count`, `mode` uniform or poisson; returns a point cloud), convex_hull, paint.

Smooth hole filling continues the surrounding curvature; large patches are flagged as estimates. Booleans need closed meshes and always return watertight results.

`{"action":"process_mesh","geometry_id":"GEOMETRY_ID","steps":[{"operation":"weld_vertices"},{"operation":"fill_holes","mode":"smooth"},{"operation":"keep_largest_component"}]}`

`{"action":"process_mesh","geometry_id":"PART_ID","steps":[{"operation":"boolean","mode":"difference","geometry_ids":["TOOL_ID"]}]}`

### `reconstruct_surface`
Required: `geometry_id` (point cloud), or `method: "rgbd_fusion"` with `frames` and `camera`. Optional: `method` (auto, poisson, ball_pivoting, alpha_shape, rgbd_fusion), `detail` (low, medium, high), `trim_low_density` (poisson; opens holes), `radius`, `depth_scale`, `depth_max`, `units`, `preview`, `name`. Poisson returns a closed, watertight surface.

`{"action":"reconstruct_surface","geometry_id":"GEOMETRY_ID","method":"poisson","detail":"high"}`

`{"action":"reconstruct_surface","method":"rgbd_fusion","frames":[{"color_file_id":"C1","depth_file_id":"D1"},{"color_file_id":"C2","depth_file_id":"D2"}],"camera":{"width":640,"height":480,"fx":525,"fy":525,"cx":319.5,"cy":239.5}}`

### `register_geometry`
Required: `source_geometry_id`, `target_geometry_id`. Optional: `extra_source_geometry_ids`, `method` (auto, icp_point_to_point, icp_point_to_plane, icp_colored, icp_generalized), `initial_transform` (16 numbers, row by row), `max_distance`, `apply` (default true). Auto needs no starting pose. Returns `transform`, `fitness`, `inlier_rmse`, aligned geometries, an overlay image, and a `warning` when a symmetric part also fits flipped.

`{"action":"register_geometry","source_geometry_id":"SCAN_ID","target_geometry_id":"CAD_ID"}`

### `compare_geometry`
Required: `geometry_id` (measured), `reference_geometry_id`. Optional: `tolerance` (default 0.1 mm), `align_first`, `f_score_radius`, `name`. Returns mean, rms, p95, max, `within_tolerance_percent`, signed inside/outside deviation for closed references, Chamfer, Hausdorff and F-score, plus a colored deviation map (green within tolerance, red extra material, blue missing). F-score also measures coverage, so it is low when the scan is sparser than the radius.

`{"action":"compare_geometry","geometry_id":"SCAN_ID","reference_geometry_id":"CAD_ID","tolerance":0.15,"align_first":true}`

### `measure_geometry`
Required: `geometry_id`. Optional: `measurements` (default overview). Kinds: overview, section (`plane`, `offset`; meshes; returns `enclosed_area` with holes subtracted and separate pieces added, `region_count`, `hole_count`, `outline_length` and each loop's area), planes (`count`, `distance_threshold`), thickness (two best-supported parallel faces), distance (`other_geometry_id`), convex_hull.

`{"action":"measure_geometry","geometry_id":"GEOMETRY_ID","measurements":[{"kind":"thickness"},{"kind":"section","plane":"Z","offset":2.5}]}`

### `segment_geometry`
Required: `geometry_id`, `method` (planes, planar_patches, clusters, connected_components, semantic, objects). Optional: `scene` (indoor_room, outdoor_street, vehicle_lidar), `model`, `max_segments`, `distance_threshold`, `min_points`, `min_confidence`, `preview`, `name`. AI methods need `scene` or `model`; `objects` needs a vehicle_lidar sweep with the sensor at the origin. AI models expect real scans: colors improve indoor and street labels. Returns a labeled geometry for `keep_labels` and a per-segment summary.

`{"action":"segment_geometry","geometry_id":"ROOM_SCAN_ID","method":"semantic","scene":"indoor_room"}`

`{"action":"segment_geometry","geometry_id":"GEOMETRY_ID","method":"planes","max_segments":4}`

### `render_geometry`
Required: `geometry_ids` (1-10, drawn together). Optional: `views` (iso, top, bottom, front, back, left, right), `direction`, `color_by` (natural, height, normals, uniform), `point_size`, `width_px`, `height_px`.

`{"action":"render_geometry","geometry_ids":["SCAN_ID","CAD_ID"],"views":["iso","top"]}`

### `export_geometry`
Required: `geometry_id`, `format` (ply, obj, stl, off, glb, gltf, pcd, xyz, xyzn, xyzrgb, pts). Optional: `units`, `binary`, `filename`. stl, obj, off, glb and gltf need a mesh; glb and gltf are always meters, y-up.

`{"action":"export_geometry","geometry_id":"GEOMETRY_ID","format":"stl","units":"mm"}`

### `run_script`
Required: `script`. Optional: `inputs` (array of `{name, geometry_id}`). `o3d` and `np` are preloaded; inputs are Open3D TriangleMesh or PointCloud objects. Call `publish(name, geometry)` to return geometry and `report({...})` to return values. No network access.

`{"action":"run_script","script":"hull, _ = part.compute_convex_hull()\npublish('hull', hull)\nreport({'hull_volume': hull.get_volume()})","inputs":[{"name":"part","geometry_id":"GEOMETRY_ID"}]}`

### `get_task`
Required: `task_id`. Optional: `wait_seconds` (0-55; returns as soon as the task finishes). `stage` shows progress: queued, loading, the running operation, saving. `restarts` appears if the job was interrupted and restarted.

`{"action":"get_task","task_id":"TASK_ID","wait_seconds":55}`

### `list_tasks`
Optional: `limit` (1-100, default 20).

`{"action":"list_tasks"}`

### `cancel_task`
Required: `task_id`. Stops a queued or running job; returns `cancelled: true` once it has stopped. A job that is already saving its results completes instead (`cancelled: false`). A cancelled job creates nothing.

`{"action":"cancel_task","task_id":"TASK_ID"}`

## Response

Actions that create geometry return `geometries`, each with `geometry_id`, `kind`, `units`, `report` (counts, size, watertight, holes, pieces, self-intersections, volume, point spacing, labels), `next_steps` and `previews`. Exports return `files`; renders return `images`. Every file has `file_id` and `signed_url`. Generated files are kept for 7 days.

## Errors

MESH_UNITS_REQUIRED, MESH_UNSUPPORTED_FORMAT, MESH_LOAD_FAILED, MESH_EMPTY_GEOMETRY, MESH_NOT_A_MESH, MESH_NOT_A_POINT_CLOUD, MESH_INVALID_PARAMETER, MESH_STEP_FAILED, MESH_BOOLEAN_FAILED, MESH_RECONSTRUCTION_FAILED, MESH_REGISTRATION_FAILED, MESH_MODEL_UNAVAILABLE, MESH_MODEL_INPUT_MISMATCH, MESH_MODEL_FAILED, MESH_SCRIPT_ERROR, MESH_WORKSHOP_GEOMETRY_NOT_FOUND, MESH_WORKSHOP_GEOMETRY_EXPIRED, MESH_WORKSHOP_UNSUPPORTED_FILE, GEOMETRY_TIMEOUT, GEOMETRY_MEMORY_LIMIT, GEOMETRY_ENGINE_CRASH, GEOMETRY_INPUT_TOO_LARGE, GEOMETRY_INPUT_EXPIRED, GEOMETRY_WORKER_BUSY, GEOMETRY_WORKER_UNAVAILABLE, GEOMETRY_TASK_NOT_FOUND, GEOMETRY_TASK_INTERRUPTED. Each error includes a `resolution` with the next step.

### Frequently Asked Questions

#### How do I connect this tool to an external agent?

- Page URL: https://www.agentpmt.com/faq
- Markdown URL: https://www.agentpmt.com/faq?format=agent-md

You can install the local MCP server by opening a terminal and running:

```
npm install -g @agentpmt/mcp-router
agentpmt-setup
```

This will connect you to local agents like Claude Code, Windsurf, Grok Build, Cursor, etc.

Alternatively you can connect to the hosted version with this config block, no installation required:

```
{
  "mcpServers": {
    "agentpmt": {
      "type": "streamable-http",
      "url": "https://api.agentpmt.com/mcp",
      "headers": {
        "Authorization": "Bearer <AGENTPMT_BEARER_TOKEN>",
        "x-instance-metadata": "{\"client\":\"generic-mcp\",\"platform\":\"remote\"}"
      }
    }
  }
}
```

[View MCP Connection Instructions](/docs/mcp-reference/connection) for more details.

#### How does an external agent use this tool?

- Page URL: https://www.agentpmt.com/faq
- Markdown URL: https://www.agentpmt.com/faq?format=agent-md

After the external agent is connected to an Agent Group that can use this tool, paste this prompt into the agent:

> Use the AgentPMT-Tool-Search-and-Execution tool. First call action 'get\_instructions' so you know how to use the tool search interface. Then call action 'get\_schema' with tool\_id 6ae3e6dc6b8e2f458be7d95c ("Scan and Mesh Workshop"). After reading the schema and any returned instructions, tell me what this tool can do, we are going to be using it

The agent should fetch the tool schema first, collect the required parameters for your request, and then call the tool through AgentPMT.

#### Are my original files changed?

- Page URL: https://www.agentpmt.com/faq#faq-6ae5e8edb3f999e1dff5a285
- Markdown URL: https://www.agentpmt.com/faq?format=agent-md#faq-6ae5e8edb3f999e1dff5a285
- Tags: Product Specific

No. Every action that produces geometry returns new geometry\_ids and leaves its inputs unchanged, so you can branch, compare and go back. Exports are written as new files in your File Manager.

#### Can I compare a 3D scan with the original CAD design?

- Page URL: https://www.agentpmt.com/faq#faq-6ae5e8ecb3f999e1dff5a282
- Markdown URL: https://www.agentpmt.com/faq?format=agent-md#faq-6ae5e8ecb3f999e1dff5a282
- Tags: Product Specific

Yes. compare\_geometry can align the scan first, then reports mean, RMS, 95th percentile and maximum deviation, the share of the surface within your tolerance, inside or outside deviation for closed references, Chamfer, Hausdorff and F-score, and a colored deviation map: green within tolerance, red for extra material, blue for missing material.

#### Can I run my own Open3D code?

- Page URL: https://www.agentpmt.com/faq#faq-6ae5e8edb3f999e1dff5a287
- Markdown URL: https://www.agentpmt.com/faq?format=agent-md#faq-6ae5e8edb3f999e1dff5a287
- Tags: Product Specific

Yes. run\_script runs Python with Open3D and NumPy preloaded on the geometries you pass in, inside an isolated worker with no network access. Call publish() to return geometry and report() to return values.

#### Can it repair a mesh for 3D printing?

- Page URL: https://www.agentpmt.com/faq#faq-6ae5e8ecb3f999e1dff5a283
- Markdown URL: https://www.agentpmt.com/faq?format=agent-md#faq-6ae5e8ecb3f999e1dff5a283
- Tags: Product Specific

Yes. process\_mesh welds vertices, removes duplicate, degenerate and non-manifold elements, fixes triangle winding, repairs self-intersections and fills holes. Smooth hole filling follows the surrounding curvature and flags large patches as estimates. The quality report shows watertightness, holes and self-intersections before and after.

#### Can it turn a point cloud or depth camera frames into a mesh?

- Page URL: https://www.agentpmt.com/faq#faq-6ae5e8edb3f999e1dff5a286
- Markdown URL: https://www.agentpmt.com/faq?format=agent-md#faq-6ae5e8edb3f999e1dff5a286
- Tags: Product Specific

Yes. reconstruct\_surface builds meshes with Poisson (closed and watertight), ball pivoting or alpha shapes, and rgbd\_fusion fuses color and depth frames into a mesh using the camera intrinsics.

#### How are long jobs handled, and how long are files kept?

- Page URL: https://www.agentpmt.com/faq#faq-6ae5e8edb3f999e1dff5a288
- Markdown URL: https://www.agentpmt.com/faq?format=agent-md#faq-6ae5e8edb3f999e1dff5a288
- Tags: Product Specific

Results come back directly when the work finishes within about 20 seconds. Longer work returns a task\_id: call get\_task with wait\_seconds 55 until it completes. Tasks survive restarts and wait in a queue when every engine is busy, and a job can run for up to 30 minutes. Generated files are kept for 7 days.

#### What can the AI segmentation recognize?

- Page URL: https://www.agentpmt.com/faq#faq-6ae5e8ecb3f999e1dff5a284
- Markdown URL: https://www.agentpmt.com/faq?format=agent-md#faq-6ae5e8ecb3f999e1dff5a284
- Tags: Product Specific

Pretrained Open3D-ML models label indoor scans (walls, floors, ceilings, doors, windows, tables, chairs and other furniture) and street-level scans (roads, sidewalks, buildings, vegetation, poles and vehicles), and find 3D boxes around cars, pedestrians and cyclists in a vehicle LiDAR sweep. Choose the scene and the matching model is picked for you, or name one of the 14 models directly.

#### Which files can I load?

- Page URL: https://www.agentpmt.com/faq#faq-6ae5e8ecb3f999e1dff5a281
- Markdown URL: https://www.agentpmt.com/faq?format=agent-md#faq-6ae5e8ecb3f999e1dff5a281
- Tags: Product Specific

PLY, OBJ, STL, OFF, GLB, glTF, PCD, XYZ, XYZN, XYZRGB and PTS meshes and point clouds, plus STEP and STP. Formats that do not store units (STL, OBJ, PLY, OFF, PCD and the XYZ family) need units when you load them. A job can take up to 2 GB of input files.

### Dependencies

This product has no public dependency products.