Absolutely, this kind of targeted automated spline trimming is totally doable with MAXScript! Let’s start by fixing the script error you ran into, then break down a step-by-step plan to trim short segments (like those between intersecting parallel lines or under 1 inch) automatically.

First: Fixing Your Initial Script Error #

The "-- Unknown system exception" happens because splineOps.startTrim requires a valid, active editable spline in the correct sub-object level, plus proper context. Here’s a cleaned-up version of your base script that avoids that error:

---- Kustom Trim Lines
try (closerolloutfloater MainFloater) catch()
Rollout Menu01 "Geometry Ops" (
    button select_trims "Trim all similar"
    on select_trims pressed do (
        -- Make sure we have a selected spline, convert to Editable Spline if needed
        if selection.count == 1 and classof selection[1] != Editable_Spline do (
            convertTo selection[1] Editable_Spline
        )
        -- Set sub-object level to Segments (level 3)
        subObjectLevel = 3
        -- Start trim operation (or hook into our automated logic here)
        splineOps.startTrim selection[1]
    )
)
MainFloater = NewRolloutFloater "Kustom TrimLines" 300 200
addRollout Menu01 MainFloater

This version checks for a valid selected object, converts it to an editable spline if necessary, and targets the specific selected object instead of relying on $, which can cause context issues.

Feasibility of Automated Trimming #

Yes, you absolutely can automate trimming of short segments (under 1 inch) or segments between intersecting parallel lines. The core workflow involves detecting intersections, splitting segments at those points, filtering short segments, and deleting them.

Step-by-Step Implementation Plan #

1. Preprocess the Spline #

• Ensure the target spline is an Editable_Spline (convert if it’s a Spline Shape or other type).
• Enter the Segment sub-object level (level 3) to work with individual segments.

2. Detect Intersections & Split Segments #

Use MAXScript’s built-in spline intersection tools to find all crossing points, then split the segments at those intersections:

• For editable splines, you can use $.intersectSegments() to get a list of intersection points.
• Use splineOps.splitSegment to split each segment at every detected intersection point. This breaks long segments into smaller pieces at every cross point, making it easy to target the short ones between parallels.

3. Filter Short Segments #

Loop through all segments in the spline, calculate their length, and mark any that are shorter than 1 inch (note: convert units if your scene uses a different system):

• Get the segment count with $.numSegments.
• For each segment, use $.getSegmentLength <segmentID> to get its length.
• Compare the length to the 1-inch threshold (use inchesToUnits 1 to get the correct unit value for your scene setup, regardless of current scene units).

4. Delete Marked Segments #

Once you have a list of short segment IDs, select them and delete them using splineOps.delete or directly via the editable spline’s methods:

• Use $.setSegmentSelection <segmentID> to select the short segments.
• Call $.deleteSegment <segmentID> or splineOps.delete() to remove the selected segments.

Example Automated Trimming Code Snippet #

Here’s a quick example of the trimming logic you can add to your button press handler:

on select_trims pressed do (
    -- Preprocess: Ensure valid editable spline
    if selection.count != 1 do (
        messagebox "Please select exactly one spline object!"
        return
    )
    local targetSpline = selection[1]
    if classof targetSpline != Editable_Spline do (
        convertTo targetSpline Editable_Spline
    )

    -- Enter segment sub-object level
    subObjectLevel = 3
    -- Clear any existing selection
    targetSpline.clearSegmentSelection()

    -- Step 1: Find intersections and split segments
    local intersections = targetSpline.intersectSegments()
    for intersect in intersections do (
        -- Split the segment at the intersection point
        splineOps.splitSegment targetSpline intersect.segmentID intersect.pos
    )

    -- Step 2: Filter and mark short segments (under 1 inch)
    local threshold = inchesToUnits 1
    local shortSegments = #()
    for segID in 1 to targetSpline.numSegments do (
        local segLength = targetSpline.getSegmentLength segID
        if segLength < threshold do (
            append shortSegments segID
        )
    )

    -- Step 3: Delete short segments
    if shortSegments.count > 0 do (
        targetSpline.setSegmentSelection shortSegments
        splineOps.delete targetSpline
        messagebox ("Deleted " + shortSegments.count as string + " short segments!")
    ) else (
        messagebox "No short segments found!"
    )
)

Notes for Edge Cases #

• Parallel Lines: To specifically target segments between parallel lines, you’d first need to detect which segments are part of parallel lines (check their slope/angle), then find segments that connect those parallel lines. Add a check for segment angles before filtering for length.
• Multiple Splines: If you want to handle multiple splines at once, adjust the script to loop through all selected objects instead of just one.
• Open vs Closed Splines: Ensure your logic accounts for open splines (avoid deleting segments that would break the spline’s continuity unless that’s your intent).

内容的提问来源于stack exchange，提问作者cnapsys