altium-toolkit 1.1.33 → 1.1.35

package/src/ui/AltiumScene3dAuthoredBodyAnchorAdapter.mjs

@@ -7,7 +7,10 @@ export class AltiumScene3dAuthoredBodyAnchorAdapter {
     static #BODY_ANCHOR_TOLERANCE_MIL = 5
     static #AUTHORED_SOURCE = 'authored-body-anchor'
     static #AUTHORED_ANCHOR_IDENTITY_PATTERN =
-        /(?:^|[^a-z0-9])(?:antenna|coax|connector|edge|header|jack|mechanical|module|mount|shield|sma|socket|usb)(?:$|[^a-z0-9])/i
+        /(?:^|[^a-z0-9])(?:antenna|coax|connector|edge|header|jack|mechanical|module|mount|shield|sma|socket)(?:$|[^a-z0-9])/i
+    static #USB_ANCHOR_IDENTITY_PATTERN = /(?:^|[^a-z0-9])usb(?:$|[^a-z0-9])/i
+    static #INTEGRATED_CIRCUIT_PACKAGE_PATTERN =
+        /(?:^|[^a-z0-9])(?:u?qfn|v?qfn|dfn|qfp|lqfp|tqfp|bga|lga|sop|soic|ssop|tssop|msop|so[-_ ]?\d+)(?:[-_ ]?\d+)?(?:$|[^a-z0-9])/i
 
     /**
      * Marks off-anchor explicit Altium body placements so the runtime does not
@@ -149,11 +152,36 @@ export class AltiumScene3dAuthoredBodyAnchorAdapter {
      * @returns {boolean}
      */
     static #hasAuthoredAnchorIdentity(placement, component) {
-        return AltiumScene3dAuthoredBodyAnchorAdapter.#AUTHORED_ANCHOR_IDENTITY_PATTERN.test(
+        const identityText =
             AltiumScene3dAuthoredBodyAnchorAdapter.#identityText(
                 placement,
                 component
             )
+
+        return (
+            AltiumScene3dAuthoredBodyAnchorAdapter.#AUTHORED_ANCHOR_IDENTITY_PATTERN.test(
+                identityText
+            ) ||
+            AltiumScene3dAuthoredBodyAnchorAdapter.#hasUsbHardwareAnchorIdentity(
+                identityText
+            )
+        )
+    }
+
+    /**
+     * Allows USB connector-like anchors without treating USB interface ICs as
+     * authored mechanical anchors.
+     * @param {string} identityText Searchable package identity.
+     * @returns {boolean}
+     */
+    static #hasUsbHardwareAnchorIdentity(identityText) {
+        return (
+            AltiumScene3dAuthoredBodyAnchorAdapter.#USB_ANCHOR_IDENTITY_PATTERN.test(
+                identityText
+            ) &&
+            !AltiumScene3dAuthoredBodyAnchorAdapter.#INTEGRATED_CIRCUIT_PACKAGE_PATTERN.test(
+                identityText
+            )
         )
     }
 

package/src/ui/AltiumScene3dExternalPlacementAdapter.mjs

@@ -752,8 +752,12 @@ export class AltiumScene3dExternalPlacementAdapter {
             180
         const cos = Math.cos(rotationRad)
         const sin = Math.sin(rotationRad)
-        const x = Number(offset?.x || 0) * cos - Number(offset?.y || 0) * sin
-        const y = Number(offset?.x || 0) * sin + Number(offset?.y || 0) * cos
+        const sourceY =
+            AltiumScene3dExternalPlacementAdapter.#isBottomPlacement(placement)
+                ? -Number(offset?.y || 0)
+                : Number(offset?.y || 0)
+        const x = Number(offset?.x || 0) * cos - sourceY * sin
+        const y = Number(offset?.x || 0) * sin + sourceY * cos
 
         return {
             x: Math.abs(x) < Number.EPSILON ? 0 : Number(x.toFixed(10)),

package/src/ui/AltiumScene3dPlacementRotationPolicy.mjs

@@ -1,3 +1,5 @@
+import { AltiumScene3dTwoRowFootprintDetector } from './AltiumScene3dTwoRowFootprintDetector.mjs'
+
 const PASSIVE_BODY_PATTERN =
     /(?:^|[^a-z0-9])(?:cap|capacitor|res|resistor|ind|inductor|ferrite|bead|crystal|xtal|lqw|lqg)(?:$|[^a-z0-9])/i
 const CHIP_PASSIVE_BODY_PATTERN =
@@ -6,6 +8,8 @@ const LOCAL_Y_CHIP_PASSIVE_MODEL_PATTERN =
     /(?:^|[^a-z0-9])local[-_ ]?y(?:$|[^a-z0-9])/i
 const PIN_ONE_CORNER_PACKAGE_PATTERN =
     /(?:^|[^a-z0-9])(?:[avw]?qfn|vfqfn|wqfn|v?qfp|lqfp|tqfp|pqfp|mqfp)(?:[0-9]+)?(?:$|[^a-z0-9])/i
+const TWO_ROW_PIN_ONE_PACKAGE_PATTERN =
+    /(?:^|[^a-z0-9])(?:msop|qsop|soic|sop|ssop|tssop|tsop|vsop)(?:[-_ ]?\d+)?(?:$|[^a-z0-9])/i
 const FIVE_LEAD_SOT_PATTERN =
     /(?:^|[^a-z0-9])sot[-_ ]?(?:23[-_ ]?5|25|5)(?:$|[^a-z0-9])/i
 const THREE_LEAD_SOT23_PATTERN =
@@ -39,6 +43,9 @@ export class AltiumScene3dPlacementRotationPolicy {
             AltiumScene3dPlacementRotationPolicy.#needsSquarePinOneCorrection(
                 context
             ) ||
+            AltiumScene3dPlacementRotationPolicy.#needsTwoRowPinOneCorrection(
+                context
+            ) ||
             AltiumScene3dPlacementRotationPolicy.#needsFiveLeadSotCorrection(
                 context
             ) ||
@@ -211,6 +218,43 @@ export class AltiumScene3dPlacementRotationPolicy {
         )
     }
 
+    /**
+     * Detects two-row IC packages whose embedded source frame puts the
+     * package pin-one corner opposite the footprint convention.
+     * @param {{ placement?: object, component?: object | null, componentBody?: object | null, pads?: object[] }} context Rotation context.
+     * @returns {boolean}
+     */
+    static #needsTwoRowPinOneCorrection(context) {
+        const { placement, component, componentBody, pads } = context || {}
+        if (
+            !AltiumScene3dPlacementRotationPolicy.#isPadFallback(placement) ||
+            !component ||
+            String(placement?.mountSide || '').toLowerCase() !== 'top' ||
+            AltiumScene3dPlacementRotationPolicy.#isGenericPassiveBody(
+                componentBody
+            ) ||
+            !AltiumScene3dPlacementRotationPolicy.#hasRightAngleModelTilt(
+                componentBody
+            )
+        ) {
+            return false
+        }
+
+        const identityText =
+            AltiumScene3dPlacementRotationPolicy.#packageIdentityText(
+                component,
+                componentBody
+            )
+        if (!TWO_ROW_PIN_ONE_PACKAGE_PATTERN.test(identityText)) {
+            return false
+        }
+
+        return AltiumScene3dTwoRowFootprintDetector.hasTwoRowSurfaceFootprint(
+            component,
+            pads
+        )
+    }
+
     /**
      * Checks whether a source package yaw already matches the footprint and
      * does not need another pin-one half-turn.

package/src/ui/AltiumScene3dRepeatedModelOwnerRepair.mjs

@@ -1,3 +1,5 @@
+import { PcbScene3dPackageDimensionResolver } from './PcbScene3dPackageDimensionResolver.mjs'
+
 const CONNECTOR_TOKENS = new Set([
     'antenna',
     'coax',
@@ -14,9 +16,14 @@ const TIMING_PACKAGE_PATTERN =
     /(?:^|[^a-z0-9])(?:clock|crystal|osc|oscillator|resonator|tcxo|txco|xtal)(?:$|[^a-z0-9])/i
 const TIMING_DESIGNATOR_PATTERN = /^(?:y|xo)\d+[a-z]?$/i
 const AUTHORED_ANCHOR_IDENTITY_PATTERN =
-    /(?:^|[^a-z0-9])(?:antenna|coax|connector|edge|header|jack|mechanical|module|mount|shield|sma|socket|usb)(?:$|[^a-z0-9])/i
+    /(?:^|[^a-z0-9])(?:antenna|coax|connector|edge|header|jack|mechanical|module|mount|shield|sma|socket)(?:$|[^a-z0-9])/i
 const PAD_FALLBACK_AUTHORED_ANCHOR_PATTERN =
-    /(?:^|[^a-z0-9])(?:antenna|coax|conn|connector|edge|flex|fpc|frame|hardware|header|jack|mechanical|module|shield|sma|socket|usb)(?:$|[^a-z0-9])/i
+    /(?:^|[^a-z0-9])(?:antenna|coax|conn|connector|edge|flex|fpc|frame|hardware|header|jack|mechanical|module|shield|sma|socket)(?:$|[^a-z0-9])/i
+const USB_ANCHOR_IDENTITY_PATTERN = /(?:^|[^a-z0-9])usb(?:$|[^a-z0-9])/i
+const INTEGRATED_CIRCUIT_PACKAGE_PATTERN =
+    /(?:^|[^a-z0-9])(?:u?qfn|v?qfn|dfn|qfp|lqfp|tqfp|bga|lga|sop|soic|ssop|tssop|msop|so[-_ ]?\d+)(?:[-_ ]?\d+)?(?:$|[^a-z0-9])/i
+const SHIELD_COVER_TOKEN_PATTERN =
+    /(?:^|[^a-z0-9])(?:rf|emi|rfi|shield|cover)(?:$|[^a-z0-9])/gi
 
 /**
  * Repairs repeated Altium model-anchor bodies by matching their shared source
@@ -228,8 +235,20 @@ export class AltiumScene3dRepeatedModelOwnerRepair {
             String(placement?.projection?.source || '').toLowerCase() ===
             'pad-fallback'
         ) {
+            if (
+                AltiumScene3dRepeatedModelOwnerRepair.#hasShieldCoverSourceOriginOffset(
+                    placement,
+                    component,
+                    identityText
+                )
+            ) {
+                return false
+            }
+
             return (
-                PAD_FALLBACK_AUTHORED_ANCHOR_PATTERN.test(identityText) ||
+                AltiumScene3dRepeatedModelOwnerRepair.#hasPadFallbackAuthoredAnchorIdentity(
+                    identityText
+                ) ||
                 AltiumScene3dRepeatedModelOwnerRepair.#hasCompactIcSourceOriginOffset(
                     placement,
                     component,
@@ -238,7 +257,149 @@ export class AltiumScene3dRepeatedModelOwnerRepair {
             )
         }
 
-        return AUTHORED_ANCHOR_IDENTITY_PATTERN.test(identityText)
+        return AltiumScene3dRepeatedModelOwnerRepair.#hasAuthoredAnchorIdentity(
+            identityText
+        )
+    }
+
+    /**
+     * Checks whether pad-fallback identity describes an authored hardware
+     * anchor instead of a source-origin-biased IC body.
+     * @param {string} identityText Searchable package identity.
+     * @returns {boolean}
+     */
+    static #hasPadFallbackAuthoredAnchorIdentity(identityText) {
+        return (
+            PAD_FALLBACK_AUTHORED_ANCHOR_PATTERN.test(identityText) ||
+            AltiumScene3dRepeatedModelOwnerRepair.#hasUsbHardwareAnchorIdentity(
+                identityText
+            )
+        )
+    }
+
+    /**
+     * Checks whether non-pad-fallback identity describes authored hardware.
+     * @param {string} identityText Searchable package identity.
+     * @returns {boolean}
+     */
+    static #hasAuthoredAnchorIdentity(identityText) {
+        return (
+            AUTHORED_ANCHOR_IDENTITY_PATTERN.test(identityText) ||
+            AltiumScene3dRepeatedModelOwnerRepair.#hasUsbHardwareAnchorIdentity(
+                identityText
+            )
+        )
+    }
+
+    /**
+     * Allows USB connector-like anchors without treating USB interface ICs as
+     * authored mechanical anchors.
+     * @param {string} identityText Searchable package identity.
+     * @returns {boolean}
+     */
+    static #hasUsbHardwareAnchorIdentity(identityText) {
+        return (
+            USB_ANCHOR_IDENTITY_PATTERN.test(identityText) &&
+            !INTEGRATED_CIRCUIT_PACKAGE_PATTERN.test(identityText)
+        )
+    }
+
+    /**
+     * Checks whether a shield cover body origin is a package corner.
+     * @param {object} placement Scene placement.
+     * @param {object} component PCB component.
+     * @param {string} identityText Searchable package identity.
+     * @returns {boolean}
+     */
+    static #hasShieldCoverSourceOriginOffset(
+        placement,
+        component,
+        identityText
+    ) {
+        const tokens = new Set(
+            [...String(identityText || '').matchAll(SHIELD_COVER_TOKEN_PATTERN)]
+                .map((match) => String(match[0] || '').toLowerCase())
+                .map((token) => token.replace(/[^a-z0-9]+/giu, ''))
+        )
+        if (
+            !tokens.has('cover') ||
+            !['rf', 'emi', 'rfi', 'shield'].some((token) => tokens.has(token))
+        ) {
+            return false
+        }
+
+        const size =
+            PcbScene3dPackageDimensionResolver.resolvePlanarSize(component)
+        if (!size) {
+            return false
+        }
+
+        const offset = {
+            x:
+                Number(placement?.bodyPositionMil?.x || 0) -
+                Number(component?.x || 0),
+            y:
+                Number(placement?.bodyPositionMil?.y || 0) -
+                Number(component?.y || 0)
+        }
+        if (
+            !Number.isFinite(offset.x) ||
+            !Number.isFinite(offset.y) ||
+            Math.hypot(offset.x, offset.y) <=
+                AltiumScene3dRepeatedModelOwnerRepair
+                    .#MIN_PAD_FALLBACK_OWNER_OFFSET_MIL
+        ) {
+            return false
+        }
+
+        return AltiumScene3dRepeatedModelOwnerRepair.#matchesCornerOriginSize(
+            Math.abs(offset.x) * 2,
+            Math.abs(offset.y) * 2,
+            size
+        )
+    }
+
+    /**
+     * Checks whether doubled owner offset matches package dimensions.
+     * @param {number} offsetWidth Doubled X offset.
+     * @param {number} offsetDepth Doubled Y offset.
+     * @param {{ width: number, depth: number }} size Explicit package size.
+     * @returns {boolean}
+     */
+    static #matchesCornerOriginSize(offsetWidth, offsetDepth, size) {
+        return (
+            (AltiumScene3dRepeatedModelOwnerRepair.#matchesDimension(
+                offsetWidth,
+                size.width
+            ) &&
+                AltiumScene3dRepeatedModelOwnerRepair.#matchesDimension(
+                    offsetDepth,
+                    size.depth
+                )) ||
+            (AltiumScene3dRepeatedModelOwnerRepair.#matchesDimension(
+                offsetWidth,
+                size.depth
+            ) &&
+                AltiumScene3dRepeatedModelOwnerRepair.#matchesDimension(
+                    offsetDepth,
+                    size.width
+                ))
+        )
+    }
+
+    /**
+     * Checks whether two dimensions are close enough for source-origin repair.
+     * @param {number} actual Actual dimension.
+     * @param {number} expected Expected dimension.
+     * @returns {boolean}
+     */
+    static #matchesDimension(actual, expected) {
+        if (!Number.isFinite(actual) || !Number.isFinite(expected)) {
+            return false
+        }
+
+        const tolerance = Math.max(35, Math.abs(expected) * 0.08)
+        return Math.abs(actual - expected) <= tolerance
     }
 
     /**
@@ -557,8 +718,12 @@ export class AltiumScene3dRepeatedModelOwnerRepair {
             180
         const cos = Math.cos(rotationRad)
         const sin = Math.sin(rotationRad)
-        const x = Number(offset?.x || 0) * cos - Number(offset?.y || 0) * sin
-        const y = Number(offset?.x || 0) * sin + Number(offset?.y || 0) * cos
+        const sourceY =
+            AltiumScene3dRepeatedModelOwnerRepair.#isBottomPlacement(placement)
+                ? -Number(offset?.y || 0)
+                : Number(offset?.y || 0)
+        const x = Number(offset?.x || 0) * cos - sourceY * sin
+        const y = Number(offset?.x || 0) * sin + sourceY * cos
         const z = Number(
             modelTransform?.offsetMil?.z ?? modelTransform?.dzMil ?? 0
         )

package/src/ui/AltiumScene3dShapeStackOwnerAdapter.mjs

@@ -7,6 +7,7 @@ const TIMING_DESIGNATOR_PATTERN = /^(?:y|xo)\d+[a-z]?$/i
  */
 export class AltiumScene3dShapeStackOwnerAdapter {
     static #BASE_OWNER_TOLERANCE_MIL = 60
+    static #EXACT_OWNER_TOLERANCE_MIL = 1
     static #STACK_BODY_RADIUS_MIL = 220
     static #HEIGHT_TOLERANCE_MIL = 0.1
 
@@ -69,7 +70,8 @@ export class AltiumScene3dShapeStackOwnerAdapter {
                 AltiumScene3dShapeStackOwnerAdapter.#repairStaticPlacements(
                     sceneDescription.staticBodyPlacements,
                     componentBodies,
-                    assignments
+                    assignments,
+                    sceneDescription.board
                 )
         }
     }
@@ -146,9 +148,15 @@ export class AltiumScene3dShapeStackOwnerAdapter {
      * @param {object[] | undefined} placements Scene static body placements.
      * @param {object[]} componentBodies Source component-body rows.
      * @param {object[]} assignments Carrier assignments.
+     * @param {object | undefined} board Scene board metadata.
      * @returns {object[]}
      */
-    static #repairStaticPlacements(placements, componentBodies, assignments) {
+    static #repairStaticPlacements(
+        placements,
+        componentBodies,
+        assignments,
+        board
+    ) {
         return (Array.isArray(placements) ? placements : []).map(
             (placement) => {
                 const assignment = assignments.find((candidate) =>
@@ -164,12 +172,37 @@ export class AltiumScene3dShapeStackOwnerAdapter {
                 return {
                     ...placement,
                     designator: String(assignment.owner.designator || ''),
+                    positionMil:
+                        AltiumScene3dShapeStackOwnerAdapter.#withOwnerAnchor(
+                            placement?.positionMil,
+                            assignment.owner,
+                            board
+                        ),
                     coLocatedVariantGroupKey: assignment.groupKey
                 }
             }
         )
     }
 
+    /**
+     * Re-anchors a repaired static carrier on the owning component position.
+     * @param {object | undefined} position Existing render position.
+     * @param {{ x?: number, y?: number }} owner Owner component.
+     * @param {object | undefined} board Scene board metadata.
+     * @returns {{ x: number, y: number, z: number }}
+     */
+    static #withOwnerAnchor(position, owner, board) {
+        return {
+            ...(position || {}),
+            x: AltiumScene3dShapeStackOwnerAdapter.#round(
+                Number(owner?.x || 0) - Number(board?.centerX || 0)
+            ),
+            y: AltiumScene3dShapeStackOwnerAdapter.#round(
+                Number(owner?.y || 0) - Number(board?.centerY || 0)
+            )
+        }
+    }
+
     /**
      * Builds carrier-base to owner-component assignments.
      * @param {object[]} componentBodies Source component-body rows.
@@ -187,6 +220,15 @@ export class AltiumScene3dShapeStackOwnerAdapter {
             AltiumScene3dShapeStackOwnerAdapter.#groupCarrierBases(bases)
 
         return groups.flatMap((group) => {
+            if (
+                AltiumScene3dShapeStackOwnerAdapter.#hasExactNonTimingOwner(
+                    group.anchor,
+                    components
+                )
+            ) {
+                return []
+            }
+
             const owners = timingComponents
                 .filter(
                     (component) =>
@@ -242,6 +284,39 @@ export class AltiumScene3dShapeStackOwnerAdapter {
         })
     }
 
+    /**
+     * Checks whether one carrier base already sits on a non-timing component.
+     * @param {{ x?: number, y?: number }} anchor Carrier base anchor.
+     * @param {object[]} components Source components.
+     * @returns {boolean}
+     */
+    static #hasExactNonTimingOwner(anchor, components) {
+        const exactOwners = (
+            Array.isArray(components) ? components : []
+        ).filter(
+            (component) =>
+                AltiumScene3dShapeStackOwnerAdapter.#distance(
+                    anchor,
+                    component
+                ) <=
+                AltiumScene3dShapeStackOwnerAdapter.#EXACT_OWNER_TOLERANCE_MIL
+        )
+
+        return (
+            exactOwners.some(
+                (component) =>
+                    !AltiumScene3dShapeStackOwnerAdapter.#isTimingComponent(
+                        component
+                    )
+            ) &&
+            !exactOwners.some((component) =>
+                AltiumScene3dShapeStackOwnerAdapter.#isTimingComponent(
+                    component
+                )
+            )
+        )
+    }
+
     /**
      * Groups carrier bases that share one source anchor.
      * @param {object[]} bases Candidate carrier bases.
@@ -469,7 +544,11 @@ export class AltiumScene3dShapeStackOwnerAdapter {
         return (
             componentBodies
                 .filter(
-                    (componentBody) => !usedComponentBodies.has(componentBody)
+                    (componentBody) =>
+                        !usedComponentBodies.has(componentBody) &&
+                        !AltiumScene3dShapeStackOwnerAdapter.#isCarrierBase(
+                            componentBody
+                        )
                 )
                 .map((componentBody) => ({
                     componentBody,

package/src/ui/AltiumScene3dTwoRowFootprintDetector.mjs

@@ -0,0 +1,90 @@
+/**
+ * Detects two-row surface-mount footprints from normalized PCB pads.
+ */
+export class AltiumScene3dTwoRowFootprintDetector {
+    /**
+     * Checks whether a component owns a symmetric two-row surface footprint.
+     * @param {object} component PCB component.
+     * @param {object[]} pads Source PCB pads.
+     * @returns {boolean}
+     */
+    static hasTwoRowSurfaceFootprint(component, pads) {
+        const surfacePads = AltiumScene3dTwoRowFootprintDetector.#surfacePads(
+            component,
+            pads
+        )
+        if (surfacePads.length < 6) {
+            return false
+        }
+
+        const xSpread = AltiumScene3dTwoRowFootprintDetector.#spread(
+            surfacePads,
+            'x'
+        )
+        const ySpread = AltiumScene3dTwoRowFootprintDetector.#spread(
+            surfacePads,
+            'y'
+        )
+        const rowAxis = xSpread >= ySpread ? 'y' : 'x'
+        const lineAxis = rowAxis === 'x' ? 'y' : 'x'
+        const rowSpread = AltiumScene3dTwoRowFootprintDetector.#spread(
+            surfacePads,
+            rowAxis
+        )
+        const lineSpread = AltiumScene3dTwoRowFootprintDetector.#spread(
+            surfacePads,
+            lineAxis
+        )
+        if (rowSpread <= 0 || lineSpread <= 0) {
+            return false
+        }
+
+        const values = surfacePads.map((pad) => Number(pad?.[rowAxis] || 0))
+        const midpoint = (Math.min(...values) + Math.max(...values)) / 2
+        const lowerCount = values.filter((value) => value <= midpoint).length
+        const upperCount = values.length - lowerCount
+
+        return Math.min(lowerCount, upperCount) >= 3
+    }
+
+    /**
+     * Collects surface pads owned by one component.
+     * @param {object} component PCB component.
+     * @param {object[]} pads Source PCB pads.
+     * @returns {object[]}
+     */
+    static #surfacePads(component, pads) {
+        const componentIndex = Number(component?.componentIndex)
+        if (!Number.isFinite(componentIndex)) {
+            return []
+        }
+
+        const ownedPads = (Array.isArray(pads) ? pads : []).filter(
+            (pad) => Number(pad?.componentIndex) === componentIndex
+        )
+        const bottom =
+            String(component?.layer || '')
+                .toUpperCase()
+                .includes('BOTTOM') ||
+            String(component?.layer || '').toUpperCase() === 'BOT'
+        const surfacePads = ownedPads.filter((pad) =>
+            bottom
+                ? Boolean(pad?.hasBottomPasteMaskOpening)
+                : Boolean(pad?.hasTopPasteMaskOpening)
+        )
+
+        return surfacePads.length ? surfacePads : ownedPads
+    }
+
+    /**
+     * Measures pad center spread on one axis.
+     * @param {object[]} pads Source PCB pads.
+     * @param {'x' | 'y'} axis Axis key.
+     * @returns {number}
+     */
+    static #spread(pads, axis) {
+        const values = pads.map((pad) => Number(pad?.[axis] || 0))
+
+        return Math.max(...values) - Math.min(...values)
+    }
+}