altium-toolkit 1.1.33 → 1.1.36

package/src/core/altium/SchematicMultipartOwnerMatcher.mjs

@@ -5,6 +5,8 @@
 import { ParserUtils } from './ParserUtils.mjs'
 
 const { getField, parseBoolean, parseNumericField } = ParserUtils
+const WIRED_PART_MIN_SCORE = 2
+const WIRED_PART_DOMINANCE_RATIO = 2
 
 /**
  * Resolves which multipart symbol section is visible for one schematic owner.
@@ -21,6 +23,10 @@ export class SchematicMultipartOwnerMatcher {
         const partBounds = new Map()
         const ownerBounds = new Map()
         const directOwnerIndexesByRecord = new WeakMap()
+        const ownerlessConnectionPoints =
+            SchematicMultipartOwnerMatcher.#collectOwnerlessConnectionPoints(
+                records
+            )
 
         for (const record of records) {
             const ownerIndex = getField(record.fields, 'OwnerIndex')
@@ -92,11 +98,6 @@ export class SchematicMultipartOwnerMatcher {
                 parseNumericField(record.fields, 'CurrentPartId') || ''
             )
             const partCount = parseNumericField(record.fields, 'PartCount') || 0
-
-            if (!currentPartId || partCount <= 1) {
-                continue
-            }
-
             const directOwnerIndex =
                 SchematicMultipartOwnerMatcher.#findSerializedOwnerIndex(
                     records,
@@ -107,6 +108,11 @@ export class SchematicMultipartOwnerMatcher {
                 continue
             }
 
+            if (!currentPartId || partCount <= 1) {
+                directOwnerIndexesByRecord.set(record, directOwnerIndex)
+                continue
+            }
+
             directOwnerIndexesByRecord.set(record, directOwnerIndex)
         }
 
@@ -120,13 +126,21 @@ export class SchematicMultipartOwnerMatcher {
             const x = parseNumericField(record.fields, 'Location.X')
             const y = parseNumericField(record.fields, 'Location.Y')
             const isMirrored = parseBoolean(record.fields.IsMirrored)
+            const directOwnerIndex = directOwnerIndexesByRecord.get(record)
 
             if (!currentPartId || partCount <= 1 || x === null || y === null) {
+                const inferredPartId =
+                    SchematicMultipartOwnerMatcher.#inferWiredMultipartOwnerPart(
+                        records,
+                        directOwnerIndex,
+                        ownerlessConnectionPoints
+                    )
+                if (directOwnerIndex && inferredPartId) {
+                    activeOwnerParts.set(directOwnerIndex, inferredPartId)
+                }
                 continue
             }
 
-            const directOwnerIndex = directOwnerIndexesByRecord.get(record)
-
             if (directOwnerIndex) {
                 activeOwnerParts.set(directOwnerIndex, currentPartId)
                 continue
@@ -253,6 +267,243 @@ export class SchematicMultipartOwnerMatcher {
         )
     }
 
+    /**
+     * Infers the visible part for malformed multipart owners from routed pin
+     * endpoint evidence. This only applies when one part clearly owns the
+     * external wire connections, avoiding guesses for ambiguous overlaps.
+     * @param {{ fields: Record<string, string | string[]> }[]} records
+     * @param {string | undefined} ownerIndex
+     * @param {{ x: number, y: number }[]} ownerlessConnectionPoints
+     * @returns {string}
+     */
+    static #inferWiredMultipartOwnerPart(
+        records,
+        ownerIndex,
+        ownerlessConnectionPoints
+    ) {
+        const normalizedOwnerIndex = String(ownerIndex || '').trim()
+        if (!normalizedOwnerIndex || !ownerlessConnectionPoints.length) {
+            return ''
+        }
+
+        const scores =
+            SchematicMultipartOwnerMatcher.#scoreWiredMultipartOwnerParts(
+                records,
+                normalizedOwnerIndex,
+                ownerlessConnectionPoints
+            )
+        if (scores.size < 2) {
+            return ''
+        }
+
+        const rankedScores = [...scores.entries()].sort((left, right) => {
+            if (left[1] !== right[1]) {
+                return right[1] - left[1]
+            }
+
+            return Number(left[0]) - Number(right[0])
+        })
+        const [bestPartId, bestScore] = rankedScores[0] || ['', 0]
+        const secondScore = rankedScores[1]?.[1] || 0
+
+        if (bestScore < WIRED_PART_MIN_SCORE) {
+            return ''
+        }
+
+        if (
+            secondScore > 0 &&
+            bestScore < secondScore * WIRED_PART_DOMINANCE_RATIO
+        ) {
+            return ''
+        }
+
+        return bestPartId
+    }
+
+    /**
+     * Scores owner parts by the number of pin endpoints touching ownerless
+     * wire endpoints or vertices.
+     * @param {{ fields: Record<string, string | string[]> }[]} records
+     * @param {string} ownerIndex
+     * @param {{ x: number, y: number }[]} ownerlessConnectionPoints
+     * @returns {Map<string, number>}
+     */
+    static #scoreWiredMultipartOwnerParts(
+        records,
+        ownerIndex,
+        ownerlessConnectionPoints
+    ) {
+        const scores = new Map()
+
+        for (const record of records || []) {
+            if (
+                getField(record.fields, 'RECORD') !== '2' ||
+                getField(record.fields, 'OwnerIndex') !== ownerIndex
+            ) {
+                continue
+            }
+
+            const ownerPartId = getField(record.fields, 'OwnerPartId')
+            if (!ownerPartId || ownerPartId === '-1') {
+                continue
+            }
+
+            if (!scores.has(ownerPartId)) {
+                scores.set(ownerPartId, 0)
+            }
+
+            const endpoint =
+                SchematicMultipartOwnerMatcher.#resolvePinConnectionPoint(
+                    record.fields
+                )
+            if (
+                endpoint &&
+                SchematicMultipartOwnerMatcher.#pointTouchesAnyConnectionPoint(
+                    endpoint,
+                    ownerlessConnectionPoints
+                )
+            ) {
+                scores.set(ownerPartId, scores.get(ownerPartId) + 1)
+            }
+        }
+
+        return scores
+    }
+
+    /**
+     * Collects ownerless schematic wire endpoints and vertices.
+     * @param {{ fields: Record<string, string | string[]> }[]} records
+     * @returns {{ x: number, y: number }[]}
+     */
+    static #collectOwnerlessConnectionPoints(records) {
+        const points = []
+
+        for (const record of records || []) {
+            if (getField(record.fields, 'OwnerIndex')) {
+                continue
+            }
+
+            const recordType = getField(record.fields, 'RECORD')
+            if (
+                recordType === '6' ||
+                recordType === '26' ||
+                recordType === '27'
+            ) {
+                points.push(
+                    ...SchematicMultipartOwnerMatcher.#collectSchematicWirePoints(
+                        record.fields
+                    )
+                )
+                continue
+            }
+
+            if (recordType !== '13') {
+                continue
+            }
+
+            const locationX = parseNumericField(record.fields, 'Location.X')
+            const locationY = parseNumericField(record.fields, 'Location.Y')
+            const cornerX = parseNumericField(record.fields, 'Corner.X')
+            const cornerY = parseNumericField(record.fields, 'Corner.Y')
+
+            if (locationX !== null && locationY !== null) {
+                points.push({ x: locationX, y: locationY })
+            }
+
+            if (cornerX !== null && cornerY !== null) {
+                points.push({ x: cornerX, y: cornerY })
+            }
+        }
+
+        return points
+    }
+
+    /**
+     * Collects polyline vertices while preserving omitted unchanged axes.
+     * @param {Record<string, string | string[]>} fields
+     * @returns {{ x: number, y: number }[]}
+     */
+    static #collectSchematicWirePoints(fields) {
+        const locationCount = parseNumericField(fields, 'LocationCount')
+        const points = []
+        let previousX = null
+        let previousY = null
+
+        if (locationCount === null || locationCount < 2) {
+            return points
+        }
+
+        for (let index = 1; index <= locationCount; index += 1) {
+            const x = parseNumericField(fields, 'X' + index)
+            const y = parseNumericField(fields, 'Y' + index)
+
+            if (x === null && y === null) {
+                break
+            }
+
+            const pointX = x === null ? previousX : x
+            const pointY = y === null ? previousY : y
+
+            if (pointX === null || pointY === null) {
+                break
+            }
+
+            points.push({ x: pointX, y: pointY })
+            previousX = pointX
+            previousY = pointY
+        }
+
+        return points
+    }
+
+    /**
+     * Resolves the external route endpoint for one raw pin record.
+     * @param {Record<string, string | string[]>} fields
+     * @returns {{ x: number, y: number } | null}
+     */
+    static #resolvePinConnectionPoint(fields) {
+        const x = parseNumericField(fields, 'Location.X')
+        const y = parseNumericField(fields, 'Location.Y')
+        const length = parseNumericField(fields, 'PinLength')
+        const orientation =
+            SchematicMultipartOwnerMatcher.#inferPinConnectionOrientation(
+                parseNumericField(fields, 'PinConglomerate')
+            )
+
+        if (x === null || y === null || length === null || !orientation) {
+            return null
+        }
+
+        switch (orientation) {
+            case 'right':
+                return { x: x + length, y }
+            case 'left':
+                return { x: x - length, y }
+            case 'top':
+                return { x, y: y + length }
+            case 'bottom':
+                return { x, y: y - length }
+            default:
+                return null
+        }
+    }
+
+    /**
+     * Returns true when one point matches any known connection point.
+     * @param {{ x: number, y: number }} point
+     * @param {{ x: number, y: number }[]} connectionPoints
+     * @returns {boolean}
+     */
+    static #pointTouchesAnyConnectionPoint(point, connectionPoints) {
+        const tolerance = 0.01
+
+        return connectionPoints.some(
+            (connectionPoint) =>
+                Math.abs(connectionPoint.x - point.x) <= tolerance &&
+                Math.abs(connectionPoint.y - point.y) <= tolerance
+        )
+    }
+
     /**
      * Returns true when one schematic record belongs to the selected visible
      * part for a multipart owner.
@@ -563,4 +814,34 @@ export class SchematicMultipartOwnerMatcher {
                 return null
         }
     }
+
+    /**
+     * Maps raw pin conglomerates into external endpoint orientations.
+     * @param {number | null} conglomerate
+     * @returns {'left' | 'right' | 'top' | 'bottom' | null}
+     */
+    static #inferPinConnectionOrientation(conglomerate) {
+        switch (conglomerate) {
+            case 34:
+            case 42:
+            case 50:
+            case 58:
+                return 'left'
+            case 32:
+            case 40:
+            case 48:
+            case 56:
+                return 'right'
+            case 33:
+            case 49:
+            case 57:
+                return 'top'
+            case 35:
+            case 51:
+            case 59:
+                return 'bottom'
+            default:
+                return null
+        }
+    }
 }

package/src/core/altium/SchematicTextParser.mjs

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 import { ParserUtils } from './ParserUtils.mjs'
+import { SchematicTitleBlockParser } from './SchematicTitleBlockParser.mjs'
 import { SchematicTextRunParser } from './SchematicTextRunParser.mjs'
 import { SchematicTextOrientationResolver } from './SchematicTextOrientationResolver.mjs'
 
@@ -152,13 +153,19 @@ export class SchematicTextParser {
         const rawText = ParserUtils.getDisplayText(fields)
         const recordType = ParserUtils.getField(fields, 'RECORD')
         const ownerIndex = ParserUtils.getField(fields, 'OwnerIndex')
+        const textMetadata = SchematicTextParser.isTitleBlockFooterRecord(
+            fields,
+            sheet.width
+        )
+            ? metadata
+            : SchematicTextParser.#resolveSchematicTextMetadata(
+                  ownerIndex,
+                  metadata,
+                  ownerMetadata
+              )
         const text = SchematicTextParser.#resolveSchematicTemplateText(
             rawText,
-            SchematicTextParser.#resolveSchematicTextMetadata(
-                ownerIndex,
-                metadata,
-                ownerMetadata
-            )
+            textMetadata
         )
         const textRuns = SchematicTextRunParser.parseOptionalOverlineRuns(text)
 
@@ -267,70 +274,12 @@ export class SchematicTextParser {
      * @returns {{ title: string, revision: string, documentNumber: string, sheetNumber: string, sheetTotal: string, date: string, drawnBy: string, footerHints: Partial<Record<'title' | 'documentNumber' | 'revision' | 'sheetNumber' | 'sheetTotal', { x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }>> }}
      */
     static extractSchematicTitleBlock(records, metadata, sheetWidth, fonts) {
-        const footerTexts = records
-            .filter((record) =>
-                SchematicTextParser.isTitleBlockFooterRecord(
-                    record.fields,
-                    sheetWidth
-                )
-            )
-            .map((record) =>
-                SchematicTextParser.#normalizeTitleBlockFooterRecord(
-                    record.fields,
-                    fonts
-                )
-            )
-            .filter(Boolean)
-            .sort((left, right) => right.y - left.y || left.x - right.x)
-        const footerHints =
-            SchematicTextParser.#collectSchematicTitleBlockFooterHints(
-                footerTexts
-            )
-        const numericFooterTexts = footerTexts.filter((record) =>
-            /^\d+$/.test(record.text)
+        return SchematicTitleBlockParser.extract(
+            records,
+            metadata,
+            sheetWidth,
+            fonts
         )
-        const footerDrawnBy =
-            SchematicTextParser.#extractSchematicTitleBlockFooterDrawnBy(
-                footerTexts,
-                metadata
-            )
-
-        return {
-            title:
-                SchematicTextParser.#resolveTitleBlockFooterValue(
-                    footerHints.title?.text,
-                    metadata
-                ) || SchematicTextParser.#cleanMetadataValue(metadata.title),
-            revision:
-                SchematicTextParser.#resolveTitleBlockFooterValue(
-                    footerHints.revision?.text,
-                    metadata
-                ) || SchematicTextParser.#cleanMetadataValue(metadata.revision),
-            documentNumber: SchematicTextParser.#cleanMetadataValue(
-                SchematicTextParser.#resolveTitleBlockFooterValue(
-                    footerHints.documentNumber?.text,
-                    metadata
-                ) || metadata.documentnumber
-            ),
-            sheetNumber:
-                footerHints.sheetNumber?.text ||
-                numericFooterTexts[0]?.text ||
-                SchematicTextParser.#cleanMetadataValue(metadata.sheetnumber),
-            sheetTotal:
-                footerHints.sheetTotal?.text ||
-                numericFooterTexts[1]?.text ||
-                SchematicTextParser.#cleanMetadataValue(metadata.sheettotal),
-            date: SchematicTextParser.#cleanMetadataValue(
-                metadata.currentdate || metadata.date
-            ),
-            drawnBy:
-                SchematicTextParser.#cleanMetadataValue(metadata.drawnby) ||
-                footerDrawnBy,
-            footerHints:
-                SchematicTextParser.#stripSchematicTitleBlockHintText(
-                    footerHints
-                )
-        }
     }
 
     /**
@@ -340,182 +289,7 @@ export class SchematicTextParser {
      * @returns {boolean}
      */
     static isTitleBlockFooterRecord(fields, sheetWidth) {
-        const recordType = ParserUtils.getField(fields, 'RECORD')
-        const x = ParserUtils.parseNumericField(fields, 'Location.X')
-        const y = ParserUtils.parseNumericField(fields, 'Location.Y')
-
-        return (
-            recordType === '4' &&
-            x !== null &&
-            y !== null &&
-            x >= sheetWidth * 0.55 &&
-            y <= 100
-        )
-    }
-
-    /**
-     * Normalizes one visible footer text record into a title-block layout hint.
-     * @param {Record<string, string | string[]>} fields
-     * @param {Record<string, { size: number, family: string, bold: boolean, italic?: boolean, rotation: number }>} fonts
-     * @returns {{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string } | null}
-     */
-    static #normalizeTitleBlockFooterRecord(fields, fonts) {
-        const text = ParserUtils.getDisplayText(fields)
-        const x = ParserUtils.parseNumericField(fields, 'Location.X')
-        const y = ParserUtils.parseNumericField(fields, 'Location.Y')
-
-        if (!text || x === null || y === null) {
-            return null
-        }
-
-        const font =
-            fonts[ParserUtils.getField(fields, 'FontID')] ||
-            SchematicTextParser.#defaultSchematicFont()
-
-        return {
-            text,
-            x,
-            y,
-            color: SchematicTextParser.#resolveSchematicTextColor(
-                fields,
-                ParserUtils.getField(fields, 'RECORD')
-            ),
-            fontSize: font.size,
-            fontFamily: font.family,
-            fontWeight: font.bold ? 700 : 400,
-            ...(font.italic ? { fontStyle: 'italic' } : {})
-        }
-    }
-
-    /**
-     * Maps visible footer rows onto title-block fields.
-     * @param {{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }[]} footerTexts
-     * @returns {Partial<Record<'title' | 'documentNumber' | 'revision' | 'sheetNumber' | 'sheetTotal', { text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }>>}
-     */
-    static #collectSchematicTitleBlockFooterHints(footerTexts) {
-        const rows = SchematicTextParser.#groupTitleBlockFooterRows(footerTexts)
-        const topRow = rows[0] || []
-        const middleRow = rows.length > 2 ? rows[1] || [] : []
-        const sheetRow =
-            [...rows]
-                .reverse()
-                .find(
-                    (row) =>
-                        row.filter((record) => /^\d+$/.test(record.text))
-                            .length >= 2
-                ) || []
-        const numericSheetRow = sheetRow.filter((record) =>
-            /^\d+$/.test(record.text)
-        )
-        const topRowHasVisibleTitleText = topRow.some(
-            (record) => /^\d+$/.test(record.text) === false
-        )
-        const hints = {}
-
-        if (topRow.length && topRowHasVisibleTitleText) {
-            hints.title = topRow[0]
-
-            if (topRow.length > 1) {
-                hints.documentNumber = topRow.at(-1)
-            }
-        }
-
-        if (middleRow.length) {
-            hints.revision = middleRow.at(-1)
-        }
-
-        if (numericSheetRow.length) {
-            hints.sheetNumber = numericSheetRow[0]
-            hints.sheetTotal = numericSheetRow.at(-1)
-        }
-
-        return hints
-    }
-
-    /**
-     * Groups footer texts by their shared baseline row.
-     * @param {{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }[]} footerTexts
-     * @returns {Array<{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }[]>}
-     */
-    static #groupTitleBlockFooterRows(footerTexts) {
-        const tolerance = 8
-        const rows = []
-
-        for (const record of footerTexts) {
-            const currentRow = rows.at(-1)
-
-            if (
-                currentRow &&
-                Math.abs(currentRow[0].y - record.y) <= tolerance
-            ) {
-                currentRow.push(record)
-                currentRow.sort((left, right) => left.x - right.x)
-                continue
-            }
-
-            rows.push([record])
-        }
-
-        return rows
-    }
-
-    /**
-     * Resolves one visible footer placeholder against hidden sheet metadata.
-     * @param {string | undefined} text
-     * @param {Record<string, string>} metadata
-     * @returns {string}
-     */
-    static #resolveTitleBlockFooterValue(text, metadata) {
-        const resolved = SchematicTextParser.#resolveSchematicTemplateText(
-            text,
-            metadata
-        )
-
-        if (String(resolved || '').startsWith('=')) {
-            return ''
-        }
-
-        return SchematicTextParser.#cleanMetadataValue(resolved)
-    }
-
-    /**
-     * Extracts a visible footer `Drawn By` value from the bottom-most footer
-     * row when hidden metadata does not provide one.
-     * @param {{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }[]} footerTexts
-     * @param {Record<string, string>} metadata
-     * @returns {string}
-     */
-    static #extractSchematicTitleBlockFooterDrawnBy(footerTexts, metadata) {
-        const bottomRow =
-            SchematicTextParser.#groupTitleBlockFooterRows(footerTexts).at(
-                -1
-            ) || []
-        const candidates = bottomRow
-            .map((record) =>
-                SchematicTextParser.#resolveTitleBlockFooterValue(
-                    record.text,
-                    metadata
-                )
-            )
-            .filter(
-                (value) => value && /^\d+$/.test(String(value).trim()) === false
-            )
-
-        return candidates.at(-1) || ''
-    }
-
-    /**
-     * Removes the non-rendered text payload from stored footer hints.
-     * @param {Partial<Record<'title' | 'documentNumber' | 'revision' | 'sheetNumber' | 'sheetTotal', { text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }>>} footerHints
-     * @returns {Partial<Record<'title' | 'documentNumber' | 'revision' | 'sheetNumber' | 'sheetTotal', { x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }>>}
-     */
-    static #stripSchematicTitleBlockHintText(footerHints) {
-        return Object.fromEntries(
-            Object.entries(footerHints).map(([key, value]) => {
-                const { text: _text, ...hint } = value
-                return [key, hint]
-            })
-        )
+        return SchematicTitleBlockParser.isFooterRecord(fields, sheetWidth)
     }
 
     /**
@@ -853,15 +627,6 @@ export class SchematicTextParser {
         return Number(size || 10)
     }
 
-    /**
-     * Normalizes placeholder metadata values.
-     * @param {string | undefined} value
-     * @returns {string}
-     */
-    static #cleanMetadataValue(value) {
-        return value && value !== '*' ? value : ''
-    }
-
     /**
      * Adds note box metadata to one decoded schematic note record.
      * @param {{ x: number, y: number, text: string, color: string, hidden: boolean, name: string, ownerIndex?: string, recordType: string, style: number, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string, rotation: number, sourceOrientation?: number, isMirrored?: boolean, anchor: 'start' | 'middle' | 'end' }} textRecord